source: vendor/current/libcli/smb/smb2cli_session.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 8.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 smb2 lib
4 Copyright (C) Volker Lendecke 2011
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21#include "system/network.h"
22#include "../lib/util/tevent_ntstatus.h"
23#include "../libcli/smb/smb_common.h"
24#include "../libcli/smb/smbXcli_base.h"
25
26struct smb2cli_session_setup_state {
27 struct smbXcli_session *session;
28 uint8_t fixed[24];
29 uint8_t dyn_pad[1];
30 struct iovec *recv_iov;
31 DATA_BLOB out_security_buffer;
32 NTSTATUS status;
33};
34
35static void smb2cli_session_setup_done(struct tevent_req *subreq);
36
37struct tevent_req *smb2cli_session_setup_send(TALLOC_CTX *mem_ctx,
38 struct tevent_context *ev,
39 struct smbXcli_conn *conn,
40 uint32_t timeout_msec,
41 struct smbXcli_session *session,
42 uint8_t in_flags,
43 uint32_t in_capabilities,
44 uint32_t in_channel,
45 uint64_t in_previous_session_id,
46 const DATA_BLOB *in_security_buffer)
47{
48 struct tevent_req *req, *subreq;
49 struct smb2cli_session_setup_state *state;
50 uint8_t *buf;
51 uint8_t *dyn;
52 size_t dyn_len;
53 uint8_t security_mode;
54 uint16_t security_buffer_offset = 0;
55 uint16_t security_buffer_length = 0;
56
57 req = tevent_req_create(mem_ctx, &state,
58 struct smb2cli_session_setup_state);
59 if (req == NULL) {
60 return NULL;
61 }
62
63 if (session == NULL) {
64 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER_MIX);
65 return tevent_req_post(req, ev);
66 }
67 state->session = session;
68 security_mode = smb2cli_session_security_mode(session);
69
70 if (in_security_buffer) {
71 if (in_security_buffer->length > UINT16_MAX) {
72 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER_MIX);
73 return tevent_req_post(req, ev);
74 }
75 security_buffer_offset = SMB2_HDR_BODY + 24;
76 security_buffer_length = in_security_buffer->length;
77 }
78
79 buf = state->fixed;
80
81 SSVAL(buf, 0, 25);
82 SCVAL(buf, 2, in_flags);
83 SCVAL(buf, 3, security_mode);
84 SIVAL(buf, 4, in_capabilities);
85 SIVAL(buf, 8, in_channel);
86 SSVAL(buf, 12, security_buffer_offset);
87 SSVAL(buf, 14, security_buffer_length);
88 SBVAL(buf, 16, in_previous_session_id);
89
90 if (security_buffer_length > 0) {
91 dyn = in_security_buffer->data;
92 dyn_len = in_security_buffer->length;
93 } else {
94 dyn = state->dyn_pad;;
95 dyn_len = sizeof(state->dyn_pad);
96 }
97
98 subreq = smb2cli_req_send(state, ev,
99 conn, SMB2_OP_SESSSETUP,
100 0, 0, /* flags */
101 timeout_msec,
102 NULL, /* tcon */
103 session,
104 state->fixed, sizeof(state->fixed),
105 dyn, dyn_len,
106 UINT16_MAX); /* max_dyn_len */
107 if (tevent_req_nomem(subreq, req)) {
108 return tevent_req_post(req, ev);
109 }
110 tevent_req_set_callback(subreq, smb2cli_session_setup_done, req);
111 return req;
112}
113
114static void smb2cli_session_setup_done(struct tevent_req *subreq)
115{
116 struct tevent_req *req =
117 tevent_req_callback_data(subreq,
118 struct tevent_req);
119 struct smb2cli_session_setup_state *state =
120 tevent_req_data(req,
121 struct smb2cli_session_setup_state);
122 NTSTATUS status;
123 NTSTATUS preauth_status;
124 uint64_t current_session_id;
125 uint64_t session_id;
126 uint16_t session_flags;
127 uint16_t expected_offset = 0;
128 uint16_t security_buffer_offset;
129 uint16_t security_buffer_length;
130 uint8_t *security_buffer_data = NULL;
131 struct iovec sent_iov[3];
132 const uint8_t *hdr;
133 const uint8_t *body;
134 static const struct smb2cli_req_expected_response expected[] = {
135 {
136 .status = NT_STATUS_MORE_PROCESSING_REQUIRED,
137 .body_size = 0x09
138 },
139 {
140 .status = NT_STATUS_OK,
141 .body_size = 0x09
142 }
143 };
144
145 status = smb2cli_req_recv(subreq, state, &state->recv_iov,
146 expected, ARRAY_SIZE(expected));
147 if (!NT_STATUS_IS_OK(status) &&
148 !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
149 TALLOC_FREE(subreq);
150 tevent_req_nterror(req, status);
151 return;
152 }
153
154 smb2cli_req_get_sent_iov(subreq, sent_iov);
155 preauth_status = smb2cli_session_update_preauth(state->session, sent_iov);
156 TALLOC_FREE(subreq);
157 if (tevent_req_nterror(req, preauth_status)) {
158 return;
159 }
160
161 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
162 preauth_status = smb2cli_session_update_preauth(state->session,
163 state->recv_iov);
164 if (tevent_req_nterror(req, preauth_status)) {
165 return;
166 }
167 }
168
169 hdr = (const uint8_t *)state->recv_iov[0].iov_base;
170 body = (const uint8_t *)state->recv_iov[1].iov_base;
171
172 session_id = BVAL(hdr, SMB2_HDR_SESSION_ID);
173 session_flags = SVAL(body, 2);
174
175 security_buffer_offset = SVAL(body, 4);
176 security_buffer_length = SVAL(body, 6);
177
178 if (security_buffer_length > 0) {
179 expected_offset = SMB2_HDR_BODY + 8;
180 }
181 if (security_buffer_offset != 0) {
182 security_buffer_data = (uint8_t *)state->recv_iov[2].iov_base;
183 expected_offset = SMB2_HDR_BODY + 8;
184 }
185
186 if (security_buffer_offset != expected_offset) {
187 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
188 return;
189 }
190 if (security_buffer_length > state->recv_iov[2].iov_len) {
191 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
192 return;
193 }
194
195 state->out_security_buffer.data = security_buffer_data;
196 state->out_security_buffer.length = security_buffer_length;
197
198 current_session_id = smb2cli_session_current_id(state->session);
199 if (current_session_id == 0) {
200 /* A new session was requested */
201 current_session_id = session_id;
202 }
203
204 if (current_session_id != session_id) {
205 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
206 return;
207 }
208
209 smb2cli_session_set_id_and_flags(state->session,
210 session_id, session_flags);
211
212 state->status = status;
213 tevent_req_done(req);
214}
215
216NTSTATUS smb2cli_session_setup_recv(struct tevent_req *req,
217 TALLOC_CTX *mem_ctx,
218 struct iovec **recv_iov,
219 DATA_BLOB *out_security_buffer)
220{
221 struct smb2cli_session_setup_state *state =
222 tevent_req_data(req,
223 struct smb2cli_session_setup_state);
224 NTSTATUS status;
225 struct iovec *_tmp;
226
227 if (tevent_req_is_nterror(req, &status)) {
228 tevent_req_received(req);
229 return status;
230 }
231
232 if (recv_iov == NULL) {
233 recv_iov = &_tmp;
234 }
235
236 *recv_iov = talloc_move(mem_ctx, &state->recv_iov);
237
238 *out_security_buffer = state->out_security_buffer;
239
240 /*
241 * Return the status from the server:
242 * NT_STATUS_MORE_PROCESSING_REQUIRED or
243 * NT_STATUS_OK.
244 */
245 status = state->status;
246 tevent_req_received(req);
247 return status;
248}
249
250struct smb2cli_logoff_state {
251 uint8_t fixed[4];
252};
253
254static void smb2cli_logoff_done(struct tevent_req *subreq);
255
256struct tevent_req *smb2cli_logoff_send(TALLOC_CTX *mem_ctx,
257 struct tevent_context *ev,
258 struct smbXcli_conn *conn,
259 uint32_t timeout_msec,
260 struct smbXcli_session *session)
261{
262 struct tevent_req *req, *subreq;
263 struct smb2cli_logoff_state *state;
264
265 req = tevent_req_create(mem_ctx, &state,
266 struct smb2cli_logoff_state);
267 if (req == NULL) {
268 return NULL;
269 }
270 SSVAL(state->fixed, 0, 4);
271
272 subreq = smb2cli_req_send(state, ev,
273 conn, SMB2_OP_LOGOFF,
274 0, 0, /* flags */
275 timeout_msec,
276 NULL, /* tcon */
277 session,
278 state->fixed, sizeof(state->fixed),
279 NULL, 0, /* dyn* */
280 0); /* max_dyn_len */
281 if (tevent_req_nomem(subreq, req)) {
282 return tevent_req_post(req, ev);
283 }
284 tevent_req_set_callback(subreq, smb2cli_logoff_done, req);
285 return req;
286}
287
288static void smb2cli_logoff_done(struct tevent_req *subreq)
289{
290 struct tevent_req *req =
291 tevent_req_callback_data(subreq,
292 struct tevent_req);
293 struct smb2cli_logoff_state *state =
294 tevent_req_data(req,
295 struct smb2cli_logoff_state);
296 NTSTATUS status;
297 struct iovec *iov;
298 static const struct smb2cli_req_expected_response expected[] = {
299 {
300 .status = NT_STATUS_OK,
301 .body_size = 0x04
302 }
303 };
304
305 status = smb2cli_req_recv(subreq, state, &iov,
306 expected, ARRAY_SIZE(expected));
307 TALLOC_FREE(subreq);
308 if (tevent_req_nterror(req, status)) {
309 return;
310 }
311 tevent_req_done(req);
312}
313
314NTSTATUS smb2cli_logoff_recv(struct tevent_req *req)
315{
316 return tevent_req_simple_recv_ntstatus(req);
317}
318
319NTSTATUS smb2cli_logoff(struct smbXcli_conn *conn,
320 uint32_t timeout_msec,
321 struct smbXcli_session *session)
322{
323 TALLOC_CTX *frame = talloc_stackframe();
324 struct tevent_context *ev;
325 struct tevent_req *req;
326 NTSTATUS status = NT_STATUS_NO_MEMORY;
327
328 if (smbXcli_conn_has_async_calls(conn)) {
329 /*
330 * Can't use sync call while an async call is in flight
331 */
332 status = NT_STATUS_INVALID_PARAMETER;
333 goto fail;
334 }
335 ev = samba_tevent_context_init(frame);
336 if (ev == NULL) {
337 goto fail;
338 }
339 req = smb2cli_logoff_send(frame, ev, conn, timeout_msec, session);
340 if (req == NULL) {
341 goto fail;
342 }
343 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
344 goto fail;
345 }
346 status = smb2cli_logoff_recv(req);
347 fail:
348 TALLOC_FREE(frame);
349 return status;
350}
Note: See TracBrowser for help on using the repository browser.