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/>.
23 #include "libcli/raw/libcliraw.h"
24 #include "libcli/raw/raw_proto.h"
25 #include "libcli/smb2/smb2.h"
26 #include "libcli/smb2/smb2_calls.h"
27 #include "libcli/composite/composite.h"
28 #include "libcli/resolve/resolve.h"
29 #include "param/param.h"
31 struct smb2_connect_state
{
32 struct cli_credentials
*credentials
;
33 struct resolve_context
*resolve_ctx
;
37 const char *socket_options
;
38 struct gensec_settings
*gensec_settings
;
39 struct smbcli_options options
;
40 struct smb2_negprot negprot
;
41 struct smb2_tree_connect tcon
;
42 struct smb2_session
*session
;
43 struct smb2_tree
*tree
;
47 continue after tcon reply
49 static void continue_tcon(struct smb2_request
*req
)
51 struct composite_context
*c
= talloc_get_type(req
->async
.private_data
,
52 struct composite_context
);
53 struct smb2_connect_state
*state
= talloc_get_type(c
->private_data
,
54 struct smb2_connect_state
);
56 c
->status
= smb2_tree_connect_recv(req
, &state
->tcon
);
57 if (!composite_is_ok(c
)) return;
59 state
->tree
->tid
= state
->tcon
.out
.tid
;
65 continue after a session setup
67 static void continue_session(struct composite_context
*creq
)
69 struct composite_context
*c
= talloc_get_type(creq
->async
.private_data
,
70 struct composite_context
);
71 struct smb2_connect_state
*state
= talloc_get_type(c
->private_data
,
72 struct smb2_connect_state
);
73 struct smb2_request
*req
;
75 c
->status
= smb2_session_setup_spnego_recv(creq
);
76 if (!composite_is_ok(c
)) return;
78 state
->tree
= smb2_tree_init(state
->session
, state
, true);
79 if (composite_nomem(state
->tree
, c
)) return;
81 state
->tcon
.in
.reserved
= 0;
82 state
->tcon
.in
.path
= talloc_asprintf(state
, "\\\\%s\\%s",
83 state
->host
, state
->share
);
84 if (composite_nomem(state
->tcon
.in
.path
, c
)) return;
86 req
= smb2_tree_connect_send(state
->tree
, &state
->tcon
);
87 if (composite_nomem(req
, c
)) return;
89 req
->async
.fn
= continue_tcon
;
90 req
->async
.private_data
= c
;
94 continue after negprot reply
96 static void continue_negprot(struct smb2_request
*req
)
98 struct composite_context
*c
= talloc_get_type(req
->async
.private_data
,
99 struct composite_context
);
100 struct smb2_connect_state
*state
= talloc_get_type(c
->private_data
,
101 struct smb2_connect_state
);
102 struct smb2_transport
*transport
= req
->transport
;
103 struct composite_context
*creq
;
105 c
->status
= smb2_negprot_recv(req
, c
, &state
->negprot
);
106 if (!composite_is_ok(c
)) return;
108 transport
->negotiate
.system_time
= state
->negprot
.out
.system_time
;
109 transport
->negotiate
.server_start_time
= state
->negprot
.out
.server_start_time
;
110 transport
->negotiate
.security_mode
= state
->negprot
.out
.security_mode
;
112 switch (transport
->options
.signing
) {
113 case SMB_SIGNING_OFF
:
114 if (transport
->negotiate
.security_mode
& SMB2_NEGOTIATE_SIGNING_REQUIRED
) {
115 composite_error(c
, NT_STATUS_ACCESS_DENIED
);
118 transport
->signing_required
= false;
120 case SMB_SIGNING_SUPPORTED
:
121 if (transport
->negotiate
.security_mode
& SMB2_NEGOTIATE_SIGNING_REQUIRED
) {
122 transport
->signing_required
= true;
124 transport
->signing_required
= false;
127 case SMB_SIGNING_AUTO
:
128 if (transport
->negotiate
.security_mode
& SMB2_NEGOTIATE_SIGNING_ENABLED
) {
129 transport
->signing_required
= true;
131 transport
->signing_required
= false;
134 case SMB_SIGNING_REQUIRED
:
135 if (transport
->negotiate
.security_mode
& SMB2_NEGOTIATE_SIGNING_ENABLED
) {
136 transport
->signing_required
= true;
138 composite_error(c
, NT_STATUS_ACCESS_DENIED
);
144 state
->session
= smb2_session_init(transport
, state
->gensec_settings
, state
, true);
145 if (composite_nomem(state
->session
, c
)) return;
147 creq
= smb2_session_setup_spnego_send(state
->session
, state
->credentials
);
149 composite_continue(c
, creq
, continue_session
, c
);
153 continue after a socket connect completes
155 static void continue_socket(struct composite_context
*creq
)
157 struct composite_context
*c
= talloc_get_type(creq
->async
.private_data
,
158 struct composite_context
);
159 struct smb2_connect_state
*state
= talloc_get_type(c
->private_data
,
160 struct smb2_connect_state
);
161 struct smbcli_socket
*sock
;
162 struct smb2_transport
*transport
;
163 struct smb2_request
*req
;
164 uint16_t dialects
[2];
166 c
->status
= smbcli_sock_connect_recv(creq
, state
, &sock
);
167 if (!composite_is_ok(c
)) return;
169 transport
= smb2_transport_init(sock
, state
, &state
->options
);
170 if (composite_nomem(transport
, c
)) return;
172 ZERO_STRUCT(state
->negprot
);
173 state
->negprot
.in
.dialect_count
= 2;
174 switch (transport
->options
.signing
) {
175 case SMB_SIGNING_OFF
:
176 state
->negprot
.in
.security_mode
= 0;
178 case SMB_SIGNING_SUPPORTED
:
179 case SMB_SIGNING_AUTO
:
180 state
->negprot
.in
.security_mode
= SMB2_NEGOTIATE_SIGNING_ENABLED
;
182 case SMB_SIGNING_REQUIRED
:
183 state
->negprot
.in
.security_mode
=
184 SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
;
187 state
->negprot
.in
.capabilities
= 0;
188 unix_to_nt_time(&state
->negprot
.in
.start_time
, time(NULL
));
189 dialects
[0] = SMB2_DIALECT_REVISION
;
191 state
->negprot
.in
.dialects
= dialects
;
193 req
= smb2_negprot_send(transport
, &state
->negprot
);
194 if (composite_nomem(req
, c
)) return;
196 req
->async
.fn
= continue_negprot
;
197 req
->async
.private_data
= c
;
202 continue after a resolve finishes
204 static void continue_resolve(struct composite_context
*creq
)
206 struct composite_context
*c
= talloc_get_type(creq
->async
.private_data
,
207 struct composite_context
);
208 struct smb2_connect_state
*state
= talloc_get_type(c
->private_data
,
209 struct smb2_connect_state
);
212 const char *default_ports
[] = { "445", NULL
};
214 c
->status
= resolve_name_recv(creq
, state
, &addr
);
215 if (!composite_is_ok(c
)) return;
217 if (state
->ports
== NULL
) {
218 ports
= default_ports
;
220 ports
= state
->ports
;
223 creq
= smbcli_sock_connect_send(state
, addr
, ports
, state
->host
, state
->resolve_ctx
, c
->event_ctx
, state
->socket_options
);
225 composite_continue(c
, creq
, continue_socket
, c
);
229 a composite function that does a full negprot/sesssetup/tcon, returning
230 a connected smb2_tree
232 struct composite_context
*smb2_connect_send(TALLOC_CTX
*mem_ctx
,
236 struct resolve_context
*resolve_ctx
,
237 struct cli_credentials
*credentials
,
238 struct event_context
*ev
,
239 struct smbcli_options
*options
,
240 const char *socket_options
,
241 struct gensec_settings
*gensec_settings
)
243 struct composite_context
*c
;
244 struct smb2_connect_state
*state
;
245 struct nbt_name name
;
246 struct composite_context
*creq
;
248 c
= composite_create(mem_ctx
, ev
);
249 if (c
== NULL
) return NULL
;
251 state
= talloc(c
, struct smb2_connect_state
);
252 if (composite_nomem(state
, c
)) return c
;
253 c
->private_data
= state
;
255 state
->credentials
= credentials
;
256 state
->options
= *options
;
257 state
->host
= talloc_strdup(c
, host
);
258 if (composite_nomem(state
->host
, c
)) return c
;
259 state
->ports
= talloc_reference(state
, ports
);
260 state
->share
= talloc_strdup(c
, share
);
261 if (composite_nomem(state
->share
, c
)) return c
;
262 state
->resolve_ctx
= talloc_reference(state
, resolve_ctx
);
263 state
->socket_options
= talloc_reference(state
, socket_options
);
264 state
->gensec_settings
= talloc_reference(state
, gensec_settings
);
269 creq
= resolve_name_send(resolve_ctx
, &name
, c
->event_ctx
);
270 composite_continue(c
, creq
, continue_resolve
, c
);
275 receive a connect reply
277 NTSTATUS
smb2_connect_recv(struct composite_context
*c
, TALLOC_CTX
*mem_ctx
,
278 struct smb2_tree
**tree
)
281 struct smb2_connect_state
*state
= talloc_get_type(c
->private_data
,
282 struct smb2_connect_state
);
283 status
= composite_wait(c
);
284 if (NT_STATUS_IS_OK(status
)) {
285 *tree
= talloc_steal(mem_ctx
, state
->tree
);
292 sync version of smb2_connect
294 NTSTATUS
smb2_connect(TALLOC_CTX
*mem_ctx
,
295 const char *host
, const char **ports
,
297 struct resolve_context
*resolve_ctx
,
298 struct cli_credentials
*credentials
,
299 struct smb2_tree
**tree
,
300 struct event_context
*ev
,
301 struct smbcli_options
*options
,
302 const char *socket_options
,
303 struct gensec_settings
*gensec_settings
)
305 struct composite_context
*c
= smb2_connect_send(mem_ctx
, host
, ports
,
307 credentials
, ev
, options
,
310 return smb2_connect_recv(c
, mem_ctx
, tree
);