Line data Source code
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 "smb_common.h"
24 : #include "smbXcli_base.h"
25 : #include "smb2_create_blob.h"
26 :
27 : struct smb2cli_create_state {
28 : uint8_t fixed[56];
29 :
30 : uint64_t fid_persistent;
31 : uint64_t fid_volatile;
32 : struct smb_create_returns cr;
33 : struct smb2_create_blobs blobs;
34 : struct tevent_req *subreq;
35 : };
36 :
37 : static void smb2cli_create_done(struct tevent_req *subreq);
38 : static bool smb2cli_create_cancel(struct tevent_req *req);
39 :
40 16207 : struct tevent_req *smb2cli_create_send(
41 : TALLOC_CTX *mem_ctx,
42 : struct tevent_context *ev,
43 : struct smbXcli_conn *conn,
44 : uint32_t timeout_msec,
45 : struct smbXcli_session *session,
46 : struct smbXcli_tcon *tcon,
47 : const char *filename,
48 : uint8_t oplock_level, /* SMB2_OPLOCK_LEVEL_* */
49 : uint32_t impersonation_level, /* SMB2_IMPERSONATION_* */
50 : uint32_t desired_access,
51 : uint32_t file_attributes,
52 : uint32_t share_access,
53 : uint32_t create_disposition,
54 : uint32_t create_options,
55 : struct smb2_create_blobs *blobs)
56 : {
57 : struct tevent_req *req, *subreq;
58 : struct smb2cli_create_state *state;
59 : uint8_t *fixed;
60 : uint8_t *name_utf16;
61 : size_t name_utf16_len;
62 : DATA_BLOB blob;
63 : NTSTATUS status;
64 : size_t blobs_offset;
65 : uint8_t *dyn;
66 : size_t dyn_len;
67 : size_t max_dyn_len;
68 16207 : uint32_t additional_flags = 0;
69 16207 : uint32_t clear_flags = 0;
70 :
71 16207 : req = tevent_req_create(mem_ctx, &state,
72 : struct smb2cli_create_state);
73 16207 : if (req == NULL) {
74 0 : return NULL;
75 : }
76 :
77 16207 : if (!convert_string_talloc(state, CH_UNIX, CH_UTF16,
78 : filename, strlen(filename),
79 : &name_utf16, &name_utf16_len)) {
80 0 : tevent_req_oom(req);
81 0 : return tevent_req_post(req, ev);
82 : }
83 :
84 16207 : if (strlen(filename) == 0) {
85 999 : TALLOC_FREE(name_utf16);
86 999 : name_utf16_len = 0;
87 : }
88 :
89 16207 : fixed = state->fixed;
90 :
91 16207 : SSVAL(fixed, 0, 57);
92 16207 : SCVAL(fixed, 3, oplock_level);
93 16207 : SIVAL(fixed, 4, impersonation_level);
94 16207 : SIVAL(fixed, 24, desired_access);
95 16207 : SIVAL(fixed, 28, file_attributes);
96 16207 : SIVAL(fixed, 32, share_access);
97 16207 : SIVAL(fixed, 36, create_disposition);
98 16207 : SIVAL(fixed, 40, create_options);
99 :
100 16207 : SSVAL(fixed, 44, SMB2_HDR_BODY + 56);
101 16207 : SSVAL(fixed, 46, name_utf16_len);
102 :
103 16207 : blob = data_blob_null;
104 :
105 16207 : if (blobs != NULL) {
106 11479 : status = smb2_create_blob_push(state, &blob, *blobs);
107 11479 : if (tevent_req_nterror(req, status)) {
108 0 : return tevent_req_post(req, ev);
109 : }
110 : }
111 :
112 16207 : blobs_offset = name_utf16_len;
113 16207 : blobs_offset = ((blobs_offset + 3) & ~3);
114 :
115 16207 : if (blob.length > 0) {
116 0 : blobs_offset = ((blobs_offset + 7) & ~7);
117 0 : SIVAL(fixed, 48, blobs_offset + SMB2_HDR_BODY + 56);
118 0 : SIVAL(fixed, 52, blob.length);
119 : }
120 :
121 16207 : dyn_len = MAX(1, blobs_offset + blob.length);
122 16207 : dyn = talloc_zero_array(state, uint8_t, dyn_len);
123 16207 : if (tevent_req_nomem(dyn, req)) {
124 0 : return tevent_req_post(req, ev);
125 : }
126 :
127 16207 : if (name_utf16) {
128 15208 : memcpy(dyn, name_utf16, name_utf16_len);
129 15208 : TALLOC_FREE(name_utf16);
130 : }
131 :
132 16207 : if (blob.data != NULL) {
133 0 : memcpy(dyn + blobs_offset,
134 0 : blob.data, blob.length);
135 0 : data_blob_free(&blob);
136 : }
137 :
138 29067 : if (smbXcli_conn_dfs_supported(conn) &&
139 12860 : smbXcli_tcon_is_dfs_share(tcon))
140 : {
141 1036 : additional_flags |= SMB2_HDR_FLAG_DFS;
142 : }
143 :
144 : /*
145 : * We use max_dyn_len = 0
146 : * as we don't explicitly ask for any output length.
147 : *
148 : * But it's still possible for the server to return
149 : * large create blobs.
150 : */
151 16207 : max_dyn_len = 0;
152 :
153 29589 : subreq = smb2cli_req_send(state, ev, conn, SMB2_OP_CREATE,
154 : additional_flags, clear_flags,
155 : timeout_msec,
156 : tcon,
157 : session,
158 16207 : state->fixed, sizeof(state->fixed),
159 : dyn, dyn_len,
160 : max_dyn_len);
161 16207 : if (tevent_req_nomem(subreq, req)) {
162 0 : return tevent_req_post(req, ev);
163 : }
164 16207 : tevent_req_set_callback(subreq, smb2cli_create_done, req);
165 :
166 16207 : state->subreq = subreq;
167 16207 : tevent_req_set_cancel_fn(req, smb2cli_create_cancel);
168 :
169 16207 : return req;
170 : }
171 :
172 0 : static bool smb2cli_create_cancel(struct tevent_req *req)
173 : {
174 0 : struct smb2cli_create_state *state = tevent_req_data(req,
175 : struct smb2cli_create_state);
176 0 : return tevent_req_cancel(state->subreq);
177 : }
178 :
179 16207 : static void smb2cli_create_done(struct tevent_req *subreq)
180 : {
181 13382 : struct tevent_req *req =
182 16207 : tevent_req_callback_data(subreq,
183 : struct tevent_req);
184 13382 : struct smb2cli_create_state *state =
185 16207 : tevent_req_data(req,
186 : struct smb2cli_create_state);
187 : NTSTATUS status;
188 : struct iovec *iov;
189 : uint8_t *body;
190 : uint32_t offset, length;
191 : static const struct smb2cli_req_expected_response expected[] = {
192 : {
193 : .status = NT_STATUS_OK,
194 : .body_size = 0x59
195 : }
196 : };
197 :
198 16207 : status = smb2cli_req_recv(subreq, state, &iov,
199 : expected, ARRAY_SIZE(expected));
200 16207 : TALLOC_FREE(subreq);
201 16207 : if (tevent_req_nterror(req, status)) {
202 3549 : return;
203 : }
204 :
205 14199 : body = (uint8_t *)iov[1].iov_base;
206 :
207 14199 : state->cr.oplock_level = CVAL(body, 2);
208 14199 : state->cr.create_action = IVAL(body, 4);
209 14199 : state->cr.creation_time = BVAL(body, 8);
210 14199 : state->cr.last_access_time = BVAL(body, 16);
211 14199 : state->cr.last_write_time = BVAL(body, 24);
212 14199 : state->cr.change_time = BVAL(body, 32);
213 14199 : state->cr.allocation_size = BVAL(body, 40);
214 14199 : state->cr.end_of_file = BVAL(body, 48);
215 14199 : state->cr.file_attributes = IVAL(body, 56);
216 14199 : state->fid_persistent = BVAL(body, 64);
217 14199 : state->fid_volatile = BVAL(body, 72);
218 :
219 14199 : offset = IVAL(body, 80);
220 14199 : length = IVAL(body, 84);
221 :
222 14199 : if ((offset != 0) && (length != 0)) {
223 0 : if ((offset != SMB2_HDR_BODY + 88) ||
224 0 : (length > iov[2].iov_len)) {
225 0 : tevent_req_nterror(
226 : req, NT_STATUS_INVALID_NETWORK_RESPONSE);
227 0 : return;
228 : }
229 0 : status = smb2_create_blob_parse(
230 0 : state, data_blob_const(iov[2].iov_base, length),
231 : &state->blobs);
232 0 : if (tevent_req_nterror(req, status)) {
233 0 : return;
234 : }
235 : }
236 14199 : tevent_req_done(req);
237 : }
238 :
239 16207 : NTSTATUS smb2cli_create_recv(struct tevent_req *req,
240 : uint64_t *fid_persistent,
241 : uint64_t *fid_volatile,
242 : struct smb_create_returns *cr,
243 : TALLOC_CTX *mem_ctx,
244 : struct smb2_create_blobs *blobs)
245 : {
246 13382 : struct smb2cli_create_state *state =
247 16207 : tevent_req_data(req,
248 : struct smb2cli_create_state);
249 : NTSTATUS status;
250 :
251 16207 : if (tevent_req_is_nterror(req, &status)) {
252 2008 : tevent_req_received(req);
253 2008 : return status;
254 : }
255 14199 : *fid_persistent = state->fid_persistent;
256 14199 : *fid_volatile = state->fid_volatile;
257 14199 : if (cr) {
258 9630 : *cr = state->cr;
259 : }
260 14199 : if (blobs) {
261 9630 : blobs->num_blobs = state->blobs.num_blobs;
262 9630 : blobs->blobs = talloc_move(mem_ctx, &state->blobs.blobs);
263 : }
264 14199 : tevent_req_received(req);
265 14199 : return NT_STATUS_OK;
266 : }
267 :
268 6 : NTSTATUS smb2cli_create(struct smbXcli_conn *conn,
269 : uint32_t timeout_msec,
270 : struct smbXcli_session *session,
271 : struct smbXcli_tcon *tcon,
272 : const char *filename,
273 : uint8_t oplock_level, /* SMB2_OPLOCK_LEVEL_* */
274 : uint32_t impersonation_level, /* SMB2_IMPERSONATION_* */
275 : uint32_t desired_access,
276 : uint32_t file_attributes,
277 : uint32_t share_access,
278 : uint32_t create_disposition,
279 : uint32_t create_options,
280 : struct smb2_create_blobs *blobs,
281 : uint64_t *fid_persistent,
282 : uint64_t *fid_volatile,
283 : struct smb_create_returns *cr,
284 : TALLOC_CTX *mem_ctx,
285 : struct smb2_create_blobs *ret_blobs)
286 : {
287 6 : TALLOC_CTX *frame = talloc_stackframe();
288 : struct tevent_context *ev;
289 : struct tevent_req *req;
290 6 : NTSTATUS status = NT_STATUS_NO_MEMORY;
291 :
292 6 : if (smbXcli_conn_has_async_calls(conn)) {
293 : /*
294 : * Can't use sync call while an async call is in flight
295 : */
296 0 : status = NT_STATUS_INVALID_PARAMETER;
297 0 : goto fail;
298 : }
299 6 : ev = samba_tevent_context_init(frame);
300 6 : if (ev == NULL) {
301 0 : goto fail;
302 : }
303 6 : req = smb2cli_create_send(frame, ev, conn, timeout_msec,
304 : session, tcon,
305 : filename, oplock_level,
306 : impersonation_level, desired_access,
307 : file_attributes, share_access,
308 : create_disposition, create_options,
309 : blobs);
310 6 : if (req == NULL) {
311 0 : goto fail;
312 : }
313 6 : if (!tevent_req_poll_ntstatus(req, ev, &status)) {
314 0 : goto fail;
315 : }
316 6 : status = smb2cli_create_recv(req, fid_persistent, fid_volatile, cr,
317 : mem_ctx, ret_blobs);
318 6 : fail:
319 6 : TALLOC_FREE(frame);
320 6 : return status;
321 : }
|
