source: vendor/3.6.0/source4/libcli/smb2/connect.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 9.5 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 SMB2 composite connection setup
5
6 Copyright (C) Andrew Tridgell 2005
7
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.
12
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.
17
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/>.
20*/
21
22#include "includes.h"
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"
30
31struct smb2_connect_state {
32 struct cli_credentials *credentials;
33 struct resolve_context *resolve_ctx;
34 const char *host;
35 const char *share;
36 const char **ports;
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;
44};
45
46/*
47 continue after tcon reply
48*/
49static void continue_tcon(struct smb2_request *req)
50{
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);
55
56 c->status = smb2_tree_connect_recv(req, &state->tcon);
57 if (!composite_is_ok(c)) return;
58
59 state->tree->tid = state->tcon.out.tid;
60
61 composite_done(c);
62}
63
64/*
65 continue after a session setup
66*/
67static void continue_session(struct composite_context *creq)
68{
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;
74
75 c->status = smb2_session_setup_spnego_recv(creq);
76 if (!composite_is_ok(c)) return;
77
78 state->tree = smb2_tree_init(state->session, state, true);
79 if (composite_nomem(state->tree, c)) return;
80
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;
85
86 req = smb2_tree_connect_send(state->tree, &state->tcon);
87 if (composite_nomem(req, c)) return;
88
89 req->async.fn = continue_tcon;
90 req->async.private_data = c;
91}
92
93/*
94 continue after negprot reply
95*/
96static void continue_negprot(struct smb2_request *req)
97{
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;
104
105 c->status = smb2_negprot_recv(req, c, &state->negprot);
106 if (!composite_is_ok(c)) return;
107
108 transport->negotiate.secblob = state->negprot.out.secblob;
109 talloc_steal(transport, transport->negotiate.secblob.data);
110 transport->negotiate.system_time = state->negprot.out.system_time;
111 transport->negotiate.server_start_time = state->negprot.out.server_start_time;
112 transport->negotiate.security_mode = state->negprot.out.security_mode;
113 transport->negotiate.dialect_revision = state->negprot.out.dialect_revision;
114
115 switch (transport->options.signing) {
116 case SMB_SIGNING_OFF:
117 if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
118 composite_error(c, NT_STATUS_ACCESS_DENIED);
119 return;
120 }
121 transport->signing_required = false;
122 break;
123 case SMB_SIGNING_SUPPORTED:
124 if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
125 transport->signing_required = true;
126 } else {
127 transport->signing_required = false;
128 }
129 break;
130 case SMB_SIGNING_AUTO:
131 if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_ENABLED) {
132 transport->signing_required = true;
133 } else {
134 transport->signing_required = false;
135 }
136 break;
137 case SMB_SIGNING_REQUIRED:
138 if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_ENABLED) {
139 transport->signing_required = true;
140 } else {
141 composite_error(c, NT_STATUS_ACCESS_DENIED);
142 return;
143 }
144 break;
145 }
146
147 state->session = smb2_session_init(transport, state->gensec_settings, state, true);
148 if (composite_nomem(state->session, c)) return;
149
150 creq = smb2_session_setup_spnego_send(state->session, state->credentials);
151
152 composite_continue(c, creq, continue_session, c);
153}
154
155/*
156 continue after a socket connect completes
157*/
158static void continue_socket(struct composite_context *creq)
159{
160 struct composite_context *c = talloc_get_type(creq->async.private_data,
161 struct composite_context);
162 struct smb2_connect_state *state = talloc_get_type(c->private_data,
163 struct smb2_connect_state);
164 struct smbcli_socket *sock;
165 struct smb2_transport *transport;
166 struct smb2_request *req;
167 uint16_t dialects[3] = {
168 SMB2_DIALECT_REVISION_000,
169 SMB2_DIALECT_REVISION_202,
170 SMB2_DIALECT_REVISION_210
171 };
172
173 c->status = smbcli_sock_connect_recv(creq, state, &sock);
174 if (!composite_is_ok(c)) return;
175
176 transport = smb2_transport_init(sock, state, &state->options);
177 if (composite_nomem(transport, c)) return;
178
179 ZERO_STRUCT(state->negprot);
180 state->negprot.in.dialect_count = sizeof(dialects) / sizeof(dialects[0]);
181 switch (transport->options.signing) {
182 case SMB_SIGNING_OFF:
183 state->negprot.in.security_mode = 0;
184 break;
185 case SMB_SIGNING_SUPPORTED:
186 case SMB_SIGNING_AUTO:
187 state->negprot.in.security_mode = SMB2_NEGOTIATE_SIGNING_ENABLED;
188 break;
189 case SMB_SIGNING_REQUIRED:
190 state->negprot.in.security_mode =
191 SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED;
192 break;
193 }
194 state->negprot.in.capabilities = 0;
195 unix_to_nt_time(&state->negprot.in.start_time, time(NULL));
196 state->negprot.in.dialects = dialects;
197
198 req = smb2_negprot_send(transport, &state->negprot);
199 if (composite_nomem(req, c)) return;
200
201 req->async.fn = continue_negprot;
202 req->async.private_data = c;
203}
204
205
206/*
207 continue after a resolve finishes
208*/
209static void continue_resolve(struct composite_context *creq)
210{
211 struct composite_context *c = talloc_get_type(creq->async.private_data,
212 struct composite_context);
213 struct smb2_connect_state *state = talloc_get_type(c->private_data,
214 struct smb2_connect_state);
215 const char *addr;
216 const char **ports;
217 const char *default_ports[] = { "445", NULL };
218
219 c->status = resolve_name_recv(creq, state, &addr);
220 if (!composite_is_ok(c)) return;
221
222 if (state->ports == NULL) {
223 ports = default_ports;
224 } else {
225 ports = state->ports;
226 }
227
228 creq = smbcli_sock_connect_send(state, addr, ports, state->host, state->resolve_ctx, c->event_ctx, state->socket_options);
229
230 composite_continue(c, creq, continue_socket, c);
231}
232
233/*
234 a composite function that does a full negprot/sesssetup/tcon, returning
235 a connected smb2_tree
236 */
237struct composite_context *smb2_connect_send(TALLOC_CTX *mem_ctx,
238 const char *host,
239 const char **ports,
240 const char *share,
241 struct resolve_context *resolve_ctx,
242 struct cli_credentials *credentials,
243 struct tevent_context *ev,
244 struct smbcli_options *options,
245 const char *socket_options,
246 struct gensec_settings *gensec_settings)
247{
248 struct composite_context *c;
249 struct smb2_connect_state *state;
250 struct nbt_name name;
251 struct composite_context *creq;
252
253 c = composite_create(mem_ctx, ev);
254 if (c == NULL) return NULL;
255
256 state = talloc(c, struct smb2_connect_state);
257 if (composite_nomem(state, c)) return c;
258 c->private_data = state;
259
260 state->credentials = credentials;
261 state->options = *options;
262 state->host = talloc_strdup(c, host);
263 if (composite_nomem(state->host, c)) return c;
264 state->ports = talloc_reference(state, ports);
265 state->share = talloc_strdup(c, share);
266 if (composite_nomem(state->share, c)) return c;
267 state->resolve_ctx = talloc_reference(state, resolve_ctx);
268 state->socket_options = talloc_reference(state, socket_options);
269 state->gensec_settings = talloc_reference(state, gensec_settings);
270
271 ZERO_STRUCT(name);
272 name.name = host;
273
274 creq = resolve_name_send(resolve_ctx, state, &name, c->event_ctx);
275 composite_continue(c, creq, continue_resolve, c);
276 return c;
277}
278
279/*
280 receive a connect reply
281*/
282NTSTATUS smb2_connect_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
283 struct smb2_tree **tree)
284{
285 NTSTATUS status;
286 struct smb2_connect_state *state = talloc_get_type(c->private_data,
287 struct smb2_connect_state);
288 status = composite_wait(c);
289 if (NT_STATUS_IS_OK(status)) {
290 *tree = talloc_steal(mem_ctx, state->tree);
291 }
292 talloc_free(c);
293 return status;
294}
295
296/*
297 sync version of smb2_connect
298*/
299NTSTATUS smb2_connect(TALLOC_CTX *mem_ctx,
300 const char *host, const char **ports,
301 const char *share,
302 struct resolve_context *resolve_ctx,
303 struct cli_credentials *credentials,
304 struct smb2_tree **tree,
305 struct tevent_context *ev,
306 struct smbcli_options *options,
307 const char *socket_options,
308 struct gensec_settings *gensec_settings)
309{
310 struct composite_context *c = smb2_connect_send(mem_ctx, host, ports,
311 share, resolve_ctx,
312 credentials, ev, options,
313 socket_options,
314 gensec_settings);
315 return smb2_connect_recv(c, mem_ctx, tree);
316}
Note: See TracBrowser for help on using the repository browser.