2 Unix SMB/CIFS implementation.
4 SMB2 composite connection setup
6 Copyright (C) Andrew Tridgell 2005
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/>.
24 #include "lib/util/tevent_ntstatus.h"
25 #include "libcli/raw/libcliraw.h"
26 #include "libcli/raw/raw_proto.h"
27 #include "libcli/smb2/smb2.h"
28 #include "libcli/smb2/smb2_calls.h"
29 #include "libcli/composite/composite.h"
30 #include "libcli/resolve/resolve.h"
31 #include "param/param.h"
33 struct smb2_connect_state
{
34 struct tevent_context
*ev
;
35 struct cli_credentials
*credentials
;
36 struct resolve_context
*resolve_ctx
;
40 const char *socket_options
;
41 struct gensec_settings
*gensec_settings
;
42 struct smbcli_options options
;
43 struct smb2_negprot negprot
;
44 struct smb2_tree_connect tcon
;
45 struct smb2_session
*session
;
46 struct smb2_tree
*tree
;
49 static void smb2_connect_resolve_done(struct composite_context
*creq
);
52 a composite function that does a full negprot/sesssetup/tcon, returning
55 struct tevent_req
*smb2_connect_send(TALLOC_CTX
*mem_ctx
,
56 struct tevent_context
*ev
,
60 struct resolve_context
*resolve_ctx
,
61 struct cli_credentials
*credentials
,
62 struct smbcli_options
*options
,
63 const char *socket_options
,
64 struct gensec_settings
*gensec_settings
)
66 struct tevent_req
*req
;
67 struct smb2_connect_state
*state
;
69 struct composite_context
*creq
;
71 req
= tevent_req_create(mem_ctx
, &state
,
72 struct smb2_connect_state
);
78 state
->credentials
= credentials
;
79 state
->options
= *options
;
83 state
->resolve_ctx
= resolve_ctx
;
84 state
->socket_options
= socket_options
;
85 state
->gensec_settings
= gensec_settings
;
90 creq
= resolve_name_send(resolve_ctx
, state
, &name
, ev
);
91 if (tevent_req_nomem(creq
, req
)) {
92 return tevent_req_post(req
, ev
);
94 creq
->async
.fn
= smb2_connect_resolve_done
;
95 creq
->async
.private_data
= req
;
99 static void smb2_connect_socket_done(struct composite_context
*creq
);
101 static void smb2_connect_resolve_done(struct composite_context
*creq
)
103 struct tevent_req
*req
=
104 talloc_get_type_abort(creq
->async
.private_data
,
106 struct smb2_connect_state
*state
=
108 struct smb2_connect_state
);
112 const char *default_ports
[] = { "445", NULL
};
114 status
= resolve_name_recv(creq
, state
, &addr
);
115 if (tevent_req_nterror(req
, status
)) {
119 if (state
->ports
== NULL
) {
120 ports
= default_ports
;
122 ports
= state
->ports
;
125 creq
= smbcli_sock_connect_send(state
, addr
, ports
,
126 state
->host
, state
->resolve_ctx
,
127 state
->ev
, state
->socket_options
);
128 if (tevent_req_nomem(creq
, req
)) {
131 creq
->async
.fn
= smb2_connect_socket_done
;
132 creq
->async
.private_data
= req
;
135 static void smb2_connect_negprot_done(struct smb2_request
*smb2req
);
137 static void smb2_connect_socket_done(struct composite_context
*creq
)
139 struct tevent_req
*req
=
140 talloc_get_type_abort(creq
->async
.private_data
,
142 struct smb2_connect_state
*state
=
144 struct smb2_connect_state
);
145 struct smbcli_socket
*sock
;
146 struct smb2_transport
*transport
;
147 struct smb2_request
*smb2req
;
149 uint16_t dialects
[3] = {
150 SMB2_DIALECT_REVISION_000
,
151 SMB2_DIALECT_REVISION_202
,
152 SMB2_DIALECT_REVISION_210
155 status
= smbcli_sock_connect_recv(creq
, state
, &sock
);
156 if (tevent_req_nterror(req
, status
)) {
160 transport
= smb2_transport_init(sock
, state
, &state
->options
);
161 if (tevent_req_nomem(transport
, req
)) {
165 ZERO_STRUCT(state
->negprot
);
166 state
->negprot
.in
.dialect_count
= ARRAY_SIZE(dialects
);
167 switch (transport
->options
.signing
) {
168 case SMB_SIGNING_OFF
:
169 state
->negprot
.in
.security_mode
= 0;
171 case SMB_SIGNING_DEFAULT
:
172 case SMB_SIGNING_SUPPORTED
:
173 case SMB_SIGNING_AUTO
:
174 state
->negprot
.in
.security_mode
= SMB2_NEGOTIATE_SIGNING_ENABLED
;
176 case SMB_SIGNING_REQUIRED
:
177 state
->negprot
.in
.security_mode
=
178 SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
;
181 state
->negprot
.in
.capabilities
= 0;
182 unix_to_nt_time(&state
->negprot
.in
.start_time
, time(NULL
));
183 state
->negprot
.in
.dialects
= dialects
;
185 smb2req
= smb2_negprot_send(transport
, &state
->negprot
);
186 if (tevent_req_nomem(smb2req
, req
)) {
189 smb2req
->async
.fn
= smb2_connect_negprot_done
;
190 smb2req
->async
.private_data
= req
;
193 static void smb2_connect_session_done(struct tevent_req
*subreq
);
195 static void smb2_connect_negprot_done(struct smb2_request
*smb2req
)
197 struct tevent_req
*req
=
198 talloc_get_type_abort(smb2req
->async
.private_data
,
200 struct smb2_connect_state
*state
=
202 struct smb2_connect_state
);
203 struct smb2_transport
*transport
= smb2req
->transport
;
204 struct tevent_req
*subreq
;
207 status
= smb2_negprot_recv(smb2req
, state
, &state
->negprot
);
208 if (tevent_req_nterror(req
, status
)) {
212 transport
->negotiate
.secblob
= state
->negprot
.out
.secblob
;
213 talloc_steal(transport
, transport
->negotiate
.secblob
.data
);
214 transport
->negotiate
.system_time
= state
->negprot
.out
.system_time
;
215 transport
->negotiate
.server_start_time
= state
->negprot
.out
.server_start_time
;
216 transport
->negotiate
.security_mode
= state
->negprot
.out
.security_mode
;
217 transport
->negotiate
.dialect_revision
= state
->negprot
.out
.dialect_revision
;
219 switch (transport
->options
.signing
) {
220 case SMB_SIGNING_OFF
:
221 if (transport
->negotiate
.security_mode
& SMB2_NEGOTIATE_SIGNING_REQUIRED
) {
222 tevent_req_nterror(req
, NT_STATUS_ACCESS_DENIED
);
225 transport
->signing_required
= false;
227 case SMB_SIGNING_DEFAULT
:
228 case SMB_SIGNING_SUPPORTED
:
229 case SMB_SIGNING_AUTO
:
230 if (transport
->negotiate
.security_mode
& SMB2_NEGOTIATE_SIGNING_REQUIRED
) {
231 transport
->signing_required
= true;
233 transport
->signing_required
= false;
236 case SMB_SIGNING_REQUIRED
:
237 if (transport
->negotiate
.security_mode
& SMB2_NEGOTIATE_SIGNING_ENABLED
) {
238 transport
->signing_required
= true;
240 tevent_req_nterror(req
, NT_STATUS_ACCESS_DENIED
);
246 state
->session
= smb2_session_init(transport
, state
->gensec_settings
, state
, true);
247 if (tevent_req_nomem(state
->session
, req
)) {
251 subreq
= smb2_session_setup_spnego_send(state
, state
->ev
,
254 if (tevent_req_nomem(subreq
, req
)) {
257 tevent_req_set_callback(subreq
, smb2_connect_session_done
, req
);
260 static void smb2_connect_tcon_done(struct smb2_request
*smb2req
);
262 static void smb2_connect_session_done(struct tevent_req
*subreq
)
264 struct tevent_req
*req
=
265 tevent_req_callback_data(subreq
,
267 struct smb2_connect_state
*state
=
269 struct smb2_connect_state
);
270 struct smb2_request
*smb2req
;
273 status
= smb2_session_setup_spnego_recv(subreq
);
275 if (tevent_req_nterror(req
, status
)) {
279 state
->tree
= smb2_tree_init(state
->session
, state
, true);
280 if (tevent_req_nomem(state
->tree
, req
)) {
284 state
->tcon
.in
.reserved
= 0;
285 state
->tcon
.in
.path
= talloc_asprintf(state
, "\\\\%s\\%s",
286 state
->host
, state
->share
);
287 if (tevent_req_nomem(state
->tcon
.in
.path
, req
)) {
291 smb2req
= smb2_tree_connect_send(state
->tree
, &state
->tcon
);
292 if (tevent_req_nomem(smb2req
, req
)) {
295 smb2req
->async
.fn
= smb2_connect_tcon_done
;
296 smb2req
->async
.private_data
= req
;
299 static void smb2_connect_tcon_done(struct smb2_request
*smb2req
)
301 struct tevent_req
*req
=
302 talloc_get_type_abort(smb2req
->async
.private_data
,
304 struct smb2_connect_state
*state
=
306 struct smb2_connect_state
);
309 status
= smb2_tree_connect_recv(smb2req
, &state
->tcon
);
310 if (tevent_req_nterror(req
, status
)) {
314 state
->tree
->tid
= state
->tcon
.out
.tid
;
316 tevent_req_done(req
);
319 NTSTATUS
smb2_connect_recv(struct tevent_req
*req
,
321 struct smb2_tree
**tree
)
323 struct smb2_connect_state
*state
=
325 struct smb2_connect_state
);
328 if (tevent_req_is_nterror(req
, &status
)) {
329 tevent_req_received(req
);
333 *tree
= talloc_move(mem_ctx
, &state
->tree
);
335 tevent_req_received(req
);
340 sync version of smb2_connect
342 NTSTATUS
smb2_connect(TALLOC_CTX
*mem_ctx
,
346 struct resolve_context
*resolve_ctx
,
347 struct cli_credentials
*credentials
,
348 struct smb2_tree
**tree
,
349 struct tevent_context
*ev
,
350 struct smbcli_options
*options
,
351 const char *socket_options
,
352 struct gensec_settings
*gensec_settings
)
354 struct tevent_req
*subreq
;
357 TALLOC_CTX
*frame
= talloc_stackframe();
360 return NT_STATUS_NO_MEMORY
;
363 subreq
= smb2_connect_send(frame
,
373 if (subreq
== NULL
) {
375 return NT_STATUS_NO_MEMORY
;
378 ok
= tevent_req_poll(subreq
, ev
);
380 status
= map_nt_error_from_unix_common(errno
);
385 status
= smb2_connect_recv(subreq
, mem_ctx
, tree
);
387 if (!NT_STATUS_IS_OK(status
)) {