?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:auth: Enforce machine authentication policy for NTLM authentication
[Samba.git] / source3 / libsmb / cli_smb2_fnum.c
blob3e4ff82b77614b50e4aeb6c7074d25814063994d
1 /*
2 Unix SMB/CIFS implementation.
3 smb2 lib
4 Copyright (C) Jeremy Allison 2013
5 Copyright (C) Volker Lendecke 2013
6 Copyright (C) Stefan Metzmacher 2013
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 /*
23 This code is a thin wrapper around the existing
24 cli_smb2_XXXX() functions in libcli/smb/smb2cli_XXXXX.c,
25 but allows the handles to be mapped to uint16_t fnums,
26 which are easier for smbclient to use.
27 */
28
29 #include "includes.h"
30 #include "client.h"
31 #include "async_smb.h"
32 #include "../libcli/smb/smbXcli_base.h"
33 #include "cli_smb2_fnum.h"
34 #include "trans2.h"
35 #include "clirap.h"
36 #include "../libcli/smb/smb2_create_blob.h"
37 #include "libsmb/proto.h"
38 #include "lib/util/tevent_ntstatus.h"
39 #include "../libcli/security/security.h"
40 #include "../librpc/gen_ndr/ndr_security.h"
41 #include "lib/util_ea.h"
42 #include "librpc/gen_ndr/ndr_ioctl.h"
43 #include "ntioctl.h"
44 #include "librpc/gen_ndr/ndr_quota.h"
45 #include "lib/util/string_wrappers.h"
46 #include "lib/util/idtree.h"
47
48 struct smb2_hnd {
49 uint64_t fid_persistent;
50 uint64_t fid_volatile;
51 };
52
53 /*
54 * Handle mapping code.
55 */
56
57 /***************************************************************
58 Allocate a new fnum between 1 and 0xFFFE from an smb2_hnd.
59 Ensures handle is owned by cli struct.
60 ***************************************************************/
61
62 static NTSTATUS map_smb2_handle_to_fnum(struct cli_state *cli,
63 const struct smb2_hnd *ph, /* In */
64 uint16_t *pfnum) /* Out */
65 {
66 int ret;
67 struct idr_context *idp = cli->smb2.open_handles;
68 struct smb2_hnd *owned_h = talloc_memdup(cli,
69 ph,
70 sizeof(struct smb2_hnd));
71
72 if (owned_h == NULL) {
73 return NT_STATUS_NO_MEMORY;
74 }
75
76 if (idp == NULL) {
77 /* Lazy init */
78 cli->smb2.open_handles = idr_init(cli);
79 if (cli->smb2.open_handles == NULL) {
80 TALLOC_FREE(owned_h);
81 return NT_STATUS_NO_MEMORY;
82 }
83 idp = cli->smb2.open_handles;
84 }
85
86 ret = idr_get_new_above(idp, owned_h, 1, 0xFFFE);
87 if (ret == -1) {
88 TALLOC_FREE(owned_h);
89 return NT_STATUS_NO_MEMORY;
90 }
91
92 *pfnum = (uint16_t)ret;
93 return NT_STATUS_OK;
94 }
95
96 /***************************************************************
97 Return the smb2_hnd pointer associated with the given fnum.
98 ***************************************************************/
99
100 static NTSTATUS map_fnum_to_smb2_handle(struct cli_state *cli,
101 uint16_t fnum, /* In */
102 struct smb2_hnd **pph) /* Out */
103 {
104 struct idr_context *idp = cli->smb2.open_handles;
105
106 if (idp == NULL) {
107 return NT_STATUS_INVALID_PARAMETER;
108 }
109 *pph = (struct smb2_hnd *)idr_find(idp, fnum);
110 if (*pph == NULL) {
111 return NT_STATUS_INVALID_HANDLE;
112 }
113 return NT_STATUS_OK;
114 }
115
116 /***************************************************************
117 Delete the fnum to smb2_hnd mapping. Zeros out handle on
118 successful return.
119 ***************************************************************/
120
121 static NTSTATUS delete_smb2_handle_mapping(struct cli_state *cli,
122 struct smb2_hnd **pph, /* In */
123 uint16_t fnum) /* In */
124 {
125 struct idr_context *idp = cli->smb2.open_handles;
126 struct smb2_hnd *ph;
127
128 if (idp == NULL) {
129 return NT_STATUS_INVALID_PARAMETER;
130 }
131
132 ph = (struct smb2_hnd *)idr_find(idp, fnum);
133 if (ph != *pph) {
134 return NT_STATUS_INVALID_PARAMETER;
135 }
136 idr_remove(idp, fnum);
137 TALLOC_FREE(*pph);
138 return NT_STATUS_OK;
139 }
140
141 /***************************************************************
142 Oplock mapping code.
143 ***************************************************************/
144
145 static uint8_t flags_to_smb2_oplock(struct cli_smb2_create_flags create_flags)
146 {
147 if (create_flags.batch_oplock) {
148 return SMB2_OPLOCK_LEVEL_BATCH;
149 } else if (create_flags.exclusive_oplock) {
150 return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
151 }
152
153 /* create_flags doesn't do a level2 request. */
154 return SMB2_OPLOCK_LEVEL_NONE;
155 }
156
157 /***************************************************************
158 If we're on a DFS share, ensure we convert to a full DFS path
159 if this hasn't already been done.
160 ***************************************************************/
161
162 static char *smb2_dfs_share_path(TALLOC_CTX *ctx,
163 struct cli_state *cli,
164 char *path)
165 {
166 bool is_dfs = smbXcli_conn_dfs_supported(cli->conn) &&
167 smbXcli_tcon_is_dfs_share(cli->smb2.tcon);
168 bool is_already_dfs_path = false;
169
170 if (!is_dfs) {
171 return path;
172 }
173 is_already_dfs_path = cli_dfs_is_already_full_path(cli, path);
174 if (is_already_dfs_path) {
175 return path;
176 }
177 if (path[0] == '\0') {
178 return talloc_asprintf(ctx,
179 "%s\\%s",
180 smbXcli_conn_remote_name(cli->conn),
181 cli->share);
182 }
183 while (*path == '\\') {
184 path++;
185 }
186 return talloc_asprintf(ctx,
187 "%s\\%s\\%s",
188 smbXcli_conn_remote_name(cli->conn),
189 cli->share,
190 path);
191 }
192
193 /***************************************************************
194 Small wrapper that allows SMB2 create to return a uint16_t fnum.
195 ***************************************************************/
196
197 struct cli_smb2_create_fnum_state {
198 struct cli_state *cli;
199 struct smb2_create_blobs in_cblobs;
200 struct smb2_create_blobs out_cblobs;
201 struct smb_create_returns cr;
202 struct symlink_reparse_struct *symlink;
203 uint16_t fnum;
204 struct tevent_req *subreq;
205 };
206
207 static void cli_smb2_create_fnum_done(struct tevent_req *subreq);
208 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req);
209
210 struct tevent_req *cli_smb2_create_fnum_send(
211 TALLOC_CTX *mem_ctx,
212 struct tevent_context *ev,
213 struct cli_state *cli,
214 const char *fname_in,
215 struct cli_smb2_create_flags create_flags,
216 uint32_t impersonation_level,
217 uint32_t desired_access,
218 uint32_t file_attributes,
219 uint32_t share_access,
220 uint32_t create_disposition,
221 uint32_t create_options,
222 const struct smb2_create_blobs *in_cblobs)
223 {
224 struct tevent_req *req, *subreq;
225 struct cli_smb2_create_fnum_state *state;
226 char *fname = NULL;
227 size_t fname_len = 0;
228 bool have_twrp;
229 NTTIME ntt;
230 NTSTATUS status;
231
232 req = tevent_req_create(mem_ctx, &state,
233 struct cli_smb2_create_fnum_state);
234 if (req == NULL) {
235 return NULL;
236 }
237 state->cli = cli;
238
239 fname = talloc_strdup(state, fname_in);
240 if (tevent_req_nomem(fname, req)) {
241 return tevent_req_post(req, ev);
242 }
243
244 if (cli->backup_intent) {
245 create_options |= FILE_OPEN_FOR_BACKUP_INTENT;
246 }
247
248 /* Check for @GMT- paths. Remove the @GMT and turn into TWrp if so. */
249 have_twrp = clistr_smb2_extract_snapshot_token(fname, &ntt);
250 if (have_twrp) {
251 status = smb2_create_blob_add(
252 state,
253 &state->in_cblobs,
254 SMB2_CREATE_TAG_TWRP,
255 (DATA_BLOB) {
256 .data = (uint8_t *)&ntt,
257 .length = sizeof(ntt),
258 });
259 if (tevent_req_nterror(req, status)) {
260 return tevent_req_post(req, ev);
261 }
262 }
263
264 if (in_cblobs != NULL) {
265 uint32_t i;
266 for (i=0; i<in_cblobs->num_blobs; i++) {
267 struct smb2_create_blob *b = &in_cblobs->blobs[i];
268 status = smb2_create_blob_add(
269 state, &state->in_cblobs, b->tag, b->data);
270 if (!NT_STATUS_IS_OK(status)) {
271 tevent_req_nterror(req, status);
272 return tevent_req_post(req, ev);
273 }
274 }
275 }
276
277 fname = smb2_dfs_share_path(state, cli, fname);
278 if (tevent_req_nomem(fname, req)) {
279 return tevent_req_post(req, ev);
280 }
281 fname_len = strlen(fname);
282
283 /* SMB2 is pickier about pathnames. Ensure it doesn't
284 start in a '\' */
285 if (*fname == '\\') {
286 fname++;
287 fname_len--;
288 }
289
290 /* Or end in a '\' */
291 if (fname_len > 0 && fname[fname_len-1] == '\\') {
292 fname[fname_len-1] = '\0';
293 }
294
295 subreq = smb2cli_create_send(state, ev,
296 cli->conn,
297 cli->timeout,
298 cli->smb2.session,
299 cli->smb2.tcon,
300 fname,
301 flags_to_smb2_oplock(create_flags),
302 impersonation_level,
303 desired_access,
304 file_attributes,
305 share_access,
306 create_disposition,
307 create_options,
308 &state->in_cblobs);
309 if (tevent_req_nomem(subreq, req)) {
310 return tevent_req_post(req, ev);
311 }
312 tevent_req_set_callback(subreq, cli_smb2_create_fnum_done, req);
313
314 state->subreq = subreq;
315 tevent_req_set_cancel_fn(req, cli_smb2_create_fnum_cancel);
316
317 return req;
318 }
319
320 static void cli_smb2_create_fnum_done(struct tevent_req *subreq)
321 {
322 struct tevent_req *req = tevent_req_callback_data(
323 subreq, struct tevent_req);
324 struct cli_smb2_create_fnum_state *state = tevent_req_data(
325 req, struct cli_smb2_create_fnum_state);
326 struct smb2_hnd h;
327 NTSTATUS status;
328
329 status = smb2cli_create_recv(
330 subreq,
331 &h.fid_persistent,
332 &h.fid_volatile, &state->cr,
333 state,
334 &state->out_cblobs,
335 &state->symlink);
336 TALLOC_FREE(subreq);
337 if (tevent_req_nterror(req, status)) {
338 return;
339 }
340
341 status = map_smb2_handle_to_fnum(state->cli, &h, &state->fnum);
342 if (tevent_req_nterror(req, status)) {
343 return;
344 }
345 tevent_req_done(req);
346 }
347
348 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req)
349 {
350 struct cli_smb2_create_fnum_state *state = tevent_req_data(
351 req, struct cli_smb2_create_fnum_state);
352 return tevent_req_cancel(state->subreq);
353 }
354
355 NTSTATUS cli_smb2_create_fnum_recv(
356 struct tevent_req *req,
357 uint16_t *pfnum,
358 struct smb_create_returns *cr,
359 TALLOC_CTX *mem_ctx,
360 struct smb2_create_blobs *out_cblobs,
361 struct symlink_reparse_struct **symlink)
362 {
363 struct cli_smb2_create_fnum_state *state = tevent_req_data(
364 req, struct cli_smb2_create_fnum_state);
365 NTSTATUS status;
366
367 if (tevent_req_is_nterror(req, &status)) {
368 if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK) &&
369 (symlink != NULL)) {
370 *symlink = talloc_move(mem_ctx, &state->symlink);
371 }
372 state->cli->raw_status = status;
373 return status;
374 }
375 if (pfnum != NULL) {
376 *pfnum = state->fnum;
377 }
378 if (cr != NULL) {
379 *cr = state->cr;
380 }
381 if (out_cblobs != NULL) {
382 *out_cblobs = (struct smb2_create_blobs) {
383 .num_blobs = state->out_cblobs.num_blobs,
384 .blobs = talloc_move(
385 mem_ctx, &state->out_cblobs.blobs),
386 };
387 }
388 state->cli->raw_status = NT_STATUS_OK;
389 return NT_STATUS_OK;
390 }
391
392 NTSTATUS cli_smb2_create_fnum(
393 struct cli_state *cli,
394 const char *fname,
395 struct cli_smb2_create_flags create_flags,
396 uint32_t impersonation_level,
397 uint32_t desired_access,
398 uint32_t file_attributes,
399 uint32_t share_access,
400 uint32_t create_disposition,
401 uint32_t create_options,
402 const struct smb2_create_blobs *in_cblobs,
403 uint16_t *pfid,
404 struct smb_create_returns *cr,
405 TALLOC_CTX *mem_ctx,
406 struct smb2_create_blobs *out_cblobs)
407 {
408 TALLOC_CTX *frame = talloc_stackframe();
409 struct tevent_context *ev;
410 struct tevent_req *req;
411 NTSTATUS status = NT_STATUS_NO_MEMORY;
412
413 if (smbXcli_conn_has_async_calls(cli->conn)) {
414 /*
415 * Can't use sync call while an async call is in flight
416 */
417 status = NT_STATUS_INVALID_PARAMETER;
418 goto fail;
419 }
420 ev = samba_tevent_context_init(frame);
421 if (ev == NULL) {
422 goto fail;
423 }
424 req = cli_smb2_create_fnum_send(
425 frame,
426 ev,
427 cli,
428 fname,
429 create_flags,
430 impersonation_level,
431 desired_access,
432 file_attributes,
433 share_access,
434 create_disposition,
435 create_options,
436 in_cblobs);
437 if (req == NULL) {
438 goto fail;
439 }
440 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
441 goto fail;
442 }
443 status = cli_smb2_create_fnum_recv(
444 req, pfid, cr, mem_ctx, out_cblobs, NULL);
445 fail:
446 TALLOC_FREE(frame);
447 return status;
448 }
449
450 /***************************************************************
451 Small wrapper that allows SMB2 close to use a uint16_t fnum.
452 ***************************************************************/
453
454 struct cli_smb2_close_fnum_state {
455 struct cli_state *cli;
456 uint16_t fnum;
457 struct smb2_hnd *ph;
458 };
459
460 static void cli_smb2_close_fnum_done(struct tevent_req *subreq);
461
462 struct tevent_req *cli_smb2_close_fnum_send(TALLOC_CTX *mem_ctx,
463 struct tevent_context *ev,
464 struct cli_state *cli,
465 uint16_t fnum)
466 {
467 struct tevent_req *req, *subreq;
468 struct cli_smb2_close_fnum_state *state;
469 NTSTATUS status;
470
471 req = tevent_req_create(mem_ctx, &state,
472 struct cli_smb2_close_fnum_state);
473 if (req == NULL) {
474 return NULL;
475 }
476 state->cli = cli;
477 state->fnum = fnum;
478
479 status = map_fnum_to_smb2_handle(cli, fnum, &state->ph);
480 if (tevent_req_nterror(req, status)) {
481 return tevent_req_post(req, ev);
482 }
483
484 subreq = smb2cli_close_send(state, ev, cli->conn, cli->timeout,
485 cli->smb2.session, cli->smb2.tcon,
486 0, state->ph->fid_persistent,
487 state->ph->fid_volatile);
488 if (tevent_req_nomem(subreq, req)) {
489 return tevent_req_post(req, ev);
490 }
491 tevent_req_set_callback(subreq, cli_smb2_close_fnum_done, req);
492 return req;
493 }
494
495 static void cli_smb2_close_fnum_done(struct tevent_req *subreq)
496 {
497 struct tevent_req *req = tevent_req_callback_data(
498 subreq, struct tevent_req);
499 struct cli_smb2_close_fnum_state *state = tevent_req_data(
500 req, struct cli_smb2_close_fnum_state);
501 NTSTATUS status;
502
503 status = smb2cli_close_recv(subreq);
504 if (tevent_req_nterror(req, status)) {
505 return;
506 }
507
508 /* Delete the fnum -> handle mapping. */
509 status = delete_smb2_handle_mapping(state->cli, &state->ph,
510 state->fnum);
511 if (tevent_req_nterror(req, status)) {
512 return;
513 }
514 tevent_req_done(req);
515 }
516
517 NTSTATUS cli_smb2_close_fnum_recv(struct tevent_req *req)
518 {
519 struct cli_smb2_close_fnum_state *state = tevent_req_data(
520 req, struct cli_smb2_close_fnum_state);
521 NTSTATUS status = NT_STATUS_OK;
522
523 if (tevent_req_is_nterror(req, &status)) {
524 state->cli->raw_status = status;
525 }
526 tevent_req_received(req);
527 return status;
528 }
529
530 NTSTATUS cli_smb2_close_fnum(struct cli_state *cli, uint16_t fnum)
531 {
532 TALLOC_CTX *frame = talloc_stackframe();
533 struct tevent_context *ev;
534 struct tevent_req *req;
535 NTSTATUS status = NT_STATUS_NO_MEMORY;
536
537 if (smbXcli_conn_has_async_calls(cli->conn)) {
538 /*
539 * Can't use sync call while an async call is in flight
540 */
541 status = NT_STATUS_INVALID_PARAMETER;
542 goto fail;
543 }
544 ev = samba_tevent_context_init(frame);
545 if (ev == NULL) {
546 goto fail;
547 }
548 req = cli_smb2_close_fnum_send(frame, ev, cli, fnum);
549 if (req == NULL) {
550 goto fail;
551 }
552 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
553 goto fail;
554 }
555 status = cli_smb2_close_fnum_recv(req);
556 fail:
557 TALLOC_FREE(frame);
558 return status;
559 }
560
561 struct cli_smb2_set_info_fnum_state {
562 uint8_t dummy;
563 };
564
565 static void cli_smb2_set_info_fnum_done(struct tevent_req *subreq);
566
567 struct tevent_req *cli_smb2_set_info_fnum_send(
568 TALLOC_CTX *mem_ctx,
569 struct tevent_context *ev,
570 struct cli_state *cli,
571 uint16_t fnum,
572 uint8_t in_info_type,
573 uint8_t in_info_class,
574 const DATA_BLOB *in_input_buffer,
575 uint32_t in_additional_info)
576 {
577 struct tevent_req *req = NULL, *subreq = NULL;
578 struct cli_smb2_set_info_fnum_state *state = NULL;
579 struct smb2_hnd *ph = NULL;
580 NTSTATUS status;
581
582 req = tevent_req_create(
583 mem_ctx, &state, struct cli_smb2_set_info_fnum_state);
584 if (req == NULL) {
585 return NULL;
586 }
587
588 status = map_fnum_to_smb2_handle(cli, fnum, &ph);
589 if (tevent_req_nterror(req, status)) {
590 return tevent_req_post(req, ev);
591 }
592
593 subreq = smb2cli_set_info_send(
594 state,
595 ev,
596 cli->conn,
597 cli->timeout,
598 cli->smb2.session,
599 cli->smb2.tcon,
600 in_info_type,
601 in_info_class,
602 in_input_buffer,
603 in_additional_info,
604 ph->fid_persistent,
605 ph->fid_volatile);
606 if (tevent_req_nomem(subreq, req)) {
607 return tevent_req_post(req, ev);
608 }
609 tevent_req_set_callback(subreq, cli_smb2_set_info_fnum_done, req);
610 return req;
611 }
612
613 static void cli_smb2_set_info_fnum_done(struct tevent_req *subreq)
614 {
615 NTSTATUS status = smb2cli_set_info_recv(subreq);
616 tevent_req_simple_finish_ntstatus(subreq, status);
617 }
618
619 NTSTATUS cli_smb2_set_info_fnum_recv(struct tevent_req *req)
620 {
621 return tevent_req_simple_recv_ntstatus(req);
622 }
623
624 NTSTATUS cli_smb2_set_info_fnum(
625 struct cli_state *cli,
626 uint16_t fnum,
627 uint8_t in_info_type,
628 uint8_t in_info_class,
629 const DATA_BLOB *in_input_buffer,
630 uint32_t in_additional_info)
631 {
632 TALLOC_CTX *frame = talloc_stackframe();
633 struct tevent_context *ev = NULL;
634 struct tevent_req *req = NULL;
635 NTSTATUS status = NT_STATUS_NO_MEMORY;
636 bool ok;
637
638 if (smbXcli_conn_has_async_calls(cli->conn)) {
639 /*
640 * Can't use sync call while an async call is in flight
641 */
642 status = NT_STATUS_INVALID_PARAMETER;
643 goto fail;
644 }
645 ev = samba_tevent_context_init(frame);
646 if (ev == NULL) {
647 goto fail;
648 }
649 req = cli_smb2_set_info_fnum_send(
650 frame,
651 ev,
652 cli,
653 fnum,
654 in_info_type,
655 in_info_class,
656 in_input_buffer,
657 in_additional_info);
658 if (req == NULL) {
659 goto fail;
660 }
661 ok = tevent_req_poll_ntstatus(req, ev, &status);
662 if (!ok) {
663 goto fail;
664 }
665 status = cli_smb2_set_info_fnum_recv(req);
666 fail:
667 TALLOC_FREE(frame);
668 return status;
669 }
670
671 struct cli_smb2_delete_on_close_state {
672 struct cli_state *cli;
673 uint8_t data[1];
674 DATA_BLOB inbuf;
675 };
676
677 static void cli_smb2_delete_on_close_done(struct tevent_req *subreq);
678
679 struct tevent_req *cli_smb2_delete_on_close_send(TALLOC_CTX *mem_ctx,
680 struct tevent_context *ev,
681 struct cli_state *cli,
682 uint16_t fnum,
683 bool flag)
684 {
685 struct tevent_req *req = NULL;
686 struct cli_smb2_delete_on_close_state *state = NULL;
687 struct tevent_req *subreq = NULL;
688 uint8_t in_info_type;
689 uint8_t in_file_info_class;
690
691 req = tevent_req_create(mem_ctx, &state,
692 struct cli_smb2_delete_on_close_state);
693 if (req == NULL) {
694 return NULL;
695 }
696 state->cli = cli;
697
698 /*
699 * setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
700 * level 13 (SMB_FILE_DISPOSITION_INFORMATION - 1000).
701 */
702 in_info_type = 1;
703 in_file_info_class = SMB_FILE_DISPOSITION_INFORMATION - 1000;
704 /* Setup data array. */
705 SCVAL(&state->data[0], 0, flag ? 1 : 0);
706 state->inbuf.data = &state->data[0];
707 state->inbuf.length = 1;
708
709 subreq = cli_smb2_set_info_fnum_send(
710 state,
711 ev,
712 cli,
713 fnum,
714 in_info_type,
715 in_file_info_class,
716 &state->inbuf,
717 0);
718 if (tevent_req_nomem(subreq, req)) {
719 return tevent_req_post(req, ev);
720 }
721 tevent_req_set_callback(subreq,
722 cli_smb2_delete_on_close_done,
723 req);
724 return req;
725 }
726
727 static void cli_smb2_delete_on_close_done(struct tevent_req *subreq)
728 {
729 NTSTATUS status = cli_smb2_set_info_fnum_recv(subreq);
730 tevent_req_simple_finish_ntstatus(subreq, status);
731 }
732
733 NTSTATUS cli_smb2_delete_on_close_recv(struct tevent_req *req)
734 {
735 struct cli_smb2_delete_on_close_state *state =
736 tevent_req_data(req,
737 struct cli_smb2_delete_on_close_state);
738 NTSTATUS status;
739
740 if (tevent_req_is_nterror(req, &status)) {
741 state->cli->raw_status = status;
742 tevent_req_received(req);
743 return status;
744 }
745
746 state->cli->raw_status = NT_STATUS_OK;
747 tevent_req_received(req);
748 return NT_STATUS_OK;
749 }
750
751 NTSTATUS cli_smb2_delete_on_close(struct cli_state *cli, uint16_t fnum, bool flag)
752 {
753 TALLOC_CTX *frame = talloc_stackframe();
754 struct tevent_context *ev;
755 struct tevent_req *req;
756 NTSTATUS status = NT_STATUS_NO_MEMORY;
757
758 if (smbXcli_conn_has_async_calls(cli->conn)) {
759 /*
760 * Can't use sync call while an async call is in flight
761 */
762 status = NT_STATUS_INVALID_PARAMETER;
763 goto fail;
764 }
765 ev = samba_tevent_context_init(frame);
766 if (ev == NULL) {
767 goto fail;
768 }
769 req = cli_smb2_delete_on_close_send(frame, ev, cli, fnum, flag);
770 if (req == NULL) {
771 goto fail;
772 }
773 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
774 goto fail;
775 }
776 status = cli_smb2_delete_on_close_recv(req);
777 fail:
778 TALLOC_FREE(frame);
779 return status;
780 }
781
782 struct cli_smb2_mkdir_state {
783 struct tevent_context *ev;
784 struct cli_state *cli;
785 };
786
787 static void cli_smb2_mkdir_opened(struct tevent_req *subreq);
788 static void cli_smb2_mkdir_closed(struct tevent_req *subreq);
789
790 struct tevent_req *cli_smb2_mkdir_send(
791 TALLOC_CTX *mem_ctx,
792 struct tevent_context *ev,
793 struct cli_state *cli,
794 const char *dname)
795 {
796 struct tevent_req *req = NULL, *subreq = NULL;
797 struct cli_smb2_mkdir_state *state = NULL;
798
799 req = tevent_req_create(
800 mem_ctx, &state, struct cli_smb2_mkdir_state);
801 if (req == NULL) {
802 return NULL;
803 }
804 state->ev = ev;
805 state->cli = cli;
806
807 /* Ensure this is a directory. */
808 subreq = cli_smb2_create_fnum_send(
809 state, /* mem_ctx */
810 ev, /* ev */
811 cli, /* cli */
812 dname, /* fname */
813 (struct cli_smb2_create_flags){0}, /* create_flags */
814 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level */
815 FILE_READ_ATTRIBUTES, /* desired_access */
816 FILE_ATTRIBUTE_DIRECTORY, /* file_attributes */
817 FILE_SHARE_READ|
818 FILE_SHARE_WRITE, /* share_access */
819 FILE_CREATE, /* create_disposition */
820 FILE_DIRECTORY_FILE, /* create_options */
821 NULL); /* in_cblobs */
822 if (tevent_req_nomem(subreq, req)) {
823 return tevent_req_post(req, ev);
824 }
825 tevent_req_set_callback(subreq, cli_smb2_mkdir_opened, req);
826 return req;
827 }
828
829 static void cli_smb2_mkdir_opened(struct tevent_req *subreq)
830 {
831 struct tevent_req *req = tevent_req_callback_data(
832 subreq, struct tevent_req);
833 struct cli_smb2_mkdir_state *state = tevent_req_data(
834 req, struct cli_smb2_mkdir_state);
835 NTSTATUS status;
836 uint16_t fnum = 0xffff;
837
838 status = cli_smb2_create_fnum_recv(
839 subreq, &fnum, NULL, NULL, NULL, NULL);
840 TALLOC_FREE(subreq);
841 if (tevent_req_nterror(req, status)) {
842 return;
843 }
844
845 subreq = cli_smb2_close_fnum_send(state, state->ev, state->cli, fnum);
846 if (tevent_req_nomem(subreq, req)) {
847 return;
848 }
849 tevent_req_set_callback(subreq, cli_smb2_mkdir_closed, req);
850 }
851
852 static void cli_smb2_mkdir_closed(struct tevent_req *subreq)
853 {
854 NTSTATUS status = cli_smb2_close_fnum_recv(subreq);
855 tevent_req_simple_finish_ntstatus(subreq, status);
856 }
857
858 NTSTATUS cli_smb2_mkdir_recv(struct tevent_req *req)
859 {
860 return tevent_req_simple_recv_ntstatus(req);
861 }
862
863 struct cli_smb2_rmdir_state {
864 struct tevent_context *ev;
865 struct cli_state *cli;
866 const char *dname;
867 const struct smb2_create_blobs *in_cblobs;
868 uint16_t fnum;
869 NTSTATUS status;
870 };
871
872 static void cli_smb2_rmdir_opened1(struct tevent_req *subreq);
873 static void cli_smb2_rmdir_opened2(struct tevent_req *subreq);
874 static void cli_smb2_rmdir_disp_set(struct tevent_req *subreq);
875 static void cli_smb2_rmdir_closed(struct tevent_req *subreq);
876
877 struct tevent_req *cli_smb2_rmdir_send(
878 TALLOC_CTX *mem_ctx,
879 struct tevent_context *ev,
880 struct cli_state *cli,
881 const char *dname,
882 const struct smb2_create_blobs *in_cblobs)
883 {
884 struct tevent_req *req = NULL, *subreq = NULL;
885 struct cli_smb2_rmdir_state *state = NULL;
886
887 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_rmdir_state);
888 if (req == NULL) {
889 return NULL;
890 }
891 state->ev = ev;
892 state->cli = cli;
893 state->dname = dname;
894 state->in_cblobs = in_cblobs;
895
896 subreq = cli_smb2_create_fnum_send(
897 state,
898 state->ev,
899 state->cli,
900 state->dname,
901 (struct cli_smb2_create_flags){0},
902 SMB2_IMPERSONATION_IMPERSONATION,
903 DELETE_ACCESS, /* desired_access */
904 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
905 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
906 FILE_OPEN, /* create_disposition */
907 FILE_DIRECTORY_FILE, /* create_options */
908 state->in_cblobs); /* in_cblobs */
909 if (tevent_req_nomem(subreq, req)) {
910 return tevent_req_post(req, ev);
911 }
912 tevent_req_set_callback(subreq, cli_smb2_rmdir_opened1, req);
913 return req;
914 }
915
916 static void cli_smb2_rmdir_opened1(struct tevent_req *subreq)
917 {
918 struct tevent_req *req = tevent_req_callback_data(
919 subreq, struct tevent_req);
920 struct cli_smb2_rmdir_state *state = tevent_req_data(
921 req, struct cli_smb2_rmdir_state);
922 NTSTATUS status;
923
924 status = cli_smb2_create_fnum_recv(
925 subreq, &state->fnum, NULL, NULL, NULL, NULL);
926 TALLOC_FREE(subreq);
927
928 if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK)) {
929 /*
930 * Naive option to match our SMB1 code. Assume the
931 * symlink path that tripped us up was the last
932 * component and try again. Eventually we will have to
933 * deal with the returned path unprocessed component. JRA.
934 */
935 subreq = cli_smb2_create_fnum_send(
936 state,
937 state->ev,
938 state->cli,
939 state->dname,
940 (struct cli_smb2_create_flags){0},
941 SMB2_IMPERSONATION_IMPERSONATION,
942 DELETE_ACCESS, /* desired_access */
943 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
944 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
945 FILE_OPEN, /* create_disposition */
946 FILE_DIRECTORY_FILE|
947 FILE_DELETE_ON_CLOSE|
948 FILE_OPEN_REPARSE_POINT, /* create_options */
949 state->in_cblobs); /* in_cblobs */
950 if (tevent_req_nomem(subreq, req)) {
951 return;
952 }
953 tevent_req_set_callback(subreq, cli_smb2_rmdir_opened2, req);
954 return;
955 }
956
957 if (tevent_req_nterror(req, status)) {
958 return;
959 }
960
961 subreq = cli_smb2_delete_on_close_send(
962 state, state->ev, state->cli, state->fnum, true);
963 if (tevent_req_nomem(subreq, req)) {
964 return;
965 }
966 tevent_req_set_callback(subreq, cli_smb2_rmdir_disp_set, req);
967 }
968
969 static void cli_smb2_rmdir_opened2(struct tevent_req *subreq)
970 {
971 struct tevent_req *req = tevent_req_callback_data(
972 subreq, struct tevent_req);
973 struct cli_smb2_rmdir_state *state = tevent_req_data(
974 req, struct cli_smb2_rmdir_state);
975 NTSTATUS status;
976
977 status = cli_smb2_create_fnum_recv(
978 subreq, &state->fnum, NULL, NULL, NULL, NULL);
979 TALLOC_FREE(subreq);
980 if (tevent_req_nterror(req, status)) {
981 return;
982 }
983
984 subreq = cli_smb2_delete_on_close_send(
985 state, state->ev, state->cli, state->fnum, true);
986 if (tevent_req_nomem(subreq, req)) {
987 return;
988 }
989 tevent_req_set_callback(subreq, cli_smb2_rmdir_disp_set, req);
990 }
991
992 static void cli_smb2_rmdir_disp_set(struct tevent_req *subreq)
993 {
994 struct tevent_req *req = tevent_req_callback_data(
995 subreq, struct tevent_req);
996 struct cli_smb2_rmdir_state *state = tevent_req_data(
997 req, struct cli_smb2_rmdir_state);
998
999 state->status = cli_smb2_delete_on_close_recv(subreq);
1000 TALLOC_FREE(subreq);
1001
1002 /*
1003 * Close the fd even if the set_disp failed
1004 */
1005
1006 subreq = cli_smb2_close_fnum_send(
1007 state, state->ev, state->cli, state->fnum);
1008 if (tevent_req_nomem(subreq, req)) {
1009 return;
1010 }
1011 tevent_req_set_callback(subreq, cli_smb2_rmdir_closed, req);
1012 }
1013
1014 static void cli_smb2_rmdir_closed(struct tevent_req *subreq)
1015 {
1016 NTSTATUS status = cli_smb2_close_fnum_recv(subreq);
1017 tevent_req_simple_finish_ntstatus(subreq, status);
1018 }
1019
1020 NTSTATUS cli_smb2_rmdir_recv(struct tevent_req *req)
1021 {
1022 struct cli_smb2_rmdir_state *state = tevent_req_data(
1023 req, struct cli_smb2_rmdir_state);
1024 NTSTATUS status;
1025
1026 if (tevent_req_is_nterror(req, &status)) {
1027 return status;
1028 }
1029 return state->status;
1030 }
1031
1032 /***************************************************************
1033 Small wrapper that allows SMB2 to unlink a pathname.
1034 ***************************************************************/
1035
1036 struct cli_smb2_unlink_state {
1037 struct tevent_context *ev;
1038 struct cli_state *cli;
1039 const char *fname;
1040 const struct smb2_create_blobs *in_cblobs;
1041 };
1042
1043 static void cli_smb2_unlink_opened1(struct tevent_req *subreq);
1044 static void cli_smb2_unlink_opened2(struct tevent_req *subreq);
1045 static void cli_smb2_unlink_closed(struct tevent_req *subreq);
1046
1047 struct tevent_req *cli_smb2_unlink_send(
1048 TALLOC_CTX *mem_ctx,
1049 struct tevent_context *ev,
1050 struct cli_state *cli,
1051 const char *fname,
1052 const struct smb2_create_blobs *in_cblobs)
1053 {
1054 struct tevent_req *req = NULL, *subreq = NULL;
1055 struct cli_smb2_unlink_state *state = NULL;
1056
1057 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_unlink_state);
1058 if (req == NULL) {
1059 return NULL;
1060 }
1061 state->ev = ev;
1062 state->cli = cli;
1063 state->fname = fname;
1064 state->in_cblobs = in_cblobs;
1065
1066 subreq = cli_smb2_create_fnum_send(
1067 state, /* mem_ctx */
1068 state->ev, /* tevent_context */
1069 state->cli, /* cli_struct */
1070 state->fname, /* filename */
1071 (struct cli_smb2_create_flags){0},
1072 SMB2_IMPERSONATION_IMPERSONATION,
1073 DELETE_ACCESS, /* desired_access */
1074 FILE_ATTRIBUTE_NORMAL, /* file attributes */
1075 FILE_SHARE_READ|
1076 FILE_SHARE_WRITE|
1077 FILE_SHARE_DELETE, /* share_access */
1078 FILE_OPEN, /* create_disposition */
1079 FILE_DELETE_ON_CLOSE, /* create_options */
1080 state->in_cblobs); /* in_cblobs */
1081 if (tevent_req_nomem(subreq, req)) {
1082 return tevent_req_post(req, ev);
1083 }
1084 tevent_req_set_callback(subreq, cli_smb2_unlink_opened1, req);
1085 return req;
1086 }
1087
1088 static void cli_smb2_unlink_opened1(struct tevent_req *subreq)
1089 {
1090 struct tevent_req *req = tevent_req_callback_data(
1091 subreq, struct tevent_req);
1092 struct cli_smb2_unlink_state *state = tevent_req_data(
1093 req, struct cli_smb2_unlink_state);
1094 uint16_t fnum = 0xffff;
1095 NTSTATUS status;
1096
1097 status = cli_smb2_create_fnum_recv(
1098 subreq, &fnum, NULL, NULL, NULL, NULL);
1099 TALLOC_FREE(subreq);
1100
1101 if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK) ||
1102 NT_STATUS_EQUAL(status, NT_STATUS_IO_REPARSE_TAG_NOT_HANDLED)) {
1103 /*
1104 * Naive option to match our SMB1 code. Assume the
1105 * symlink path that tripped us up was the last
1106 * component and try again. Eventually we will have to
1107 * deal with the returned path unprocessed component. JRA.
1108 */
1109 subreq = cli_smb2_create_fnum_send(
1110 state, /* mem_ctx */
1111 state->ev, /* tevent_context */
1112 state->cli, /* cli_struct */
1113 state->fname, /* filename */
1114 (struct cli_smb2_create_flags){0},
1115 SMB2_IMPERSONATION_IMPERSONATION,
1116 DELETE_ACCESS, /* desired_access */
1117 FILE_ATTRIBUTE_NORMAL, /* file attributes */
1118 FILE_SHARE_READ|
1119 FILE_SHARE_WRITE|
1120 FILE_SHARE_DELETE, /* share_access */
1121 FILE_OPEN, /* create_disposition */
1122 FILE_DELETE_ON_CLOSE|
1123 FILE_OPEN_REPARSE_POINT, /* create_options */
1124 state->in_cblobs); /* in_cblobs */
1125 if (tevent_req_nomem(subreq, req)) {
1126 return;
1127 }
1128 tevent_req_set_callback(subreq, cli_smb2_unlink_opened2, req);
1129 return;
1130 }
1131
1132 if (tevent_req_nterror(req, status)) {
1133 return;
1134 }
1135
1136 subreq = cli_smb2_close_fnum_send(state, state->ev, state->cli, fnum);
1137 if (tevent_req_nomem(subreq, req)) {
1138 return;
1139 }
1140 tevent_req_set_callback(subreq, cli_smb2_unlink_closed, req);
1141 }
1142
1143 static void cli_smb2_unlink_opened2(struct tevent_req *subreq)
1144 {
1145 struct tevent_req *req = tevent_req_callback_data(
1146 subreq, struct tevent_req);
1147 struct cli_smb2_unlink_state *state = tevent_req_data(
1148 req, struct cli_smb2_unlink_state);
1149 uint16_t fnum = 0xffff;
1150 NTSTATUS status;
1151
1152 status = cli_smb2_create_fnum_recv(
1153 subreq, &fnum, NULL, NULL, NULL, NULL);
1154 TALLOC_FREE(subreq);
1155 if (tevent_req_nterror(req, status)) {
1156 return;
1157 }
1158
1159 subreq = cli_smb2_close_fnum_send(state, state->ev, state->cli, fnum);
1160 if (tevent_req_nomem(subreq, req)) {
1161 return;
1162 }
1163 tevent_req_set_callback(subreq, cli_smb2_unlink_closed, req);
1164 }
1165
1166 static void cli_smb2_unlink_closed(struct tevent_req *subreq)
1167 {
1168 NTSTATUS status = cli_smb2_close_fnum_recv(subreq);
1169 tevent_req_simple_finish_ntstatus(subreq, status);
1170 }
1171
1172 NTSTATUS cli_smb2_unlink_recv(struct tevent_req *req)
1173 {
1174 return tevent_req_simple_recv_ntstatus(req);
1175 }
1176
1177 static ssize_t sid_parse_wire(TALLOC_CTX *mem_ctx, const uint8_t *data,
1178 struct dom_sid *sid, size_t num_rdata)
1179 {
1180 size_t sid_size;
1181 enum ndr_err_code ndr_err;
1182 DATA_BLOB in = data_blob_const(data, num_rdata);
1183
1184 ndr_err = ndr_pull_struct_blob(&in,
1185 mem_ctx,
1186 sid,
1187 (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
1188 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1189 return 0;
1190 }
1191
1192 sid_size = ndr_size_dom_sid(sid, 0);
1193 if (sid_size > num_rdata) {
1194 return 0;
1195 }
1196
1197 return sid_size;
1198 }
1199
1200 /***************************************************************
1201 Utility function to parse a SMB2_FIND_POSIX_INFORMATION reply.
1202 ***************************************************************/
1203
1204 static NTSTATUS parse_finfo_posix_info(const uint8_t *dir_data,
1205 uint32_t dir_data_length,
1206 struct file_info *finfo,
1207 uint32_t *next_offset)
1208 {
1209 size_t namelen = 0;
1210 size_t slen = 0, slen2 = 0;
1211 size_t ret = 0;
1212 uint32_t _next_offset = 0;
1213
1214 if (dir_data_length < 4) {
1215 return NT_STATUS_INFO_LENGTH_MISMATCH;
1216 }
1217
1218 _next_offset = IVAL(dir_data, 0);
1219
1220 if (_next_offset > dir_data_length) {
1221 return NT_STATUS_INFO_LENGTH_MISMATCH;
1222 }
1223
1224 if (_next_offset != 0) {
1225 /* Ensure we only read what in this record. */
1226 dir_data_length = _next_offset;
1227 }
1228
1229 if (dir_data_length < 92) {
1230 return NT_STATUS_INFO_LENGTH_MISMATCH;
1231 }
1232
1233 finfo->btime_ts = interpret_long_date((const char *)dir_data + 8);
1234 finfo->atime_ts = interpret_long_date((const char *)dir_data + 16);
1235 finfo->mtime_ts = interpret_long_date((const char *)dir_data + 24);
1236 finfo->ctime_ts = interpret_long_date((const char *)dir_data + 32);
1237 finfo->allocated_size = PULL_LE_U64(dir_data, 40);
1238 finfo->size = PULL_LE_U64(dir_data, 48);
1239 finfo->mode = PULL_LE_U32(dir_data, 56);
1240 finfo->ino = PULL_LE_U64(dir_data, 60);
1241 finfo->st_ex_dev = PULL_LE_U32(dir_data, 68);
1242 finfo->st_ex_nlink = PULL_LE_U32(dir_data, 76);
1243 finfo->reparse_tag = PULL_LE_U32(dir_data, 80);
1244 finfo->st_ex_mode = wire_perms_to_unix(PULL_LE_U32(dir_data, 84));
1245
1246 slen = sid_parse_wire(finfo, dir_data+88, &finfo->owner_sid,
1247 dir_data_length-88);
1248 if (slen == 0) {
1249 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1250 }
1251 slen2 = sid_parse_wire(finfo, dir_data+88+slen, &finfo->group_sid,
1252 dir_data_length-88-slen);
1253 if (slen2 == 0) {
1254 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1255 }
1256 slen += slen2;
1257
1258 namelen = PULL_LE_U32(dir_data, 88+slen);
1259 ret = pull_string_talloc(finfo,
1260 dir_data,
1261 FLAGS2_UNICODE_STRINGS,
1262 &finfo->name,
1263 dir_data+92+slen,
1264 namelen,
1265 STR_UNICODE);
1266 if (ret == (size_t)-1) {
1267 /* Bad conversion. */
1268 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1269 }
1270
1271 if (finfo->name == NULL) {
1272 /* Bad conversion. */
1273 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1274 }
1275
1276 *next_offset = _next_offset;
1277 return NT_STATUS_OK;
1278 }
1279
1280 /***************************************************************
1281 Utility function to parse a SMB2_FIND_ID_BOTH_DIRECTORY_INFO reply.
1282 ***************************************************************/
1283
1284 static NTSTATUS parse_finfo_id_both_directory_info(const uint8_t *dir_data,
1285 uint32_t dir_data_length,
1286 struct file_info *finfo,
1287 uint32_t *next_offset)
1288 {
1289 size_t namelen = 0;
1290 size_t slen = 0;
1291 size_t ret = 0;
1292
1293 if (dir_data_length < 4) {
1294 return NT_STATUS_INFO_LENGTH_MISMATCH;
1295 }
1296
1297 *next_offset = IVAL(dir_data, 0);
1298
1299 if (*next_offset > dir_data_length) {
1300 return NT_STATUS_INFO_LENGTH_MISMATCH;
1301 }
1302
1303 if (*next_offset != 0) {
1304 /* Ensure we only read what in this record. */
1305 dir_data_length = *next_offset;
1306 }
1307
1308 if (dir_data_length < 105) {
1309 return NT_STATUS_INFO_LENGTH_MISMATCH;
1310 }
1311
1312 finfo->btime_ts = interpret_long_date((const char *)dir_data + 8);
1313 finfo->atime_ts = interpret_long_date((const char *)dir_data + 16);
1314 finfo->mtime_ts = interpret_long_date((const char *)dir_data + 24);
1315 finfo->ctime_ts = interpret_long_date((const char *)dir_data + 32);
1316 finfo->size = IVAL2_TO_SMB_BIG_UINT(dir_data + 40, 0);
1317 finfo->allocated_size = IVAL2_TO_SMB_BIG_UINT(dir_data + 48, 0);
1318 finfo->attr = IVAL(dir_data + 56, 0);
1319 finfo->ino = IVAL2_TO_SMB_BIG_UINT(dir_data + 96, 0);
1320 namelen = IVAL(dir_data + 60,0);
1321 if (namelen > (dir_data_length - 104)) {
1322 return NT_STATUS_INFO_LENGTH_MISMATCH;
1323 }
1324 slen = CVAL(dir_data + 68, 0);
1325 if (slen > 24) {
1326 return NT_STATUS_INFO_LENGTH_MISMATCH;
1327 }
1328 ret = pull_string_talloc(finfo,
1329 dir_data,
1330 FLAGS2_UNICODE_STRINGS,
1331 &finfo->short_name,
1332 dir_data + 70,
1333 slen,
1334 STR_UNICODE);
1335 if (ret == (size_t)-1) {
1336 /* Bad conversion. */
1337 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1338 }
1339
1340 ret = pull_string_talloc(finfo,
1341 dir_data,
1342 FLAGS2_UNICODE_STRINGS,
1343 &finfo->name,
1344 dir_data + 104,
1345 namelen,
1346 STR_UNICODE);
1347 if (ret == (size_t)-1) {
1348 /* Bad conversion. */
1349 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1350 }
1351
1352 if (finfo->name == NULL) {
1353 /* Bad conversion. */
1354 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1355 }
1356
1357 return NT_STATUS_OK;
1358 }
1359
1360 /*******************************************************************
1361 Given a filename - get its directory name
1362 ********************************************************************/
1363
1364 static bool windows_parent_dirname(TALLOC_CTX *mem_ctx,
1365 const char *dir,
1366 char **parent,
1367 const char **name)
1368 {
1369 char *p;
1370 ptrdiff_t len;
1371
1372 p = strrchr_m(dir, '\\'); /* Find final '\\', if any */
1373
1374 if (p == NULL) {
1375 if (!(*parent = talloc_strdup(mem_ctx, "\\"))) {
1376 return false;
1377 }
1378 if (name) {
1379 *name = dir;
1380 }
1381 return true;
1382 }
1383
1384 len = p-dir;
1385
1386 if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
1387 return false;
1388 }
1389 (*parent)[len] = '\0';
1390
1391 if (name) {
1392 *name = p+1;
1393 }
1394 return true;
1395 }
1396
1397 struct cli_smb2_list_dir_data {
1398 uint8_t *data;
1399 uint32_t length;
1400 };
1401
1402 struct cli_smb2_list_state {
1403 struct tevent_context *ev;
1404 struct cli_state *cli;
1405 const char *mask;
1406
1407 uint16_t fnum;
1408
1409 NTSTATUS status;
1410 struct cli_smb2_list_dir_data *response;
1411 uint32_t offset;
1412 unsigned int info_level;
1413 };
1414
1415 static void cli_smb2_list_opened(struct tevent_req *subreq);
1416 static void cli_smb2_list_done(struct tevent_req *subreq);
1417 static void cli_smb2_list_closed(struct tevent_req *subreq);
1418
1419 struct tevent_req *cli_smb2_list_send(
1420 TALLOC_CTX *mem_ctx,
1421 struct tevent_context *ev,
1422 struct cli_state *cli,
1423 const char *pathname,
1424 unsigned int info_level,
1425 bool posix)
1426 {
1427 struct tevent_req *req = NULL, *subreq = NULL;
1428 struct cli_smb2_list_state *state = NULL;
1429 char *parent = NULL;
1430 bool ok;
1431 struct smb2_create_blobs *in_cblobs = NULL;
1432
1433 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_list_state);
1434 if (req == NULL) {
1435 return NULL;
1436 }
1437 state->ev = ev;
1438 state->cli = cli;
1439 state->status = NT_STATUS_OK;
1440 state->info_level = info_level;
1441
1442 ok = windows_parent_dirname(state, pathname, &parent, &state->mask);
1443 if (!ok) {
1444 tevent_req_oom(req);
1445 return tevent_req_post(req, ev);
1446 }
1447
1448 if (smbXcli_conn_have_posix(cli->conn) && posix) {
1449 NTSTATUS status;
1450
1451 /* The mode MUST be 0 when opening an existing file/dir, and
1452 * will be ignored by the server.
1453 */
1454 uint8_t linear_mode[4] = { 0 };
1455 DATA_BLOB blob = { .data=linear_mode,
1456 .length=sizeof(linear_mode) };
1457
1458 in_cblobs = talloc_zero(mem_ctx, struct smb2_create_blobs);
1459 if (in_cblobs == NULL) {
1460 return NULL;
1461 }
1462
1463 status = smb2_create_blob_add(in_cblobs, in_cblobs,
1464 SMB2_CREATE_TAG_POSIX, blob);
1465 if (!NT_STATUS_IS_OK(status)) {
1466 tevent_req_nterror(req, status);
1467 return tevent_req_post(req, ev);
1468 }
1469 }
1470
1471 subreq = cli_smb2_create_fnum_send(
1472 state, /* mem_ctx */
1473 ev, /* ev */
1474 cli, /* cli */
1475 parent, /* fname */
1476 (struct cli_smb2_create_flags){0}, /* create_flags */
1477 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level */
1478 SEC_DIR_LIST|SEC_DIR_READ_ATTRIBUTE, /* desired_access */
1479 FILE_ATTRIBUTE_DIRECTORY, /* file_attributes */
1480 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
1481 FILE_OPEN, /* create_disposition */
1482 FILE_DIRECTORY_FILE, /* create_options */
1483 in_cblobs); /* in_cblobs */
1484 TALLOC_FREE(in_cblobs);
1485 if (tevent_req_nomem(subreq, req)) {
1486 return tevent_req_post(req, ev);
1487 }
1488 tevent_req_set_callback(subreq, cli_smb2_list_opened, req);
1489 return req;
1490 }
1491
1492 static void cli_smb2_list_opened(struct tevent_req *subreq)
1493 {
1494 struct tevent_req *req = tevent_req_callback_data(
1495 subreq, struct tevent_req);
1496 struct cli_smb2_list_state *state = tevent_req_data(
1497 req, struct cli_smb2_list_state);
1498 NTSTATUS status;
1499
1500 status = cli_smb2_create_fnum_recv(
1501 subreq, &state->fnum, NULL, NULL, NULL, NULL);
1502 TALLOC_FREE(subreq);
1503 if (tevent_req_nterror(req, status)) {
1504 return;
1505 }
1506
1507 /*
1508 * Make our caller get back to us via cli_smb2_list_recv(),
1509 * triggering the smb2_query_directory_send()
1510 */
1511 tevent_req_defer_callback(req, state->ev);
1512 tevent_req_notify_callback(req);
1513 }
1514
1515 static void cli_smb2_list_done(struct tevent_req *subreq)
1516 {
1517 struct tevent_req *req = tevent_req_callback_data(
1518 subreq, struct tevent_req);
1519 struct cli_smb2_list_state *state = tevent_req_data(
1520 req, struct cli_smb2_list_state);
1521 struct cli_smb2_list_dir_data *response = NULL;
1522
1523 response = talloc(state, struct cli_smb2_list_dir_data);
1524 if (tevent_req_nomem(response, req)) {
1525 return;
1526 }
1527
1528 state->status = smb2cli_query_directory_recv(
1529 subreq, response, &response->data, &response->length);
1530 TALLOC_FREE(subreq);
1531
1532 if (NT_STATUS_IS_OK(state->status)) {
1533 state->response = response;
1534 state->offset = 0;
1535
1536 tevent_req_defer_callback(req, state->ev);
1537 tevent_req_notify_callback(req);
1538 return;
1539 }
1540
1541 TALLOC_FREE(response);
1542
1543 subreq = cli_smb2_close_fnum_send(
1544 state, state->ev, state->cli, state->fnum);
1545 if (tevent_req_nomem(subreq, req)) {
1546 return;
1547 }
1548 tevent_req_set_callback(subreq, cli_smb2_list_closed, req);
1549 }
1550
1551 static void cli_smb2_list_closed(struct tevent_req *subreq)
1552 {
1553 NTSTATUS status = cli_smb2_close_fnum_recv(subreq);
1554 tevent_req_simple_finish_ntstatus(subreq, status);
1555 }
1556
1557 /*
1558 * Return the next finfo directory.
1559 *
1560 * This parses the blob returned from QUERY_DIRECTORY step by step. If
1561 * the blob ends, this triggers a fresh QUERY_DIRECTORY and returns
1562 * NT_STATUS_RETRY, which will then trigger the caller again when the
1563 * QUERY_DIRECTORY has returned with another buffer. This way we
1564 * guarantee that no asynchronous request is open after this call
1565 * returns an entry, so that other synchronous requests can be issued
1566 * on the same connection while the directoy listing proceeds.
1567 */
1568 NTSTATUS cli_smb2_list_recv(
1569 struct tevent_req *req,
1570 TALLOC_CTX *mem_ctx,
1571 struct file_info **pfinfo)
1572 {
1573 struct cli_smb2_list_state *state = tevent_req_data(
1574 req, struct cli_smb2_list_state);
1575 struct cli_smb2_list_dir_data *response = NULL;
1576 struct file_info *finfo = NULL;
1577 NTSTATUS status;
1578 uint32_t next_offset = 0;
1579 bool in_progress;
1580
1581 in_progress = tevent_req_is_in_progress(req);
1582
1583 if (!in_progress) {
1584 if (!tevent_req_is_nterror(req, &status)) {
1585 status = NT_STATUS_NO_MORE_FILES;
1586 }
1587 goto fail;
1588 }
1589
1590 response = state->response;
1591 if (response == NULL) {
1592 struct tevent_req *subreq = NULL;
1593 struct cli_state *cli = state->cli;
1594 struct smb2_hnd *ph = NULL;
1595 uint32_t max_trans, max_avail_len;
1596 bool ok;
1597
1598 if (!NT_STATUS_IS_OK(state->status)) {
1599 status = state->status;
1600 goto fail;
1601 }
1602
1603 status = map_fnum_to_smb2_handle(cli, state->fnum, &ph);
1604 if (!NT_STATUS_IS_OK(status)) {
1605 goto fail;
1606 }
1607
1608 max_trans = smb2cli_conn_max_trans_size(cli->conn);
1609 ok = smb2cli_conn_req_possible(cli->conn, &max_avail_len);
1610 if (ok) {
1611 max_trans = MIN(max_trans, max_avail_len);
1612 }
1613
1614 subreq = smb2cli_query_directory_send(
1615 state, /* mem_ctx */
1616 state->ev, /* ev */
1617 cli->conn, /* conn */
1618 cli->timeout, /* timeout_msec */
1619 cli->smb2.session, /* session */
1620 cli->smb2.tcon, /* tcon */
1621 state->info_level, /* level */
1622 0, /* flags */
1623 0, /* file_index */
1624 ph->fid_persistent, /* fid_persistent */
1625 ph->fid_volatile, /* fid_volatile */
1626 state->mask, /* mask */
1627 max_trans); /* outbuf_len */
1628 if (subreq == NULL) {
1629 status = NT_STATUS_NO_MEMORY;
1630 goto fail;
1631 }
1632 tevent_req_set_callback(subreq, cli_smb2_list_done, req);
1633 return NT_STATUS_RETRY;
1634 }
1635
1636 SMB_ASSERT(response->length > state->offset);
1637
1638 finfo = talloc_zero(mem_ctx, struct file_info);
1639 if (finfo == NULL) {
1640 status = NT_STATUS_NO_MEMORY;
1641 goto fail;
1642 }
1643
1644 if (state->info_level == SMB2_FIND_POSIX_INFORMATION) {
1645 status = parse_finfo_posix_info(
1646 response->data + state->offset,
1647 response->length - state->offset,
1648 finfo,
1649 &next_offset);
1650 } else {
1651 status = parse_finfo_id_both_directory_info(
1652 response->data + state->offset,
1653 response->length - state->offset,
1654 finfo,
1655 &next_offset);
1656 }
1657 if (!NT_STATUS_IS_OK(status)) {
1658 goto fail;
1659 }
1660
1661 status = is_bad_finfo_name(state->cli, finfo);
1662 if (!NT_STATUS_IS_OK(status)) {
1663 goto fail;
1664 }
1665
1666 /*
1667 * parse_finfo_id_both_directory_info() checks for overflow,
1668 * no need to check again here.
1669 */
1670 state->offset += next_offset;
1671
1672 if (next_offset == 0) {
1673 TALLOC_FREE(state->response);
1674 }
1675
1676 tevent_req_defer_callback(req, state->ev);
1677 tevent_req_notify_callback(req);
1678
1679 *pfinfo = finfo;
1680 return NT_STATUS_OK;
1681
1682 fail:
1683 TALLOC_FREE(finfo);
1684 tevent_req_received(req);
1685 return status;
1686 }
1687
1688 /***************************************************************
1689 Wrapper that allows SMB2 to query a path info (basic level).
1690 Synchronous only.
1691 ***************************************************************/
1692
1693 NTSTATUS cli_smb2_qpathinfo_basic(struct cli_state *cli,
1694 const char *name,
1695 SMB_STRUCT_STAT *sbuf,
1696 uint32_t *attributes)
1697 {
1698 NTSTATUS status;
1699 struct smb_create_returns cr;
1700 uint16_t fnum = 0xffff;
1701 size_t namelen = strlen(name);
1702
1703 if (smbXcli_conn_has_async_calls(cli->conn)) {
1704 /*
1705 * Can't use sync call while an async call is in flight
1706 */
1707 return NT_STATUS_INVALID_PARAMETER;
1708 }
1709
1710 /* SMB2 is pickier about pathnames. Ensure it doesn't
1711 end in a '\' */
1712 if (namelen > 0 && name[namelen-1] == '\\') {
1713 char *modname = talloc_strndup(talloc_tos(), name, namelen-1);
1714 if (modname == NULL) {
1715 return NT_STATUS_NO_MEMORY;
1716 }
1717 name = modname;
1718 }
1719
1720 /* This is commonly used as a 'cd'. Try qpathinfo on
1721 a directory handle first. */
1722
1723 status = cli_smb2_create_fnum(cli,
1724 name,
1725 (struct cli_smb2_create_flags){0},
1726 SMB2_IMPERSONATION_IMPERSONATION,
1727 FILE_READ_ATTRIBUTES, /* desired_access */
1728 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1729 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1730 FILE_OPEN, /* create_disposition */
1731 FILE_DIRECTORY_FILE, /* create_options */
1732 NULL,
1733 &fnum,
1734 &cr,
1735 NULL,
1736 NULL);
1737
1738 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
1739 /* Maybe a file ? */
1740 status = cli_smb2_create_fnum(cli,
1741 name,
1742 (struct cli_smb2_create_flags){0},
1743 SMB2_IMPERSONATION_IMPERSONATION,
1744 FILE_READ_ATTRIBUTES, /* desired_access */
1745 0, /* file attributes */
1746 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1747 FILE_OPEN, /* create_disposition */
1748 0, /* create_options */
1749 NULL,
1750 &fnum,
1751 &cr,
1752 NULL,
1753 NULL);
1754 }
1755
1756 if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK)) {
1757 /* Maybe a reparse point ? */
1758 status = cli_smb2_create_fnum(cli,
1759 name,
1760 (struct cli_smb2_create_flags){0},
1761 SMB2_IMPERSONATION_IMPERSONATION,
1762 FILE_READ_ATTRIBUTES, /* desired_access */
1763 0, /* file attributes */
1764 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1765 FILE_OPEN, /* create_disposition */
1766 FILE_OPEN_REPARSE_POINT, /* create_options */
1767 NULL,
1768 &fnum,
1769 &cr,
1770 NULL,
1771 NULL);
1772 }
1773
1774 if (!NT_STATUS_IS_OK(status)) {
1775 return status;
1776 }
1777
1778 status = cli_smb2_close_fnum(cli, fnum);
1779
1780 ZERO_STRUCTP(sbuf);
1781
1782 sbuf->st_ex_atime = nt_time_to_unix_timespec(cr.last_access_time);
1783 sbuf->st_ex_mtime = nt_time_to_unix_timespec(cr.last_write_time);
1784 sbuf->st_ex_ctime = nt_time_to_unix_timespec(cr.change_time);
1785 sbuf->st_ex_size = cr.end_of_file;
1786 *attributes = cr.file_attributes;
1787
1788 return status;
1789 }
1790
1791 struct cli_smb2_query_info_fnum_state {
1792 DATA_BLOB outbuf;
1793 };
1794
1795 static void cli_smb2_query_info_fnum_done(struct tevent_req *subreq);
1796
1797 struct tevent_req *cli_smb2_query_info_fnum_send(
1798 TALLOC_CTX *mem_ctx,
1799 struct tevent_context *ev,
1800 struct cli_state *cli,
1801 uint16_t fnum,
1802 uint8_t in_info_type,
1803 uint8_t in_info_class,
1804 uint32_t in_max_output_length,
1805 const DATA_BLOB *in_input_buffer,
1806 uint32_t in_additional_info,
1807 uint32_t in_flags)
1808 {
1809 struct tevent_req *req = NULL, *subreq = NULL;
1810 struct cli_smb2_query_info_fnum_state *state = NULL;
1811 struct smb2_hnd *ph = NULL;
1812 NTSTATUS status;
1813
1814 req = tevent_req_create(
1815 mem_ctx, &state, struct cli_smb2_query_info_fnum_state);
1816 if (req == NULL) {
1817 return req;
1818 }
1819
1820 status = map_fnum_to_smb2_handle(cli, fnum, &ph);
1821 if (tevent_req_nterror(req, status)) {
1822 return tevent_req_post(req, ev);
1823 }
1824
1825 subreq = smb2cli_query_info_send(
1826 state,
1827 ev,
1828 cli->conn,
1829 cli->timeout,
1830 cli->smb2.session,
1831 cli->smb2.tcon,
1832 in_info_type,
1833 in_info_class,
1834 in_max_output_length,
1835 in_input_buffer,
1836 in_additional_info,
1837 in_flags,
1838 ph->fid_persistent,
1839 ph->fid_volatile);
1840 if (tevent_req_nomem(subreq, req)) {
1841 return tevent_req_post(req, ev);
1842 }
1843 tevent_req_set_callback(subreq, cli_smb2_query_info_fnum_done, req);
1844 return req;
1845 }
1846
1847 static void cli_smb2_query_info_fnum_done(struct tevent_req *subreq)
1848 {
1849 struct tevent_req *req = tevent_req_callback_data(
1850 subreq, struct tevent_req);
1851 struct cli_smb2_query_info_fnum_state *state = tevent_req_data(
1852 req, struct cli_smb2_query_info_fnum_state);
1853 DATA_BLOB outbuf;
1854 NTSTATUS status;
1855
1856 status = smb2cli_query_info_recv(subreq, state, &outbuf);
1857 TALLOC_FREE(subreq);
1858 if (tevent_req_nterror(req, status)) {
1859 return;
1860 }
1861
1862 /*
1863 * We have to dup the memory here because outbuf.data is not
1864 * returned as a talloc object by smb2cli_query_info_recv.
1865 * It's a pointer into the received buffer.
1866 */
1867 state->outbuf = data_blob_dup_talloc(state, outbuf);
1868
1869 if ((outbuf.length != 0) &&
1870 tevent_req_nomem(state->outbuf.data, req)) {
1871 return;
1872 }
1873 tevent_req_done(req);
1874 }
1875
1876 NTSTATUS cli_smb2_query_info_fnum_recv(
1877 struct tevent_req *req, TALLOC_CTX *mem_ctx, DATA_BLOB *outbuf)
1878 {
1879 struct cli_smb2_query_info_fnum_state *state = tevent_req_data(
1880 req, struct cli_smb2_query_info_fnum_state);
1881 NTSTATUS status;
1882
1883 if (tevent_req_is_nterror(req, &status)) {
1884 return status;
1885 }
1886 *outbuf = (DATA_BLOB) {
1887 .data = talloc_move(mem_ctx, &state->outbuf.data),
1888 .length = state->outbuf.length,
1889 };
1890 return NT_STATUS_OK;
1891 }
1892
1893 NTSTATUS cli_smb2_query_info_fnum(
1894 struct cli_state *cli,
1895 uint16_t fnum,
1896 uint8_t in_info_type,
1897 uint8_t in_info_class,
1898 uint32_t in_max_output_length,
1899 const DATA_BLOB *in_input_buffer,
1900 uint32_t in_additional_info,
1901 uint32_t in_flags,
1902 TALLOC_CTX *mem_ctx,
1903 DATA_BLOB *outbuf)
1904 {
1905 TALLOC_CTX *frame = talloc_stackframe();
1906 struct tevent_context *ev = NULL;
1907 struct tevent_req *req = NULL;
1908 NTSTATUS status = NT_STATUS_NO_MEMORY;
1909 bool ok;
1910
1911 if (smbXcli_conn_has_async_calls(cli->conn)) {
1912 /*
1913 * Can't use sync call while an async call is in flight
1914 */
1915 status = NT_STATUS_INVALID_PARAMETER;
1916 goto fail;
1917 }
1918 ev = samba_tevent_context_init(frame);
1919 if (ev == NULL) {
1920 goto fail;
1921 }
1922 req = cli_smb2_query_info_fnum_send(
1923 frame,
1924 ev,
1925 cli,
1926 fnum,
1927 in_info_type,
1928 in_info_class,
1929 in_max_output_length,
1930 in_input_buffer,
1931 in_additional_info,
1932 in_flags);
1933 if (req == NULL) {
1934 goto fail;
1935 }
1936 ok = tevent_req_poll_ntstatus(req, ev, &status);
1937 if (!ok) {
1938 goto fail;
1939 }
1940 status = cli_smb2_query_info_fnum_recv(req, mem_ctx, outbuf);
1941 fail:
1942 TALLOC_FREE(frame);
1943 return status;
1944 }
1945
1946 /***************************************************************
1947 Helper function for pathname operations.
1948 ***************************************************************/
1949
1950 struct get_fnum_from_path_state {
1951 struct tevent_context *ev;
1952 struct cli_state *cli;
1953 const char *name;
1954 uint32_t desired_access;
1955 uint16_t fnum;
1956 };
1957
1958 static void get_fnum_from_path_opened_file(struct tevent_req *subreq);
1959 static void get_fnum_from_path_opened_reparse(struct tevent_req *subreq);
1960 static void get_fnum_from_path_opened_dir(struct tevent_req *subreq);
1961
1962 static struct tevent_req *get_fnum_from_path_send(
1963 TALLOC_CTX *mem_ctx,
1964 struct tevent_context *ev,
1965 struct cli_state *cli,
1966 const char *name,
1967 uint32_t desired_access)
1968 {
1969 struct tevent_req *req = NULL, *subreq = NULL;
1970 struct get_fnum_from_path_state *state = NULL;
1971 size_t namelen = strlen(name);
1972
1973 req = tevent_req_create(
1974 mem_ctx, &state, struct get_fnum_from_path_state);
1975 if (req == NULL) {
1976 return NULL;
1977 }
1978 state->ev = ev;
1979 state->cli = cli;
1980 state->name = name;
1981 state->desired_access = desired_access;
1982
1983 /*
1984 * SMB2 is pickier about pathnames. Ensure it doesn't end in a
1985 * '\'
1986 */
1987 if (namelen > 0 && name[namelen-1] == '\\') {
1988 state->name = talloc_strndup(state, name, namelen-1);
1989 if (tevent_req_nomem(state->name, req)) {
1990 return tevent_req_post(req, ev);
1991 }
1992 }
1993
1994 subreq = cli_smb2_create_fnum_send(
1995 state, /* mem_ctx, */
1996 ev, /* ev */
1997 cli, /* cli */
1998 state->name, /* fname */
1999 (struct cli_smb2_create_flags){0}, /* create_flags */
2000 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level */
2001 desired_access, /* desired_access */
2002 0, /* file_attributes */
2003 FILE_SHARE_READ|
2004 FILE_SHARE_WRITE|
2005 FILE_SHARE_DELETE, /* share_access */
2006 FILE_OPEN, /* create_disposition */
2007 0, /* create_options */
2008 NULL); /* in_cblobs */
2009 if (tevent_req_nomem(subreq, req)) {
2010 return tevent_req_post(req, ev);
2011 }
2012 tevent_req_set_callback(subreq, get_fnum_from_path_opened_file, req);
2013 return req;
2014 }
2015
2016 static void get_fnum_from_path_opened_file(struct tevent_req *subreq)
2017 {
2018 struct tevent_req *req = tevent_req_callback_data(
2019 subreq, struct tevent_req);
2020 struct get_fnum_from_path_state *state = tevent_req_data(
2021 req, struct get_fnum_from_path_state);
2022 NTSTATUS status;
2023
2024 status = cli_smb2_create_fnum_recv(
2025 subreq, &state->fnum, NULL, NULL, NULL, NULL);
2026 TALLOC_FREE(subreq);
2027
2028 if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK)) {
2029 /*
2030 * Naive option to match our SMB1 code. Assume the
2031 * symlink path that tripped us up was the last
2032 * component and try again. Eventually we will have to
2033 * deal with the returned path unprocessed component. JRA.
2034 */
2035 subreq = cli_smb2_create_fnum_send(
2036 state, /* mem_ctx, */
2037 state->ev, /* ev */
2038 state->cli, /* cli */
2039 state->name, /* fname */
2040 (struct cli_smb2_create_flags){0}, /* create_flags */
2041 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation */
2042 state->desired_access, /* desired_access */
2043 0, /* file_attributes */
2044 FILE_SHARE_READ|
2045 FILE_SHARE_WRITE|
2046 FILE_SHARE_DELETE, /* share_access */
2047 FILE_OPEN, /* create_disposition */
2048 FILE_OPEN_REPARSE_POINT, /* create_options */
2049 NULL); /* in_cblobs */
2050 if (tevent_req_nomem(subreq, req)) {
2051 return;
2052 }
2053 tevent_req_set_callback(
2054 subreq, get_fnum_from_path_opened_reparse, req);
2055 return;
2056 }
2057
2058 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
2059 subreq = cli_smb2_create_fnum_send(
2060 state, /* mem_ctx, */
2061 state->ev, /* ev */
2062 state->cli, /* cli */
2063 state->name, /* fname */
2064 (struct cli_smb2_create_flags){0}, /* create_flags */
2065 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation */
2066 state->desired_access, /* desired_access */
2067 0, /* file_attributes */
2068 FILE_SHARE_READ|
2069 FILE_SHARE_WRITE|
2070 FILE_SHARE_DELETE, /* share_access */
2071 FILE_OPEN, /* create_disposition */
2072 FILE_DIRECTORY_FILE, /* create_options */
2073 NULL); /* in_cblobs */
2074 if (tevent_req_nomem(subreq, req)) {
2075 return;
2076 }
2077 tevent_req_set_callback(
2078 subreq, get_fnum_from_path_opened_dir, req);
2079 return;
2080 }
2081
2082 if (tevent_req_nterror(req, status)) {
2083 return;
2084 }
2085 tevent_req_done(req);
2086 }
2087
2088 static void get_fnum_from_path_opened_reparse(struct tevent_req *subreq)
2089 {
2090 struct tevent_req *req = tevent_req_callback_data(
2091 subreq, struct tevent_req);
2092 struct get_fnum_from_path_state *state = tevent_req_data(
2093 req, struct get_fnum_from_path_state);
2094 NTSTATUS status = cli_smb2_create_fnum_recv(
2095 subreq, &state->fnum, NULL, NULL, NULL, NULL);
2096 tevent_req_simple_finish_ntstatus(subreq, status);
2097 }
2098
2099 static void get_fnum_from_path_opened_dir(struct tevent_req *subreq)
2100 {
2101 /* Abstraction violation, but these two are just the same... */
2102 get_fnum_from_path_opened_reparse(subreq);
2103 }
2104
2105 static NTSTATUS get_fnum_from_path_recv(
2106 struct tevent_req *req, uint16_t *pfnum)
2107 {
2108 struct get_fnum_from_path_state *state = tevent_req_data(
2109 req, struct get_fnum_from_path_state);
2110 NTSTATUS status = NT_STATUS_OK;
2111
2112 if (!tevent_req_is_nterror(req, &status)) {
2113 *pfnum = state->fnum;
2114 }
2115 tevent_req_received(req);
2116 return status;
2117 }
2118
2119 static NTSTATUS get_fnum_from_path(struct cli_state *cli,
2120 const char *name,
2121 uint32_t desired_access,
2122 uint16_t *pfnum)
2123 {
2124 TALLOC_CTX *frame = talloc_stackframe();
2125 struct tevent_context *ev = NULL;
2126 struct tevent_req *req = NULL;
2127 NTSTATUS status = NT_STATUS_NO_MEMORY;
2128
2129 if (smbXcli_conn_has_async_calls(cli->conn)) {
2130 status = NT_STATUS_INVALID_PARAMETER;
2131 goto fail;
2132 }
2133 ev = samba_tevent_context_init(frame);
2134 if (ev == NULL) {
2135 goto fail;
2136 }
2137 req = get_fnum_from_path_send(frame, ev, cli, name, desired_access);
2138 if (req == NULL) {
2139 goto fail;
2140 }
2141 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2142 goto fail;
2143 }
2144 status = get_fnum_from_path_recv(req, pfnum);
2145 fail:
2146 TALLOC_FREE(frame);
2147 return status;
2148 }
2149
2150 /***************************************************************
2151 Wrapper that allows SMB2 to query a path info (ALTNAME level).
2152 Synchronous only.
2153 ***************************************************************/
2154
2155 NTSTATUS cli_smb2_qpathinfo_alt_name(struct cli_state *cli,
2156 const char *name,
2157 fstring alt_name)
2158 {
2159 NTSTATUS status;
2160 DATA_BLOB outbuf = data_blob_null;
2161 uint16_t fnum = 0xffff;
2162 uint32_t altnamelen = 0;
2163 TALLOC_CTX *frame = talloc_stackframe();
2164
2165 if (smbXcli_conn_has_async_calls(cli->conn)) {
2166 /*
2167 * Can't use sync call while an async call is in flight
2168 */
2169 status = NT_STATUS_INVALID_PARAMETER;
2170 goto fail;
2171 }
2172
2173 status = get_fnum_from_path(cli,
2174 name,
2175 FILE_READ_ATTRIBUTES,
2176 &fnum);
2177
2178 if (!NT_STATUS_IS_OK(status)) {
2179 goto fail;
2180 }
2181
2182 status = cli_smb2_query_info_fnum(
2183 cli,
2184 fnum,
2185 1, /* in_info_type */
2186 (SMB_FILE_ALTERNATE_NAME_INFORMATION - 1000), /* in_file_info_class */
2187 0xFFFF, /* in_max_output_length */
2188 NULL, /* in_input_buffer */
2189 0, /* in_additional_info */
2190 0, /* in_flags */
2191 frame,
2192 &outbuf);
2193
2194 if (!NT_STATUS_IS_OK(status)) {
2195 goto fail;
2196 }
2197
2198 /* Parse the reply. */
2199 if (outbuf.length < 4) {
2200 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2201 goto fail;
2202 }
2203
2204 altnamelen = IVAL(outbuf.data, 0);
2205 if (altnamelen > outbuf.length - 4) {
2206 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2207 goto fail;
2208 }
2209
2210 if (altnamelen > 0) {
2211 size_t ret = 0;
2212 char *short_name = NULL;
2213 ret = pull_string_talloc(frame,
2214 outbuf.data,
2215 FLAGS2_UNICODE_STRINGS,
2216 &short_name,
2217 outbuf.data + 4,
2218 altnamelen,
2219 STR_UNICODE);
2220 if (ret == (size_t)-1) {
2221 /* Bad conversion. */
2222 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2223 goto fail;
2224 }
2225
2226 fstrcpy(alt_name, short_name);
2227 } else {
2228 alt_name[0] = '\0';
2229 }
2230
2231 status = NT_STATUS_OK;
2232
2233 fail:
2234
2235 if (fnum != 0xffff) {
2236 cli_smb2_close_fnum(cli, fnum);
2237 }
2238
2239 cli->raw_status = status;
2240
2241 TALLOC_FREE(frame);
2242 return status;
2243 }
2244
2245 /***************************************************************
2246 Wrapper that allows SMB2 to get pathname attributes.
2247 Synchronous only.
2248 ***************************************************************/
2249
2250 NTSTATUS cli_smb2_getatr(struct cli_state *cli,
2251 const char *name,
2252 uint32_t *pattr,
2253 off_t *size,
2254 time_t *write_time)
2255 {
2256 NTSTATUS status;
2257 uint16_t fnum = 0xffff;
2258 struct timespec write_time_ts;
2259 TALLOC_CTX *frame = talloc_stackframe();
2260
2261 if (smbXcli_conn_has_async_calls(cli->conn)) {
2262 /*
2263 * Can't use sync call while an async call is in flight
2264 */
2265 status = NT_STATUS_INVALID_PARAMETER;
2266 goto fail;
2267 }
2268
2269 status = get_fnum_from_path(cli,
2270 name,
2271 FILE_READ_ATTRIBUTES,
2272 &fnum);
2273
2274 if (!NT_STATUS_IS_OK(status)) {
2275 goto fail;
2276 }
2277
2278 status = cli_qfileinfo_basic(
2279 cli,
2280 fnum,
2281 pattr,
2282 size,
2283 NULL, /* create_time */
2284 NULL, /* access_time */
2285 &write_time_ts,
2286 NULL, /* change_time */
2287 NULL); /* ino */
2288 if (!NT_STATUS_IS_OK(status)) {
2289 goto fail;
2290 }
2291 if (write_time != NULL) {
2292 *write_time = write_time_ts.tv_sec;
2293 }
2294
2295 fail:
2296
2297 if (fnum != 0xffff) {
2298 cli_smb2_close_fnum(cli, fnum);
2299 }
2300
2301 cli->raw_status = status;
2302
2303 TALLOC_FREE(frame);
2304 return status;
2305 }
2306
2307 struct cli_smb2_qpathinfo2_state {
2308 struct tevent_context *ev;
2309 struct cli_state *cli;
2310 uint16_t fnum;
2311
2312 NTSTATUS queryinfo_status;
2313 struct timespec create_time;
2314 struct timespec access_time;
2315 struct timespec write_time;
2316 struct timespec change_time;
2317 off_t size;
2318 uint32_t attr;
2319 SMB_INO_T ino;
2320 };
2321
2322 static void cli_smb2_qpathinfo2_opened(struct tevent_req *subreq);
2323 static void cli_smb2_qpathinfo2_done(struct tevent_req *subreq);
2324 static void cli_smb2_qpathinfo2_closed(struct tevent_req *subreq);
2325
2326 struct tevent_req *cli_smb2_qpathinfo2_send(TALLOC_CTX *mem_ctx,
2327 struct tevent_context *ev,
2328 struct cli_state *cli,
2329 const char *fname)
2330 {
2331 struct tevent_req *req = NULL, *subreq = NULL;
2332 struct cli_smb2_qpathinfo2_state *state = NULL;
2333
2334 req = tevent_req_create(mem_ctx,
2335 &state,
2336 struct cli_smb2_qpathinfo2_state);
2337 if (req == NULL) {
2338 return NULL;
2339 }
2340 state->ev = ev;
2341 state->cli = cli;
2342
2343 subreq = get_fnum_from_path_send(mem_ctx,
2344 ev,
2345 cli,
2346 fname,
2347 FILE_READ_ATTRIBUTES);
2348 if (tevent_req_nomem(subreq, req)) {
2349 return tevent_req_post(req, ev);
2350 }
2351 tevent_req_set_callback(subreq, cli_smb2_qpathinfo2_opened, req);
2352 return req;
2353 }
2354
2355 static void cli_smb2_qpathinfo2_opened(struct tevent_req *subreq)
2356 {
2357 struct tevent_req *req =
2358 tevent_req_callback_data(subreq, struct tevent_req);
2359 struct cli_smb2_qpathinfo2_state *state =
2360 tevent_req_data(req, struct cli_smb2_qpathinfo2_state);
2361 NTSTATUS status;
2362
2363 status = get_fnum_from_path_recv(subreq, &state->fnum);
2364 TALLOC_FREE(subreq);
2365 if (tevent_req_nterror(req, status)) {
2366 return;
2367 }
2368
2369 subreq = cli_qfileinfo_basic_send(state,
2370 state->ev,
2371 state->cli,
2372 state->fnum);
2373 if (tevent_req_nomem(subreq, req)) {
2374 return;
2375 }
2376 tevent_req_set_callback(subreq, cli_smb2_qpathinfo2_done, req);
2377 }
2378
2379 static void cli_smb2_qpathinfo2_done(struct tevent_req *subreq)
2380 {
2381 struct tevent_req *req =
2382 tevent_req_callback_data(subreq, struct tevent_req);
2383 struct cli_smb2_qpathinfo2_state *state =
2384 tevent_req_data(req, struct cli_smb2_qpathinfo2_state);
2385
2386 state->queryinfo_status = cli_qfileinfo_basic_recv(subreq,
2387 &state->attr,
2388 &state->size,
2389 &state->create_time,
2390 &state->access_time,
2391 &state->write_time,
2392 &state->change_time,
2393 &state->ino);
2394 TALLOC_FREE(subreq);
2395
2396 subreq = cli_smb2_close_fnum_send(state,
2397 state->ev,
2398 state->cli,
2399 state->fnum);
2400 if (tevent_req_nomem(subreq, req)) {
2401 return;
2402 }
2403 tevent_req_set_callback(subreq, cli_smb2_qpathinfo2_closed, req);
2404 }
2405
2406 static void cli_smb2_qpathinfo2_closed(struct tevent_req *subreq)
2407 {
2408 struct tevent_req *req =
2409 tevent_req_callback_data(subreq, struct tevent_req);
2410 struct cli_smb2_qpathinfo2_state *state =
2411 tevent_req_data(req, struct cli_smb2_qpathinfo2_state);
2412 NTSTATUS status;
2413
2414 status = cli_smb2_close_fnum_recv(subreq);
2415 TALLOC_FREE(subreq);
2416 if (tevent_req_nterror(req, status)) {
2417 return;
2418 }
2419 if (tevent_req_nterror(req, state->queryinfo_status)) {
2420 return;
2421 }
2422 tevent_req_done(req);
2423 }
2424
2425 NTSTATUS cli_smb2_qpathinfo2_recv(struct tevent_req *req,
2426 struct timespec *create_time,
2427 struct timespec *access_time,
2428 struct timespec *write_time,
2429 struct timespec *change_time,
2430 off_t *size,
2431 uint32_t *attr,
2432 SMB_INO_T *ino)
2433 {
2434 struct cli_smb2_qpathinfo2_state *state =
2435 tevent_req_data(req, struct cli_smb2_qpathinfo2_state);
2436 NTSTATUS status;
2437
2438 if (tevent_req_is_nterror(req, &status)) {
2439 return status;
2440 }
2441
2442 if (create_time != NULL) {
2443 *create_time = state->create_time;
2444 }
2445 if (access_time != NULL) {
2446 *access_time = state->access_time;
2447 }
2448 if (write_time != NULL) {
2449 *write_time = state->write_time;
2450 }
2451 if (change_time != NULL) {
2452 *change_time = state->change_time;
2453 }
2454 if (attr != NULL) {
2455 *attr = state->attr;
2456 }
2457 if (size != NULL) {
2458 *size = state->size;
2459 }
2460 if (ino) {
2461 *ino = state->ino;
2462 }
2463
2464 return NT_STATUS_OK;
2465 }
2466
2467 /***************************************************************
2468 Wrapper that allows SMB2 to query pathname streams.
2469 Synchronous only.
2470 ***************************************************************/
2471
2472 NTSTATUS cli_smb2_qpathinfo_streams(struct cli_state *cli,
2473 const char *name,
2474 TALLOC_CTX *mem_ctx,
2475 unsigned int *pnum_streams,
2476 struct stream_struct **pstreams)
2477 {
2478 NTSTATUS status;
2479 uint16_t fnum = 0xffff;
2480 DATA_BLOB outbuf = data_blob_null;
2481 TALLOC_CTX *frame = talloc_stackframe();
2482
2483 if (smbXcli_conn_has_async_calls(cli->conn)) {
2484 /*
2485 * Can't use sync call while an async call is in flight
2486 */
2487 status = NT_STATUS_INVALID_PARAMETER;
2488 goto fail;
2489 }
2490
2491 status = get_fnum_from_path(cli,
2492 name,
2493 FILE_READ_ATTRIBUTES,
2494 &fnum);
2495
2496 if (!NT_STATUS_IS_OK(status)) {
2497 goto fail;
2498 }
2499
2500 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
2501 level 22 (SMB2_FILE_STREAM_INFORMATION). */
2502
2503 status = cli_smb2_query_info_fnum(
2504 cli,
2505 fnum,
2506 1, /* in_info_type */
2507 (SMB_FILE_STREAM_INFORMATION - 1000), /* in_file_info_class */
2508 0xFFFF, /* in_max_output_length */
2509 NULL, /* in_input_buffer */
2510 0, /* in_additional_info */
2511 0, /* in_flags */
2512 frame,
2513 &outbuf);
2514
2515 if (!NT_STATUS_IS_OK(status)) {
2516 goto fail;
2517 }
2518
2519 /* Parse the reply. */
2520 if (!parse_streams_blob(mem_ctx,
2521 outbuf.data,
2522 outbuf.length,
2523 pnum_streams,
2524 pstreams)) {
2525 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2526 goto fail;
2527 }
2528
2529 fail:
2530
2531 if (fnum != 0xffff) {
2532 cli_smb2_close_fnum(cli, fnum);
2533 }
2534
2535 cli->raw_status = status;
2536
2537 TALLOC_FREE(frame);
2538 return status;
2539 }
2540
2541 /***************************************************************
2542 Wrapper that allows SMB2 to set SMB_FILE_BASIC_INFORMATION on
2543 a pathname.
2544 Synchronous only.
2545 ***************************************************************/
2546
2547 NTSTATUS cli_smb2_setpathinfo(struct cli_state *cli,
2548 const char *name,
2549 uint8_t in_info_type,
2550 uint8_t in_file_info_class,
2551 const DATA_BLOB *p_in_data)
2552 {
2553 NTSTATUS status;
2554 uint16_t fnum = 0xffff;
2555 TALLOC_CTX *frame = talloc_stackframe();
2556
2557 if (smbXcli_conn_has_async_calls(cli->conn)) {
2558 /*
2559 * Can't use sync call while an async call is in flight
2560 */
2561 status = NT_STATUS_INVALID_PARAMETER;
2562 goto fail;
2563 }
2564
2565 status = get_fnum_from_path(cli,
2566 name,
2567 FILE_WRITE_ATTRIBUTES,
2568 &fnum);
2569
2570 if (!NT_STATUS_IS_OK(status)) {
2571 goto fail;
2572 }
2573
2574 status = cli_smb2_set_info_fnum(
2575 cli,
2576 fnum,
2577 in_info_type,
2578 in_file_info_class,
2579 p_in_data, /* in_input_buffer */
2580 0); /* in_additional_info */
2581 fail:
2582
2583 if (fnum != 0xffff) {
2584 cli_smb2_close_fnum(cli, fnum);
2585 }
2586
2587 cli->raw_status = status;
2588
2589 TALLOC_FREE(frame);
2590 return status;
2591 }
2592
2593
2594 /***************************************************************
2595 Wrapper that allows SMB2 to set pathname attributes.
2596 Synchronous only.
2597 ***************************************************************/
2598
2599 NTSTATUS cli_smb2_setatr(struct cli_state *cli,
2600 const char *name,
2601 uint32_t attr,
2602 time_t mtime)
2603 {
2604 uint8_t inbuf_store[40];
2605 DATA_BLOB inbuf = data_blob_null;
2606
2607 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
2608 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
2609
2610 inbuf.data = inbuf_store;
2611 inbuf.length = sizeof(inbuf_store);
2612 data_blob_clear(&inbuf);
2613
2614 /*
2615 * SMB1 uses attr == 0 to clear all attributes
2616 * on a file (end up with FILE_ATTRIBUTE_NORMAL),
2617 * and attr == FILE_ATTRIBUTE_NORMAL to mean ignore
2618 * request attribute change.
2619 *
2620 * SMB2 uses exactly the reverse. Unfortunately as the
2621 * cli_setatr() ABI is exposed inside libsmbclient,
2622 * we must make the SMB2 cli_smb2_setatr() call
2623 * export the same ABI as the SMB1 cli_setatr()
2624 * which calls it. This means reversing the sense
2625 * of the requested attr argument if it's zero
2626 * or FILE_ATTRIBUTE_NORMAL.
2627 *
2628 * See BUG: https://bugzilla.samba.org/show_bug.cgi?id=12899
2629 */
2630
2631 if (attr == 0) {
2632 attr = FILE_ATTRIBUTE_NORMAL;
2633 } else if (attr == FILE_ATTRIBUTE_NORMAL) {
2634 attr = 0;
2635 }
2636
2637 SIVAL(inbuf.data, 32, attr);
2638 if (mtime != 0) {
2639 put_long_date((char *)inbuf.data + 16,mtime);
2640 }
2641 /* Set all the other times to -1. */
2642 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
2643 SBVAL(inbuf.data, 8, 0xFFFFFFFFFFFFFFFFLL);
2644 SBVAL(inbuf.data, 24, 0xFFFFFFFFFFFFFFFFLL);
2645
2646 return cli_smb2_setpathinfo(cli,
2647 name,
2648 1, /* in_info_type */
2649 /* in_file_info_class */
2650 SMB_FILE_BASIC_INFORMATION - 1000,
2651 &inbuf);
2652 }
2653
2654
2655 /***************************************************************
2656 Wrapper that allows SMB2 to set file handle times.
2657 Synchronous only.
2658 ***************************************************************/
2659
2660 NTSTATUS cli_smb2_setattrE(struct cli_state *cli,
2661 uint16_t fnum,
2662 time_t change_time,
2663 time_t access_time,
2664 time_t write_time)
2665 {
2666 uint8_t inbuf_store[40];
2667 DATA_BLOB inbuf = data_blob_null;
2668
2669 if (smbXcli_conn_has_async_calls(cli->conn)) {
2670 /*
2671 * Can't use sync call while an async call is in flight
2672 */
2673 return NT_STATUS_INVALID_PARAMETER;
2674 }
2675
2676 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
2677 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
2678
2679 inbuf.data = inbuf_store;
2680 inbuf.length = sizeof(inbuf_store);
2681 data_blob_clear(&inbuf);
2682
2683 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
2684 if (change_time != 0) {
2685 put_long_date((char *)inbuf.data + 24, change_time);
2686 }
2687 if (access_time != 0) {
2688 put_long_date((char *)inbuf.data + 8, access_time);
2689 }
2690 if (write_time != 0) {
2691 put_long_date((char *)inbuf.data + 16, write_time);
2692 }
2693
2694 cli->raw_status = cli_smb2_set_info_fnum(
2695 cli,
2696 fnum,
2697 1, /* in_info_type */
2698 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
2699 &inbuf, /* in_input_buffer */
2700 0); /* in_additional_info */
2701
2702 return cli->raw_status;
2703 }
2704
2705 /***************************************************************
2706 Wrapper that allows SMB2 to query disk attributes (size).
2707 Synchronous only.
2708 ***************************************************************/
2709
2710 NTSTATUS cli_smb2_dskattr(struct cli_state *cli, const char *path,
2711 uint64_t *bsize, uint64_t *total, uint64_t *avail)
2712 {
2713 NTSTATUS status;
2714 uint16_t fnum = 0xffff;
2715 DATA_BLOB outbuf = data_blob_null;
2716 uint32_t sectors_per_unit = 0;
2717 uint32_t bytes_per_sector = 0;
2718 uint64_t total_size = 0;
2719 uint64_t size_free = 0;
2720 TALLOC_CTX *frame = talloc_stackframe();
2721
2722 if (smbXcli_conn_has_async_calls(cli->conn)) {
2723 /*
2724 * Can't use sync call while an async call is in flight
2725 */
2726 status = NT_STATUS_INVALID_PARAMETER;
2727 goto fail;
2728 }
2729
2730 /* First open the top level directory. */
2731 status = cli_smb2_create_fnum(cli,
2732 path,
2733 (struct cli_smb2_create_flags){0},
2734 SMB2_IMPERSONATION_IMPERSONATION,
2735 FILE_READ_ATTRIBUTES, /* desired_access */
2736 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2737 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
2738 FILE_OPEN, /* create_disposition */
2739 FILE_DIRECTORY_FILE, /* create_options */
2740 NULL,
2741 &fnum,
2742 NULL,
2743 NULL,
2744 NULL);
2745
2746 if (!NT_STATUS_IS_OK(status)) {
2747 goto fail;
2748 }
2749
2750 /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
2751 level 3 (SMB_FS_SIZE_INFORMATION). */
2752
2753 status = cli_smb2_query_info_fnum(
2754 cli,
2755 fnum,
2756 2, /* in_info_type */
2757 3, /* in_file_info_class */
2758 0xFFFF, /* in_max_output_length */
2759 NULL, /* in_input_buffer */
2760 0, /* in_additional_info */
2761 0, /* in_flags */
2762 frame,
2763 &outbuf);
2764 if (!NT_STATUS_IS_OK(status)) {
2765 goto fail;
2766 }
2767
2768 /* Parse the reply. */
2769 if (outbuf.length != 24) {
2770 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2771 goto fail;
2772 }
2773
2774 total_size = BVAL(outbuf.data, 0);
2775 size_free = BVAL(outbuf.data, 8);
2776 sectors_per_unit = IVAL(outbuf.data, 16);
2777 bytes_per_sector = IVAL(outbuf.data, 20);
2778
2779 if (bsize) {
2780 *bsize = (uint64_t)sectors_per_unit * (uint64_t)bytes_per_sector;
2781 }
2782 if (total) {
2783 *total = total_size;
2784 }
2785 if (avail) {
2786 *avail = size_free;
2787 }
2788
2789 status = NT_STATUS_OK;
2790
2791 fail:
2792
2793 if (fnum != 0xffff) {
2794 cli_smb2_close_fnum(cli, fnum);
2795 }
2796
2797 cli->raw_status = status;
2798
2799 TALLOC_FREE(frame);
2800 return status;
2801 }
2802
2803 /***************************************************************
2804 Wrapper that allows SMB2 to query file system sizes.
2805 Synchronous only.
2806 ***************************************************************/
2807
2808 NTSTATUS cli_smb2_get_fs_full_size_info(struct cli_state *cli,
2809 uint64_t *total_allocation_units,
2810 uint64_t *caller_allocation_units,
2811 uint64_t *actual_allocation_units,
2812 uint64_t *sectors_per_allocation_unit,
2813 uint64_t *bytes_per_sector)
2814 {
2815 NTSTATUS status;
2816 uint16_t fnum = 0xffff;
2817 DATA_BLOB outbuf = data_blob_null;
2818 TALLOC_CTX *frame = talloc_stackframe();
2819
2820 if (smbXcli_conn_has_async_calls(cli->conn)) {
2821 /*
2822 * Can't use sync call while an async call is in flight
2823 */
2824 status = NT_STATUS_INVALID_PARAMETER;
2825 goto fail;
2826 }
2827
2828 /* First open the top level directory. */
2829 status =
2830 cli_smb2_create_fnum(cli, "",
2831 (struct cli_smb2_create_flags){0},
2832 SMB2_IMPERSONATION_IMPERSONATION,
2833 FILE_READ_ATTRIBUTES, /* desired_access */
2834 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2835 FILE_SHARE_READ | FILE_SHARE_WRITE |
2836 FILE_SHARE_DELETE, /* share_access */
2837 FILE_OPEN, /* create_disposition */
2838 FILE_DIRECTORY_FILE, /* create_options */
2839 NULL,
2840 &fnum,
2841 NULL,
2842 NULL,
2843 NULL);
2844
2845 if (!NT_STATUS_IS_OK(status)) {
2846 goto fail;
2847 }
2848
2849 /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
2850 level 7 (SMB_FS_FULL_SIZE_INFORMATION). */
2851
2852 status = cli_smb2_query_info_fnum(
2853 cli,
2854 fnum,
2855 SMB2_0_INFO_FILESYSTEM, /* in_info_type */
2856 SMB_FS_FULL_SIZE_INFORMATION - 1000, /* in_file_info_class */
2857 0xFFFF, /* in_max_output_length */
2858 NULL, /* in_input_buffer */
2859 0, /* in_additional_info */
2860 0, /* in_flags */
2861 frame,
2862 &outbuf);
2863 if (!NT_STATUS_IS_OK(status)) {
2864 goto fail;
2865 }
2866
2867 if (outbuf.length < 32) {
2868 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2869 goto fail;
2870 }
2871
2872 *total_allocation_units = BIG_UINT(outbuf.data, 0);
2873 *caller_allocation_units = BIG_UINT(outbuf.data, 8);
2874 *actual_allocation_units = BIG_UINT(outbuf.data, 16);
2875 *sectors_per_allocation_unit = (uint64_t)IVAL(outbuf.data, 24);
2876 *bytes_per_sector = (uint64_t)IVAL(outbuf.data, 28);
2877
2878 fail:
2879
2880 if (fnum != 0xffff) {
2881 cli_smb2_close_fnum(cli, fnum);
2882 }
2883
2884 cli->raw_status = status;
2885
2886 TALLOC_FREE(frame);
2887 return status;
2888 }
2889
2890 /***************************************************************
2891 Wrapper that allows SMB2 to query file system attributes.
2892 Synchronous only.
2893 ***************************************************************/
2894
2895 NTSTATUS cli_smb2_get_fs_attr_info(struct cli_state *cli, uint32_t *fs_attr)
2896 {
2897 NTSTATUS status;
2898 uint16_t fnum = 0xffff;
2899 DATA_BLOB outbuf = data_blob_null;
2900 TALLOC_CTX *frame = talloc_stackframe();
2901
2902 if (smbXcli_conn_has_async_calls(cli->conn)) {
2903 /*
2904 * Can't use sync call while an async call is in flight
2905 */
2906 status = NT_STATUS_INVALID_PARAMETER;
2907 goto fail;
2908 }
2909
2910 /* First open the top level directory. */
2911 status =
2912 cli_smb2_create_fnum(cli, "",
2913 (struct cli_smb2_create_flags){0},
2914 SMB2_IMPERSONATION_IMPERSONATION,
2915 FILE_READ_ATTRIBUTES, /* desired_access */
2916 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2917 FILE_SHARE_READ | FILE_SHARE_WRITE |
2918 FILE_SHARE_DELETE, /* share_access */
2919 FILE_OPEN, /* create_disposition */
2920 FILE_DIRECTORY_FILE, /* create_options */
2921 NULL,
2922 &fnum,
2923 NULL,
2924 NULL,
2925 NULL);
2926
2927 if (!NT_STATUS_IS_OK(status)) {
2928 goto fail;
2929 }
2930
2931 status = cli_smb2_query_info_fnum(
2932 cli,
2933 fnum,
2934 2, /* in_info_type */
2935 5, /* in_file_info_class */
2936 0xFFFF, /* in_max_output_length */
2937 NULL, /* in_input_buffer */
2938 0, /* in_additional_info */
2939 0, /* in_flags */
2940 frame,
2941 &outbuf);
2942 if (!NT_STATUS_IS_OK(status)) {
2943 goto fail;
2944 }
2945
2946 if (outbuf.length < 12) {
2947 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2948 goto fail;
2949 }
2950
2951 *fs_attr = IVAL(outbuf.data, 0);
2952
2953 fail:
2954
2955 if (fnum != 0xffff) {
2956 cli_smb2_close_fnum(cli, fnum);
2957 }
2958
2959 cli->raw_status = status;
2960
2961 TALLOC_FREE(frame);
2962 return status;
2963 }
2964
2965 /***************************************************************
2966 Wrapper that allows SMB2 to query file system volume info.
2967 Synchronous only.
2968 ***************************************************************/
2969
2970 NTSTATUS cli_smb2_get_fs_volume_info(struct cli_state *cli,
2971 TALLOC_CTX *mem_ctx,
2972 char **_volume_name,
2973 uint32_t *pserial_number,
2974 time_t *pdate)
2975 {
2976 NTSTATUS status;
2977 uint16_t fnum = 0xffff;
2978 DATA_BLOB outbuf = data_blob_null;
2979 uint32_t nlen;
2980 char *volume_name = NULL;
2981 TALLOC_CTX *frame = talloc_stackframe();
2982
2983 if (smbXcli_conn_has_async_calls(cli->conn)) {
2984 /*
2985 * Can't use sync call while an async call is in flight
2986 */
2987 status = NT_STATUS_INVALID_PARAMETER;
2988 goto fail;
2989 }
2990
2991 /* First open the top level directory. */
2992 status =
2993 cli_smb2_create_fnum(cli, "",
2994 (struct cli_smb2_create_flags){0},
2995 SMB2_IMPERSONATION_IMPERSONATION,
2996 FILE_READ_ATTRIBUTES, /* desired_access */
2997 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2998 FILE_SHARE_READ | FILE_SHARE_WRITE |
2999 FILE_SHARE_DELETE, /* share_access */
3000 FILE_OPEN, /* create_disposition */
3001 FILE_DIRECTORY_FILE, /* create_options */
3002 NULL,
3003 &fnum,
3004 NULL,
3005 NULL,
3006 NULL);
3007
3008 if (!NT_STATUS_IS_OK(status)) {
3009 goto fail;
3010 }
3011
3012 /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
3013 level 1 (SMB_FS_VOLUME_INFORMATION). */
3014
3015 status = cli_smb2_query_info_fnum(
3016 cli,
3017 fnum,
3018 SMB2_0_INFO_FILESYSTEM, /* in_info_type */
3019 /* in_file_info_class */
3020 SMB_FS_VOLUME_INFORMATION - 1000,
3021 0xFFFF, /* in_max_output_length */
3022 NULL, /* in_input_buffer */
3023 0, /* in_additional_info */
3024 0, /* in_flags */
3025 frame,
3026 &outbuf);
3027 if (!NT_STATUS_IS_OK(status)) {
3028 goto fail;
3029 }
3030
3031 if (outbuf.length < 24) {
3032 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3033 goto fail;
3034 }
3035
3036 if (pdate) {
3037 struct timespec ts;
3038 ts = interpret_long_date((char *)outbuf.data);
3039 *pdate = ts.tv_sec;
3040 }
3041 if (pserial_number) {
3042 *pserial_number = IVAL(outbuf.data,8);
3043 }
3044 nlen = IVAL(outbuf.data,12);
3045 if (nlen + 18 < 18) {
3046 /* Integer wrap. */
3047 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3048 goto fail;
3049 }
3050 /*
3051 * The next check is safe as we know outbuf.length >= 24
3052 * from above.
3053 */
3054 if (nlen > (outbuf.length - 18)) {
3055 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3056 goto fail;
3057 }
3058
3059 pull_string_talloc(mem_ctx,
3060 (const char *)outbuf.data,
3061 0,
3062 &volume_name,
3063 outbuf.data + 18,
3064 nlen,
3065 STR_UNICODE);
3066 if (volume_name == NULL) {
3067 status = map_nt_error_from_unix(errno);
3068 goto fail;
3069 }
3070
3071 *_volume_name = volume_name;
3072
3073 fail:
3074
3075 if (fnum != 0xffff) {
3076 cli_smb2_close_fnum(cli, fnum);
3077 }
3078
3079 cli->raw_status = status;
3080
3081 TALLOC_FREE(frame);
3082 return status;
3083 }
3084
3085 struct cli_smb2_mxac_state {
3086 struct tevent_context *ev;
3087 struct cli_state *cli;
3088 const char *fname;
3089 struct smb2_create_blobs in_cblobs;
3090 uint16_t fnum;
3091 NTSTATUS status;
3092 uint32_t mxac;
3093 };
3094
3095 static void cli_smb2_mxac_opened(struct tevent_req *subreq);
3096 static void cli_smb2_mxac_closed(struct tevent_req *subreq);
3097
3098 struct tevent_req *cli_smb2_query_mxac_send(TALLOC_CTX *mem_ctx,
3099 struct tevent_context *ev,
3100 struct cli_state *cli,
3101 const char *fname)
3102 {
3103 struct tevent_req *req = NULL, *subreq = NULL;
3104 struct cli_smb2_mxac_state *state = NULL;
3105 NTSTATUS status;
3106
3107 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_mxac_state);
3108 if (req == NULL) {
3109 return NULL;
3110 }
3111 *state = (struct cli_smb2_mxac_state) {
3112 .ev = ev,
3113 .cli = cli,
3114 .fname = fname,
3115 };
3116
3117 status = smb2_create_blob_add(state,
3118 &state->in_cblobs,
3119 SMB2_CREATE_TAG_MXAC,
3120 data_blob(NULL, 0));
3121 if (tevent_req_nterror(req, status)) {
3122 return tevent_req_post(req, ev);
3123 }
3124
3125 subreq = cli_smb2_create_fnum_send(
3126 state,
3127 state->ev,
3128 state->cli,
3129 state->fname,
3130 (struct cli_smb2_create_flags){0},
3131 SMB2_IMPERSONATION_IMPERSONATION,
3132 FILE_READ_ATTRIBUTES,
3133 0, /* file attributes */
3134 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3135 FILE_OPEN,
3136 0, /* create_options */
3137 &state->in_cblobs);
3138 if (tevent_req_nomem(subreq, req)) {
3139 return tevent_req_post(req, ev);
3140 }
3141 tevent_req_set_callback(subreq, cli_smb2_mxac_opened, req);
3142 return req;
3143 }
3144
3145 static void cli_smb2_mxac_opened(struct tevent_req *subreq)
3146 {
3147 struct tevent_req *req = tevent_req_callback_data(
3148 subreq, struct tevent_req);
3149 struct cli_smb2_mxac_state *state = tevent_req_data(
3150 req, struct cli_smb2_mxac_state);
3151 struct smb2_create_blobs out_cblobs = {0};
3152 struct smb2_create_blob *mxac_blob = NULL;
3153 NTSTATUS status;
3154
3155 status = cli_smb2_create_fnum_recv(
3156 subreq, &state->fnum, NULL, state, &out_cblobs, NULL);
3157 TALLOC_FREE(subreq);
3158
3159 if (tevent_req_nterror(req, status)) {
3160 return;
3161 }
3162
3163 mxac_blob = smb2_create_blob_find(&out_cblobs, SMB2_CREATE_TAG_MXAC);
3164 if (mxac_blob == NULL) {
3165 state->status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3166 goto close;
3167 }
3168 if (mxac_blob->data.length != 8) {
3169 state->status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3170 goto close;
3171 }
3172
3173 state->status = NT_STATUS(IVAL(mxac_blob->data.data, 0));
3174 state->mxac = IVAL(mxac_blob->data.data, 4);
3175
3176 close:
3177 subreq = cli_smb2_close_fnum_send(
3178 state, state->ev, state->cli, state->fnum);
3179 if (tevent_req_nomem(subreq, req)) {
3180 return;
3181 }
3182 tevent_req_set_callback(subreq, cli_smb2_mxac_closed, req);
3183
3184 return;
3185 }
3186
3187 static void cli_smb2_mxac_closed(struct tevent_req *subreq)
3188 {
3189 struct tevent_req *req = tevent_req_callback_data(
3190 subreq, struct tevent_req);
3191 NTSTATUS status;
3192
3193 status = cli_smb2_close_fnum_recv(subreq);
3194 if (tevent_req_nterror(req, status)) {
3195 return;
3196 }
3197
3198 tevent_req_done(req);
3199 }
3200
3201 NTSTATUS cli_smb2_query_mxac_recv(struct tevent_req *req, uint32_t *mxac)
3202 {
3203 struct cli_smb2_mxac_state *state = tevent_req_data(
3204 req, struct cli_smb2_mxac_state);
3205 NTSTATUS status;
3206
3207 if (tevent_req_is_nterror(req, &status)) {
3208 return status;
3209 }
3210
3211 if (!NT_STATUS_IS_OK(state->status)) {
3212 return state->status;
3213 }
3214
3215 *mxac = state->mxac;
3216 return NT_STATUS_OK;
3217 }
3218
3219 NTSTATUS cli_smb2_query_mxac(struct cli_state *cli,
3220 const char *fname,
3221 uint32_t *_mxac)
3222 {
3223 TALLOC_CTX *frame = talloc_stackframe();
3224 struct tevent_context *ev = NULL;
3225 struct tevent_req *req = NULL;
3226 NTSTATUS status = NT_STATUS_INTERNAL_ERROR;
3227 bool ok;
3228
3229 if (smbXcli_conn_has_async_calls(cli->conn)) {
3230 /*
3231 * Can't use sync call while an async call is in flight
3232 */
3233 status = NT_STATUS_INVALID_PARAMETER;
3234 goto fail;
3235 }
3236
3237 ev = samba_tevent_context_init(frame);
3238 if (ev == NULL) {
3239 goto fail;
3240 }
3241 req = cli_smb2_query_mxac_send(frame, ev, cli, fname);
3242 if (req == NULL) {
3243 goto fail;
3244 }
3245 ok = tevent_req_poll_ntstatus(req, ev, &status);
3246 if (!ok) {
3247 goto fail;
3248 }
3249 status = cli_smb2_query_mxac_recv(req, _mxac);
3250
3251 fail:
3252 cli->raw_status = status;
3253 TALLOC_FREE(frame);
3254 return status;
3255 }
3256
3257 struct cli_smb2_rename_fnum_state {
3258 DATA_BLOB inbuf;
3259 };
3260
3261 static void cli_smb2_rename_fnum_done(struct tevent_req *subreq);
3262
3263 static struct tevent_req *cli_smb2_rename_fnum_send(
3264 TALLOC_CTX *mem_ctx,
3265 struct tevent_context *ev,
3266 struct cli_state *cli,
3267 uint16_t fnum,
3268 const char *fname_dst,
3269 bool replace)
3270 {
3271 struct tevent_req *req = NULL, *subreq = NULL;
3272 struct cli_smb2_rename_fnum_state *state = NULL;
3273 size_t namelen = strlen(fname_dst);
3274 smb_ucs2_t *converted_str = NULL;
3275 size_t converted_size_bytes = 0;
3276 size_t inbuf_size;
3277 bool ok;
3278
3279 req = tevent_req_create(
3280 mem_ctx, &state, struct cli_smb2_rename_fnum_state);
3281 if (req == NULL) {
3282 return NULL;
3283 }
3284
3285 /*
3286 * SMB2 is pickier about pathnames. Ensure it doesn't start in
3287 * a '\'
3288 */
3289 if (*fname_dst == '\\') {
3290 fname_dst++;
3291 }
3292
3293 /*
3294 * SMB2 is pickier about pathnames. Ensure it doesn't end in a
3295 * '\'
3296 */
3297 if (namelen > 0 && fname_dst[namelen-1] == '\\') {
3298 fname_dst = talloc_strndup(state, fname_dst, namelen-1);
3299 if (tevent_req_nomem(fname_dst, req)) {
3300 return tevent_req_post(req, ev);
3301 }
3302 }
3303
3304 ok = push_ucs2_talloc(
3305 state, &converted_str, fname_dst, &converted_size_bytes);
3306 if (!ok) {
3307 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
3308 return tevent_req_post(req, ev);
3309 }
3310
3311 /*
3312 * W2K8 insists the dest name is not null terminated. Remove
3313 * the last 2 zero bytes and reduce the name length.
3314 */
3315 if (converted_size_bytes < 2) {
3316 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
3317 return tevent_req_post(req, ev);
3318 }
3319 converted_size_bytes -= 2;
3320
3321 inbuf_size = 20 + converted_size_bytes;
3322 if (inbuf_size < 20) {
3323 /* Integer wrap check. */
3324 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
3325 return tevent_req_post(req, ev);
3326 }
3327
3328 /*
3329 * The Windows 10 SMB2 server has a minimum length
3330 * for a SMB2_FILE_RENAME_INFORMATION buffer of
3331 * 24 bytes. It returns NT_STATUS_INFO_LENGTH_MISMATCH
3332 * if the length is less. This isn't an alignment
3333 * issue as Windows client happily 2-byte align
3334 * for larget target name sizes. Also the Windows 10
3335 * SMB1 server doesn't have this restriction.
3336 *
3337 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=14403
3338 */
3339 inbuf_size = MAX(inbuf_size, 24);
3340
3341 state->inbuf = data_blob_talloc_zero(state, inbuf_size);
3342 if (tevent_req_nomem(state->inbuf.data, req)) {
3343 return tevent_req_post(req, ev);
3344 }
3345
3346 if (replace) {
3347 SCVAL(state->inbuf.data, 0, 1);
3348 }
3349
3350 SIVAL(state->inbuf.data, 16, converted_size_bytes);
3351 memcpy(state->inbuf.data + 20, converted_str, converted_size_bytes);
3352
3353 TALLOC_FREE(converted_str);
3354
3355 /* setinfo on the returned handle with info_type SMB2_GETINFO_FILE (1),
3356 level SMB2_FILE_RENAME_INFORMATION (SMB_FILE_RENAME_INFORMATION - 1000) */
3357
3358 subreq = cli_smb2_set_info_fnum_send(
3359 state, /* mem_ctx */
3360 ev, /* ev */
3361 cli, /* cli */
3362 fnum, /* fnum */
3363 1, /* in_info_type */
3364 SMB_FILE_RENAME_INFORMATION - 1000, /* in_file_info_class */
3365 &state->inbuf, /* in_input_buffer */
3366 0); /* in_additional_info */
3367 if (tevent_req_nomem(subreq, req)) {
3368 return tevent_req_post(req, ev);
3369 }
3370 tevent_req_set_callback(subreq, cli_smb2_rename_fnum_done, req);
3371 return req;
3372 }
3373
3374 static void cli_smb2_rename_fnum_done(struct tevent_req *subreq)
3375 {
3376 NTSTATUS status = cli_smb2_set_info_fnum_recv(subreq);
3377 tevent_req_simple_finish_ntstatus(subreq, status);
3378 }
3379
3380 static NTSTATUS cli_smb2_rename_fnum_recv(struct tevent_req *req)
3381 {
3382 return tevent_req_simple_recv_ntstatus(req);
3383 }
3384
3385 /***************************************************************
3386 Wrapper that allows SMB2 to rename a file.
3387 ***************************************************************/
3388
3389 struct cli_smb2_rename_state {
3390 struct tevent_context *ev;
3391 struct cli_state *cli;
3392 const char *fname_dst;
3393 bool replace;
3394 uint16_t fnum;
3395
3396 NTSTATUS rename_status;
3397 };
3398
3399 static void cli_smb2_rename_opened(struct tevent_req *subreq);
3400 static void cli_smb2_rename_renamed(struct tevent_req *subreq);
3401 static void cli_smb2_rename_closed(struct tevent_req *subreq);
3402
3403 struct tevent_req *cli_smb2_rename_send(
3404 TALLOC_CTX *mem_ctx,
3405 struct tevent_context *ev,
3406 struct cli_state *cli,
3407 const char *fname_src,
3408 const char *fname_dst,
3409 bool replace)
3410 {
3411 struct tevent_req *req = NULL, *subreq = NULL;
3412 struct cli_smb2_rename_state *state = NULL;
3413 NTSTATUS status;
3414
3415 req = tevent_req_create(
3416 mem_ctx, &state, struct cli_smb2_rename_state);
3417 if (req == NULL) {
3418 return NULL;
3419 }
3420
3421 /*
3422 * Strip a MSDFS path from fname_dst if we were given one.
3423 */
3424 status = cli_dfs_target_check(state,
3425 cli,
3426 fname_dst,
3427 &fname_dst);
3428 if (tevent_req_nterror(req, status)) {
3429 return tevent_req_post(req, ev);
3430 }
3431
3432 state->ev = ev;
3433 state->cli = cli;
3434 state->fname_dst = fname_dst;
3435 state->replace = replace;
3436
3437 subreq = get_fnum_from_path_send(
3438 state, ev, cli, fname_src, DELETE_ACCESS);
3439 if (tevent_req_nomem(subreq, req)) {
3440 return tevent_req_post(req, ev);
3441 }
3442 tevent_req_set_callback(subreq, cli_smb2_rename_opened, req);
3443 return req;
3444 }
3445
3446 static void cli_smb2_rename_opened(struct tevent_req *subreq)
3447 {
3448 struct tevent_req *req = tevent_req_callback_data(
3449 subreq, struct tevent_req);
3450 struct cli_smb2_rename_state *state = tevent_req_data(
3451 req, struct cli_smb2_rename_state);
3452 NTSTATUS status;
3453
3454 status = get_fnum_from_path_recv(subreq, &state->fnum);
3455 TALLOC_FREE(subreq);
3456 if (tevent_req_nterror(req, status)) {
3457 return;
3458 }
3459
3460 subreq = cli_smb2_rename_fnum_send(
3461 state,
3462 state->ev,
3463 state->cli,
3464 state->fnum,
3465 state->fname_dst,
3466 state->replace);
3467 if (tevent_req_nomem(subreq, req)) {
3468 return;
3469 }
3470 tevent_req_set_callback(subreq, cli_smb2_rename_renamed, req);
3471 }
3472
3473 static void cli_smb2_rename_renamed(struct tevent_req *subreq)
3474 {
3475 struct tevent_req *req = tevent_req_callback_data(
3476 subreq, struct tevent_req);
3477 struct cli_smb2_rename_state *state = tevent_req_data(
3478 req, struct cli_smb2_rename_state);
3479
3480 state->rename_status = cli_smb2_rename_fnum_recv(subreq);
3481 TALLOC_FREE(subreq);
3482
3483 subreq = cli_smb2_close_fnum_send(
3484 state, state->ev, state->cli, state->fnum);
3485 if (tevent_req_nomem(subreq, req)) {
3486 return;
3487 }
3488 tevent_req_set_callback(subreq, cli_smb2_rename_closed, req);
3489 }
3490
3491 static void cli_smb2_rename_closed(struct tevent_req *subreq)
3492 {
3493 NTSTATUS status = cli_smb2_close_fnum_recv(subreq);
3494 tevent_req_simple_finish_ntstatus(subreq, status);
3495 }
3496
3497 NTSTATUS cli_smb2_rename_recv(struct tevent_req *req)
3498 {
3499 struct cli_smb2_rename_state *state = tevent_req_data(
3500 req, struct cli_smb2_rename_state);
3501 NTSTATUS status = NT_STATUS_OK;
3502
3503 if (!tevent_req_is_nterror(req, &status)) {
3504 status = state->rename_status;
3505 }
3506 tevent_req_received(req);
3507 return status;
3508 }
3509
3510 /***************************************************************
3511 Wrapper that allows SMB2 to set an EA on a fnum.
3512 Synchronous only.
3513 ***************************************************************/
3514
3515 NTSTATUS cli_smb2_set_ea_fnum(struct cli_state *cli,
3516 uint16_t fnum,
3517 const char *ea_name,
3518 const char *ea_val,
3519 size_t ea_len)
3520 {
3521 NTSTATUS status;
3522 DATA_BLOB inbuf = data_blob_null;
3523 size_t bloblen = 0;
3524 char *ea_name_ascii = NULL;
3525 size_t namelen = 0;
3526 TALLOC_CTX *frame = talloc_stackframe();
3527
3528 if (smbXcli_conn_has_async_calls(cli->conn)) {
3529 /*
3530 * Can't use sync call while an async call is in flight
3531 */
3532 status = NT_STATUS_INVALID_PARAMETER;
3533 goto fail;
3534 }
3535
3536 /* Marshall the SMB2 EA data. */
3537 if (ea_len > 0xFFFF) {
3538 status = NT_STATUS_INVALID_PARAMETER;
3539 goto fail;
3540 }
3541
3542 if (!push_ascii_talloc(frame,
3543 &ea_name_ascii,
3544 ea_name,
3545 &namelen)) {
3546 status = NT_STATUS_INVALID_PARAMETER;
3547 goto fail;
3548 }
3549
3550 if (namelen < 2 || namelen > 0xFF) {
3551 status = NT_STATUS_INVALID_PARAMETER;
3552 goto fail;
3553 }
3554
3555 bloblen = 8 + ea_len + namelen;
3556 /* Round up to a 4 byte boundary. */
3557 bloblen = ((bloblen + 3)&~3);
3558
3559 inbuf = data_blob_talloc_zero(frame, bloblen);
3560 if (inbuf.data == NULL) {
3561 status = NT_STATUS_NO_MEMORY;
3562 goto fail;
3563 }
3564 /* namelen doesn't include the NULL byte. */
3565 SCVAL(inbuf.data, 5, namelen - 1);
3566 SSVAL(inbuf.data, 6, ea_len);
3567 memcpy(inbuf.data + 8, ea_name_ascii, namelen);
3568 memcpy(inbuf.data + 8 + namelen, ea_val, ea_len);
3569
3570 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
3571 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
3572
3573 status = cli_smb2_set_info_fnum(
3574 cli,
3575 fnum,
3576 1, /* in_info_type */
3577 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
3578 &inbuf, /* in_input_buffer */
3579 0); /* in_additional_info */
3580
3581 fail:
3582
3583 cli->raw_status = status;
3584
3585 TALLOC_FREE(frame);
3586 return status;
3587 }
3588
3589 /***************************************************************
3590 Wrapper that allows SMB2 to set an EA on a pathname.
3591 Synchronous only.
3592 ***************************************************************/
3593
3594 NTSTATUS cli_smb2_set_ea_path(struct cli_state *cli,
3595 const char *name,
3596 const char *ea_name,
3597 const char *ea_val,
3598 size_t ea_len)
3599 {
3600 NTSTATUS status;
3601 uint16_t fnum = 0xffff;
3602
3603 if (smbXcli_conn_has_async_calls(cli->conn)) {
3604 /*
3605 * Can't use sync call while an async call is in flight
3606 */
3607 status = NT_STATUS_INVALID_PARAMETER;
3608 goto fail;
3609 }
3610
3611 status = get_fnum_from_path(cli,
3612 name,
3613 FILE_WRITE_EA,
3614 &fnum);
3615
3616 if (!NT_STATUS_IS_OK(status)) {
3617 goto fail;
3618 }
3619
3620 status = cli_set_ea_fnum(cli,
3621 fnum,
3622 ea_name,
3623 ea_val,
3624 ea_len);
3625 if (!NT_STATUS_IS_OK(status)) {
3626 goto fail;
3627 }
3628
3629 fail:
3630
3631 if (fnum != 0xffff) {
3632 cli_smb2_close_fnum(cli, fnum);
3633 }
3634
3635 cli->raw_status = status;
3636
3637 return status;
3638 }
3639
3640 /***************************************************************
3641 Wrapper that allows SMB2 to get an EA list on a pathname.
3642 Synchronous only.
3643 ***************************************************************/
3644
3645 NTSTATUS cli_smb2_get_ea_list_path(struct cli_state *cli,
3646 const char *name,
3647 TALLOC_CTX *ctx,
3648 size_t *pnum_eas,
3649 struct ea_struct **pea_array)
3650 {
3651 NTSTATUS status;
3652 uint16_t fnum = 0xffff;
3653 DATA_BLOB outbuf = data_blob_null;
3654 struct ea_list *ea_list = NULL;
3655 struct ea_list *eal = NULL;
3656 size_t ea_count = 0;
3657 TALLOC_CTX *frame = talloc_stackframe();
3658
3659 *pnum_eas = 0;
3660 *pea_array = NULL;
3661
3662 if (smbXcli_conn_has_async_calls(cli->conn)) {
3663 /*
3664 * Can't use sync call while an async call is in flight
3665 */
3666 status = NT_STATUS_INVALID_PARAMETER;
3667 goto fail;
3668 }
3669
3670 status = get_fnum_from_path(cli,
3671 name,
3672 FILE_READ_EA,
3673 &fnum);
3674
3675 if (!NT_STATUS_IS_OK(status)) {
3676 goto fail;
3677 }
3678
3679 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
3680 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
3681
3682 status = cli_smb2_query_info_fnum(
3683 cli,
3684 fnum,
3685 1, /* in_info_type */
3686 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
3687 0xFFFF, /* in_max_output_length */
3688 NULL, /* in_input_buffer */
3689 0, /* in_additional_info */
3690 0, /* in_flags */
3691 frame,
3692 &outbuf);
3693
3694 if (!NT_STATUS_IS_OK(status)) {
3695 goto fail;
3696 }
3697
3698 /* Parse the reply. */
3699 ea_list = read_nttrans_ea_list(ctx,
3700 (const char *)outbuf.data,
3701 outbuf.length);
3702 if (ea_list == NULL) {
3703 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3704 goto fail;
3705 }
3706
3707 /* Convert to an array. */
3708 for (eal = ea_list; eal; eal = eal->next) {
3709 ea_count++;
3710 }
3711
3712 if (ea_count) {
3713 *pea_array = talloc_array(ctx, struct ea_struct, ea_count);
3714 if (*pea_array == NULL) {
3715 status = NT_STATUS_NO_MEMORY;
3716 goto fail;
3717 }
3718 ea_count = 0;
3719 for (eal = ea_list; eal; eal = eal->next) {
3720 (*pea_array)[ea_count++] = eal->ea;
3721 }
3722 *pnum_eas = ea_count;
3723 }
3724
3725 fail:
3726
3727 if (fnum != 0xffff) {
3728 cli_smb2_close_fnum(cli, fnum);
3729 }
3730
3731 cli->raw_status = status;
3732
3733 TALLOC_FREE(frame);
3734 return status;
3735 }
3736
3737 /***************************************************************
3738 Wrapper that allows SMB2 to get user quota.
3739 Synchronous only.
3740 ***************************************************************/
3741
3742 NTSTATUS cli_smb2_get_user_quota(struct cli_state *cli,
3743 int quota_fnum,
3744 SMB_NTQUOTA_STRUCT *pqt)
3745 {
3746 NTSTATUS status;
3747 DATA_BLOB inbuf = data_blob_null;
3748 DATA_BLOB info_blob = data_blob_null;
3749 DATA_BLOB outbuf = data_blob_null;
3750 TALLOC_CTX *frame = talloc_stackframe();
3751 unsigned sid_len;
3752 unsigned int offset;
3753 struct smb2_query_quota_info query = {0};
3754 struct file_get_quota_info info = {0};
3755 enum ndr_err_code err;
3756 struct ndr_push *ndr_push = NULL;
3757
3758 if (smbXcli_conn_has_async_calls(cli->conn)) {
3759 /*
3760 * Can't use sync call while an async call is in flight
3761 */
3762 status = NT_STATUS_INVALID_PARAMETER;
3763 goto fail;
3764 }
3765
3766 sid_len = ndr_size_dom_sid(&pqt->sid, 0);
3767
3768 query.return_single = 1;
3769
3770 info.next_entry_offset = 0;
3771 info.sid_length = sid_len;
3772 info.sid = pqt->sid;
3773
3774 err = ndr_push_struct_blob(
3775 &info_blob,
3776 frame,
3777 &info,
3778 (ndr_push_flags_fn_t)ndr_push_file_get_quota_info);
3779
3780 if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3781 status = NT_STATUS_INTERNAL_ERROR;
3782 goto fail;
3783 }
3784
3785 query.sid_list_length = info_blob.length;
3786 ndr_push = ndr_push_init_ctx(frame);
3787 if (!ndr_push) {
3788 status = NT_STATUS_NO_MEMORY;
3789 goto fail;
3790 }
3791
3792 err = ndr_push_smb2_query_quota_info(ndr_push,
3793 NDR_SCALARS | NDR_BUFFERS,
3794 &query);
3795
3796 if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3797 status = NT_STATUS_INTERNAL_ERROR;
3798 goto fail;
3799 }
3800
3801 err = ndr_push_array_uint8(ndr_push, NDR_SCALARS, info_blob.data,
3802 info_blob.length);
3803
3804 if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3805 status = NT_STATUS_INTERNAL_ERROR;
3806 goto fail;
3807 }
3808 inbuf.data = ndr_push->data;
3809 inbuf.length = ndr_push->offset;
3810
3811 status = cli_smb2_query_info_fnum(
3812 cli,
3813 quota_fnum,
3814 4, /* in_info_type */
3815 0, /* in_file_info_class */
3816 0xFFFF, /* in_max_output_length */
3817 &inbuf, /* in_input_buffer */
3818 0, /* in_additional_info */
3819 0, /* in_flags */
3820 frame,
3821 &outbuf);
3822
3823 if (!NT_STATUS_IS_OK(status)) {
3824 goto fail;
3825 }
3826
3827 if (!parse_user_quota_record(outbuf.data, outbuf.length, &offset,
3828 pqt)) {
3829 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3830 DEBUG(0, ("Got invalid FILE_QUOTA_INFORMATION in reply.\n"));
3831 }
3832
3833 fail:
3834 cli->raw_status = status;
3835
3836 TALLOC_FREE(frame);
3837 return status;
3838 }
3839
3840 /***************************************************************
3841 Wrapper that allows SMB2 to list user quota.
3842 Synchronous only.
3843 ***************************************************************/
3844
3845 NTSTATUS cli_smb2_list_user_quota_step(struct cli_state *cli,
3846 TALLOC_CTX *mem_ctx,
3847 int quota_fnum,
3848 SMB_NTQUOTA_LIST **pqt_list,
3849 bool first)
3850 {
3851 NTSTATUS status;
3852 DATA_BLOB inbuf = data_blob_null;
3853 DATA_BLOB outbuf = data_blob_null;
3854 TALLOC_CTX *frame = talloc_stackframe();
3855 struct smb2_query_quota_info info = {0};
3856 enum ndr_err_code err;
3857
3858 if (smbXcli_conn_has_async_calls(cli->conn)) {
3859 /*
3860 * Can't use sync call while an async call is in flight
3861 */
3862 status = NT_STATUS_INVALID_PARAMETER;
3863 goto cleanup;
3864 }
3865
3866 info.restart_scan = first ? 1 : 0;
3867
3868 err = ndr_push_struct_blob(
3869 &inbuf,
3870 frame,
3871 &info,
3872 (ndr_push_flags_fn_t)ndr_push_smb2_query_quota_info);
3873
3874 if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3875 status = NT_STATUS_INTERNAL_ERROR;
3876 goto cleanup;
3877 }
3878
3879 status = cli_smb2_query_info_fnum(
3880 cli,
3881 quota_fnum,
3882 4, /* in_info_type */
3883 0, /* in_file_info_class */
3884 0xFFFF, /* in_max_output_length */
3885 &inbuf, /* in_input_buffer */
3886 0, /* in_additional_info */
3887 0, /* in_flags */
3888 frame,
3889 &outbuf);
3890
3891 /*
3892 * safeguard against panic from calling parse_user_quota_list with
3893 * NULL buffer
3894 */
3895 if (NT_STATUS_IS_OK(status) && outbuf.length == 0) {
3896 status = NT_STATUS_NO_MORE_ENTRIES;
3897 }
3898
3899 if (!NT_STATUS_IS_OK(status)) {
3900 goto cleanup;
3901 }
3902
3903 status = parse_user_quota_list(outbuf.data, outbuf.length, mem_ctx,
3904 pqt_list);
3905
3906 cleanup:
3907 cli->raw_status = status;
3908
3909 TALLOC_FREE(frame);
3910 return status;
3911 }
3912
3913 /***************************************************************
3914 Wrapper that allows SMB2 to get file system quota.
3915 Synchronous only.
3916 ***************************************************************/
3917
3918 NTSTATUS cli_smb2_get_fs_quota_info(struct cli_state *cli,
3919 int quota_fnum,
3920 SMB_NTQUOTA_STRUCT *pqt)
3921 {
3922 NTSTATUS status;
3923 DATA_BLOB outbuf = data_blob_null;
3924 TALLOC_CTX *frame = talloc_stackframe();
3925
3926 if (smbXcli_conn_has_async_calls(cli->conn)) {
3927 /*
3928 * Can't use sync call while an async call is in flight
3929 */
3930 status = NT_STATUS_INVALID_PARAMETER;
3931 goto cleanup;
3932 }
3933
3934 status = cli_smb2_query_info_fnum(
3935 cli,
3936 quota_fnum,
3937 2, /* in_info_type */
3938 SMB_FS_QUOTA_INFORMATION - 1000, /* in_file_info_class */
3939 0xFFFF, /* in_max_output_length */
3940 NULL, /* in_input_buffer */
3941 0, /* in_additional_info */
3942 0, /* in_flags */
3943 frame,
3944 &outbuf);
3945
3946 if (!NT_STATUS_IS_OK(status)) {
3947 goto cleanup;
3948 }
3949
3950 status = parse_fs_quota_buffer(outbuf.data, outbuf.length, pqt);
3951
3952 cleanup:
3953 cli->raw_status = status;
3954
3955 TALLOC_FREE(frame);
3956 return status;
3957 }
3958
3959 /***************************************************************
3960 Wrapper that allows SMB2 to set user quota.
3961 Synchronous only.
3962 ***************************************************************/
3963
3964 NTSTATUS cli_smb2_set_user_quota(struct cli_state *cli,
3965 int quota_fnum,
3966 SMB_NTQUOTA_LIST *qtl)
3967 {
3968 NTSTATUS status;
3969 DATA_BLOB inbuf = data_blob_null;
3970 TALLOC_CTX *frame = talloc_stackframe();
3971
3972 if (smbXcli_conn_has_async_calls(cli->conn)) {
3973 /*
3974 * Can't use sync call while an async call is in flight
3975 */
3976 status = NT_STATUS_INVALID_PARAMETER;
3977 goto cleanup;
3978 }
3979
3980 status = build_user_quota_buffer(qtl, 0, talloc_tos(), &inbuf, NULL);
3981 if (!NT_STATUS_IS_OK(status)) {
3982 goto cleanup;
3983 }
3984
3985 status = cli_smb2_set_info_fnum(
3986 cli,
3987 quota_fnum,
3988 4, /* in_info_type */
3989 0, /* in_file_info_class */
3990 &inbuf, /* in_input_buffer */
3991 0); /* in_additional_info */
3992 cleanup:
3993
3994 cli->raw_status = status;
3995
3996 TALLOC_FREE(frame);
3997
3998 return status;
3999 }
4000
4001 NTSTATUS cli_smb2_set_fs_quota_info(struct cli_state *cli,
4002 int quota_fnum,
4003 SMB_NTQUOTA_STRUCT *pqt)
4004 {
4005 NTSTATUS status;
4006 DATA_BLOB inbuf = data_blob_null;
4007 TALLOC_CTX *frame = talloc_stackframe();
4008
4009 if (smbXcli_conn_has_async_calls(cli->conn)) {
4010 /*
4011 * Can't use sync call while an async call is in flight
4012 */
4013 status = NT_STATUS_INVALID_PARAMETER;
4014 goto cleanup;
4015 }
4016
4017 status = build_fs_quota_buffer(talloc_tos(), pqt, &inbuf, 0);
4018 if (!NT_STATUS_IS_OK(status)) {
4019 goto cleanup;
4020 }
4021
4022 status = cli_smb2_set_info_fnum(
4023 cli,
4024 quota_fnum,
4025 2, /* in_info_type */
4026 SMB_FS_QUOTA_INFORMATION - 1000, /* in_file_info_class */
4027 &inbuf, /* in_input_buffer */
4028 0); /* in_additional_info */
4029 cleanup:
4030 cli->raw_status = status;
4031
4032 TALLOC_FREE(frame);
4033 return status;
4034 }
4035
4036 struct cli_smb2_read_state {
4037 struct tevent_context *ev;
4038 struct cli_state *cli;
4039 struct smb2_hnd *ph;
4040 uint64_t start_offset;
4041 uint32_t size;
4042 uint32_t received;
4043 uint8_t *buf;
4044 };
4045
4046 static void cli_smb2_read_done(struct tevent_req *subreq);
4047
4048 struct tevent_req *cli_smb2_read_send(TALLOC_CTX *mem_ctx,
4049 struct tevent_context *ev,
4050 struct cli_state *cli,
4051 uint16_t fnum,
4052 off_t offset,
4053 size_t size)
4054 {
4055 NTSTATUS status;
4056 struct tevent_req *req, *subreq;
4057 struct cli_smb2_read_state *state;
4058
4059 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_read_state);
4060 if (req == NULL) {
4061 return NULL;
4062 }
4063 state->ev = ev;
4064 state->cli = cli;
4065 state->start_offset = (uint64_t)offset;
4066 state->size = (uint32_t)size;
4067 state->received = 0;
4068 state->buf = NULL;
4069
4070 status = map_fnum_to_smb2_handle(cli,
4071 fnum,
4072 &state->ph);
4073 if (tevent_req_nterror(req, status)) {
4074 return tevent_req_post(req, ev);
4075 }
4076
4077 subreq = smb2cli_read_send(state,
4078 state->ev,
4079 state->cli->conn,
4080 state->cli->timeout,
4081 state->cli->smb2.session,
4082 state->cli->smb2.tcon,
4083 state->size,
4084 state->start_offset,
4085 state->ph->fid_persistent,
4086 state->ph->fid_volatile,
4087 0, /* minimum_count */
4088 0); /* remaining_bytes */
4089
4090 if (tevent_req_nomem(subreq, req)) {
4091 return tevent_req_post(req, ev);
4092 }
4093 tevent_req_set_callback(subreq, cli_smb2_read_done, req);
4094 return req;
4095 }
4096
4097 static void cli_smb2_read_done(struct tevent_req *subreq)
4098 {
4099 struct tevent_req *req = tevent_req_callback_data(
4100 subreq, struct tevent_req);
4101 struct cli_smb2_read_state *state = tevent_req_data(
4102 req, struct cli_smb2_read_state);
4103 NTSTATUS status;
4104
4105 status = smb2cli_read_recv(subreq, state,
4106 &state->buf, &state->received);
4107 if (tevent_req_nterror(req, status)) {
4108 return;
4109 }
4110
4111 if (state->received > state->size) {
4112 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
4113 return;
4114 }
4115
4116 tevent_req_done(req);
4117 }
4118
4119 NTSTATUS cli_smb2_read_recv(struct tevent_req *req,
4120 ssize_t *received,
4121 uint8_t **rcvbuf)
4122 {
4123 NTSTATUS status;
4124 struct cli_smb2_read_state *state = tevent_req_data(
4125 req, struct cli_smb2_read_state);
4126
4127 if (tevent_req_is_nterror(req, &status)) {
4128 state->cli->raw_status = status;
4129 return status;
4130 }
4131 /*
4132 * As in cli_read_andx_recv() rcvbuf is talloced from the request, so
4133 * better make sure that you copy it away before you talloc_free(req).
4134 * "rcvbuf" is NOT a talloc_ctx of its own, so do not talloc_move it!
4135 */
4136 *received = (ssize_t)state->received;
4137 *rcvbuf = state->buf;
4138 state->cli->raw_status = NT_STATUS_OK;
4139 return NT_STATUS_OK;
4140 }
4141
4142 struct cli_smb2_write_state {
4143 struct tevent_context *ev;
4144 struct cli_state *cli;
4145 struct smb2_hnd *ph;
4146 uint32_t flags;
4147 const uint8_t *buf;
4148 uint64_t offset;
4149 uint32_t size;
4150 uint32_t written;
4151 };
4152
4153 static void cli_smb2_write_written(struct tevent_req *req);
4154
4155 struct tevent_req *cli_smb2_write_send(TALLOC_CTX *mem_ctx,
4156 struct tevent_context *ev,
4157 struct cli_state *cli,
4158 uint16_t fnum,
4159 uint16_t mode,
4160 const uint8_t *buf,
4161 off_t offset,
4162 size_t size)
4163 {
4164 NTSTATUS status;
4165 struct tevent_req *req, *subreq = NULL;
4166 struct cli_smb2_write_state *state = NULL;
4167
4168 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_write_state);
4169 if (req == NULL) {
4170 return NULL;
4171 }
4172 state->ev = ev;
4173 state->cli = cli;
4174 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
4175 state->flags = (uint32_t)mode;
4176 state->buf = buf;
4177 state->offset = (uint64_t)offset;
4178 state->size = (uint32_t)size;
4179 state->written = 0;
4180
4181 status = map_fnum_to_smb2_handle(cli,
4182 fnum,
4183 &state->ph);
4184 if (tevent_req_nterror(req, status)) {
4185 return tevent_req_post(req, ev);
4186 }
4187
4188 subreq = smb2cli_write_send(state,
4189 state->ev,
4190 state->cli->conn,
4191 state->cli->timeout,
4192 state->cli->smb2.session,
4193 state->cli->smb2.tcon,
4194 state->size,
4195 state->offset,
4196 state->ph->fid_persistent,
4197 state->ph->fid_volatile,
4198 0, /* remaining_bytes */
4199 state->flags, /* flags */
4200 state->buf);
4201
4202 if (tevent_req_nomem(subreq, req)) {
4203 return tevent_req_post(req, ev);
4204 }
4205 tevent_req_set_callback(subreq, cli_smb2_write_written, req);
4206 return req;
4207 }
4208
4209 static void cli_smb2_write_written(struct tevent_req *subreq)
4210 {
4211 struct tevent_req *req = tevent_req_callback_data(
4212 subreq, struct tevent_req);
4213 struct cli_smb2_write_state *state = tevent_req_data(
4214 req, struct cli_smb2_write_state);
4215 NTSTATUS status;
4216 uint32_t written;
4217
4218 status = smb2cli_write_recv(subreq, &written);
4219 TALLOC_FREE(subreq);
4220 if (tevent_req_nterror(req, status)) {
4221 return;
4222 }
4223
4224 state->written = written;
4225
4226 tevent_req_done(req);
4227 }
4228
4229 NTSTATUS cli_smb2_write_recv(struct tevent_req *req,
4230 size_t *pwritten)
4231 {
4232 struct cli_smb2_write_state *state = tevent_req_data(
4233 req, struct cli_smb2_write_state);
4234 NTSTATUS status;
4235
4236 if (tevent_req_is_nterror(req, &status)) {
4237 state->cli->raw_status = status;
4238 tevent_req_received(req);
4239 return status;
4240 }
4241
4242 if (pwritten != NULL) {
4243 *pwritten = (size_t)state->written;
4244 }
4245 state->cli->raw_status = NT_STATUS_OK;
4246 tevent_req_received(req);
4247 return NT_STATUS_OK;
4248 }
4249
4250 /***************************************************************
4251 Wrapper that allows SMB2 async write using an fnum.
4252 This is mostly cut-and-paste from Volker's code inside
4253 source3/libsmb/clireadwrite.c, adapted for SMB2.
4254
4255 Done this way so I can reuse all the logic inside cli_push()
4256 for free :-).
4257 ***************************************************************/
4258
4259 struct cli_smb2_writeall_state {
4260 struct tevent_context *ev;
4261 struct cli_state *cli;
4262 struct smb2_hnd *ph;
4263 uint32_t flags;
4264 const uint8_t *buf;
4265 uint64_t offset;
4266 uint32_t size;
4267 uint32_t written;
4268 };
4269
4270 static void cli_smb2_writeall_written(struct tevent_req *req);
4271
4272 struct tevent_req *cli_smb2_writeall_send(TALLOC_CTX *mem_ctx,
4273 struct tevent_context *ev,
4274 struct cli_state *cli,
4275 uint16_t fnum,
4276 uint16_t mode,
4277 const uint8_t *buf,
4278 off_t offset,
4279 size_t size)
4280 {
4281 NTSTATUS status;
4282 struct tevent_req *req, *subreq = NULL;
4283 struct cli_smb2_writeall_state *state = NULL;
4284 uint32_t to_write;
4285 uint32_t max_size;
4286 bool ok;
4287
4288 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_writeall_state);
4289 if (req == NULL) {
4290 return NULL;
4291 }
4292 state->ev = ev;
4293 state->cli = cli;
4294 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
4295 state->flags = (uint32_t)mode;
4296 state->buf = buf;
4297 state->offset = (uint64_t)offset;
4298 state->size = (uint32_t)size;
4299 state->written = 0;
4300
4301 status = map_fnum_to_smb2_handle(cli,
4302 fnum,
4303 &state->ph);
4304 if (tevent_req_nterror(req, status)) {
4305 return tevent_req_post(req, ev);
4306 }
4307
4308 to_write = state->size;
4309 max_size = smb2cli_conn_max_write_size(state->cli->conn);
4310 to_write = MIN(max_size, to_write);
4311 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
4312 if (ok) {
4313 to_write = MIN(max_size, to_write);
4314 }
4315
4316 subreq = smb2cli_write_send(state,
4317 state->ev,
4318 state->cli->conn,
4319 state->cli->timeout,
4320 state->cli->smb2.session,
4321 state->cli->smb2.tcon,
4322 to_write,
4323 state->offset,
4324 state->ph->fid_persistent,
4325 state->ph->fid_volatile,
4326 0, /* remaining_bytes */
4327 state->flags, /* flags */
4328 state->buf + state->written);
4329
4330 if (tevent_req_nomem(subreq, req)) {
4331 return tevent_req_post(req, ev);
4332 }
4333 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
4334 return req;
4335 }
4336
4337 static void cli_smb2_writeall_written(struct tevent_req *subreq)
4338 {
4339 struct tevent_req *req = tevent_req_callback_data(
4340 subreq, struct tevent_req);
4341 struct cli_smb2_writeall_state *state = tevent_req_data(
4342 req, struct cli_smb2_writeall_state);
4343 NTSTATUS status;
4344 uint32_t written, to_write;
4345 uint32_t max_size;
4346 bool ok;
4347
4348 status = smb2cli_write_recv(subreq, &written);
4349 TALLOC_FREE(subreq);
4350 if (tevent_req_nterror(req, status)) {
4351 return;
4352 }
4353
4354 state->written += written;
4355
4356 if (state->written > state->size) {
4357 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
4358 return;
4359 }
4360
4361 to_write = state->size - state->written;
4362
4363 if (to_write == 0) {
4364 tevent_req_done(req);
4365 return;
4366 }
4367
4368 max_size = smb2cli_conn_max_write_size(state->cli->conn);
4369 to_write = MIN(max_size, to_write);
4370 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
4371 if (ok) {
4372 to_write = MIN(max_size, to_write);
4373 }
4374
4375 subreq = smb2cli_write_send(state,
4376 state->ev,
4377 state->cli->conn,
4378 state->cli->timeout,
4379 state->cli->smb2.session,
4380 state->cli->smb2.tcon,
4381 to_write,
4382 state->offset + state->written,
4383 state->ph->fid_persistent,
4384 state->ph->fid_volatile,
4385 0, /* remaining_bytes */
4386 state->flags, /* flags */
4387 state->buf + state->written);
4388
4389 if (tevent_req_nomem(subreq, req)) {
4390 return;
4391 }
4392 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
4393 }
4394
4395 NTSTATUS cli_smb2_writeall_recv(struct tevent_req *req,
4396 size_t *pwritten)
4397 {
4398 struct cli_smb2_writeall_state *state = tevent_req_data(
4399 req, struct cli_smb2_writeall_state);
4400 NTSTATUS status;
4401
4402 if (tevent_req_is_nterror(req, &status)) {
4403 state->cli->raw_status = status;
4404 return status;
4405 }
4406 if (pwritten != NULL) {
4407 *pwritten = (size_t)state->written;
4408 }
4409 state->cli->raw_status = NT_STATUS_OK;
4410 return NT_STATUS_OK;
4411 }
4412
4413 struct cli_smb2_splice_state {
4414 struct tevent_context *ev;
4415 struct cli_state *cli;
4416 struct smb2_hnd *src_ph;
4417 struct smb2_hnd *dst_ph;
4418 int (*splice_cb)(off_t n, void *priv);
4419 void *priv;
4420 off_t written;
4421 off_t size;
4422 off_t src_offset;
4423 off_t dst_offset;
4424 bool resized;
4425 struct req_resume_key_rsp resume_rsp;
4426 struct srv_copychunk_copy cc_copy;
4427 };
4428
4429 static void cli_splice_copychunk_send(struct cli_smb2_splice_state *state,
4430 struct tevent_req *req);
4431
4432 static void cli_splice_copychunk_done(struct tevent_req *subreq)
4433 {
4434 struct tevent_req *req = tevent_req_callback_data(
4435 subreq, struct tevent_req);
4436 struct cli_smb2_splice_state *state =
4437 tevent_req_data(req,
4438 struct cli_smb2_splice_state);
4439 struct smbXcli_conn *conn = state->cli->conn;
4440 DATA_BLOB out_input_buffer = data_blob_null;
4441 DATA_BLOB out_output_buffer = data_blob_null;
4442 struct srv_copychunk_rsp cc_copy_rsp;
4443 enum ndr_err_code ndr_ret;
4444 NTSTATUS status;
4445
4446 status = smb2cli_ioctl_recv(subreq, state,
4447 &out_input_buffer,
4448 &out_output_buffer);
4449 TALLOC_FREE(subreq);
4450 if ((!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER) ||
4451 state->resized) && tevent_req_nterror(req, status)) {
4452 return;
4453 }
4454
4455 ndr_ret = ndr_pull_struct_blob(&out_output_buffer, state, &cc_copy_rsp,
4456 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
4457 if (ndr_ret != NDR_ERR_SUCCESS) {
4458 DEBUG(0, ("failed to unmarshall copy chunk rsp\n"));
4459 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
4460 return;
4461 }
4462
4463 if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
4464 uint32_t max_chunks = MIN(cc_copy_rsp.chunks_written,
4465 cc_copy_rsp.total_bytes_written / cc_copy_rsp.chunk_bytes_written);
4466 if ((cc_copy_rsp.chunk_bytes_written > smb2cli_conn_cc_chunk_len(conn) ||
4467 max_chunks > smb2cli_conn_cc_max_chunks(conn)) &&
4468 tevent_req_nterror(req, status)) {
4469 return;
4470 }
4471
4472 state->resized = true;
4473 smb2cli_conn_set_cc_chunk_len(conn, cc_copy_rsp.chunk_bytes_written);
4474 smb2cli_conn_set_cc_max_chunks(conn, max_chunks);
4475 } else {
4476 if ((state->src_offset > INT64_MAX - cc_copy_rsp.total_bytes_written) ||
4477 (state->dst_offset > INT64_MAX - cc_copy_rsp.total_bytes_written) ||
4478 (state->written > INT64_MAX - cc_copy_rsp.total_bytes_written)) {
4479 tevent_req_nterror(req, NT_STATUS_FILE_TOO_LARGE);
4480 return;
4481 }
4482 state->src_offset += cc_copy_rsp.total_bytes_written;
4483 state->dst_offset += cc_copy_rsp.total_bytes_written;
4484 state->written += cc_copy_rsp.total_bytes_written;
4485 if (!state->splice_cb(state->written, state->priv)) {
4486 tevent_req_nterror(req, NT_STATUS_CANCELLED);
4487 return;
4488 }
4489 }
4490
4491 cli_splice_copychunk_send(state, req);
4492 }
4493
4494 static void cli_splice_copychunk_send(struct cli_smb2_splice_state *state,
4495 struct tevent_req *req)
4496 {
4497 struct tevent_req *subreq;
4498 enum ndr_err_code ndr_ret;
4499 struct smbXcli_conn *conn = state->cli->conn;
4500 struct srv_copychunk_copy *cc_copy = &state->cc_copy;
4501 off_t src_offset = state->src_offset;
4502 off_t dst_offset = state->dst_offset;
4503 uint32_t req_len = MIN(smb2cli_conn_cc_chunk_len(conn) * smb2cli_conn_cc_max_chunks(conn),
4504 state->size - state->written);
4505 DATA_BLOB in_input_buffer = data_blob_null;
4506 DATA_BLOB in_output_buffer = data_blob_null;
4507
4508 if (state->size - state->written == 0) {
4509 tevent_req_done(req);
4510 return;
4511 }
4512
4513 cc_copy->chunk_count = 0;
4514 while (req_len) {
4515 cc_copy->chunks[cc_copy->chunk_count].source_off = src_offset;
4516 cc_copy->chunks[cc_copy->chunk_count].target_off = dst_offset;
4517 cc_copy->chunks[cc_copy->chunk_count].length = MIN(req_len,
4518 smb2cli_conn_cc_chunk_len(conn));
4519 if (req_len < cc_copy->chunks[cc_copy->chunk_count].length) {
4520 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
4521 return;
4522 }
4523 req_len -= cc_copy->chunks[cc_copy->chunk_count].length;
4524 if ((src_offset > INT64_MAX - cc_copy->chunks[cc_copy->chunk_count].length) ||
4525 (dst_offset > INT64_MAX - cc_copy->chunks[cc_copy->chunk_count].length)) {
4526 tevent_req_nterror(req, NT_STATUS_FILE_TOO_LARGE);
4527 return;
4528 }
4529 src_offset += cc_copy->chunks[cc_copy->chunk_count].length;
4530 dst_offset += cc_copy->chunks[cc_copy->chunk_count].length;
4531 cc_copy->chunk_count++;
4532 }
4533
4534 ndr_ret = ndr_push_struct_blob(&in_input_buffer, state, cc_copy,
4535 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
4536 if (ndr_ret != NDR_ERR_SUCCESS) {
4537 DEBUG(0, ("failed to marshall copy chunk req\n"));
4538 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
4539 return;
4540 }
4541
4542 subreq = smb2cli_ioctl_send(state, state->ev, state->cli->conn,
4543 state->cli->timeout,
4544 state->cli->smb2.session,
4545 state->cli->smb2.tcon,
4546 state->dst_ph->fid_persistent, /* in_fid_persistent */
4547 state->dst_ph->fid_volatile, /* in_fid_volatile */
4548 FSCTL_SRV_COPYCHUNK_WRITE,
4549 0, /* in_max_input_length */
4550 &in_input_buffer,
4551 12, /* in_max_output_length */
4552 &in_output_buffer,
4553 SMB2_IOCTL_FLAG_IS_FSCTL);
4554 if (tevent_req_nomem(subreq, req)) {
4555 return;
4556 }
4557 tevent_req_set_callback(subreq,
4558 cli_splice_copychunk_done,
4559 req);
4560 }
4561
4562 static void cli_splice_key_done(struct tevent_req *subreq)
4563 {
4564 struct tevent_req *req = tevent_req_callback_data(
4565 subreq, struct tevent_req);
4566 struct cli_smb2_splice_state *state =
4567 tevent_req_data(req,
4568 struct cli_smb2_splice_state);
4569 enum ndr_err_code ndr_ret;
4570 NTSTATUS status;
4571
4572 DATA_BLOB out_input_buffer = data_blob_null;
4573 DATA_BLOB out_output_buffer = data_blob_null;
4574
4575 status = smb2cli_ioctl_recv(subreq, state,
4576 &out_input_buffer,
4577 &out_output_buffer);
4578 TALLOC_FREE(subreq);
4579 if (tevent_req_nterror(req, status)) {
4580 return;
4581 }
4582
4583 ndr_ret = ndr_pull_struct_blob(&out_output_buffer,
4584 state, &state->resume_rsp,
4585 (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
4586 if (ndr_ret != NDR_ERR_SUCCESS) {
4587 DEBUG(0, ("failed to unmarshall resume key rsp\n"));
4588 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
4589 return;
4590 }
4591
4592 memcpy(&state->cc_copy.source_key,
4593 &state->resume_rsp.resume_key,
4594 sizeof state->resume_rsp.resume_key);
4595
4596 cli_splice_copychunk_send(state, req);
4597 }
4598
4599 struct tevent_req *cli_smb2_splice_send(TALLOC_CTX *mem_ctx,
4600 struct tevent_context *ev,
4601 struct cli_state *cli,
4602 uint16_t src_fnum, uint16_t dst_fnum,
4603 off_t size, off_t src_offset, off_t dst_offset,
4604 int (*splice_cb)(off_t n, void *priv),
4605 void *priv)
4606 {
4607 struct tevent_req *req;
4608 struct tevent_req *subreq;
4609 struct cli_smb2_splice_state *state;
4610 NTSTATUS status;
4611 DATA_BLOB in_input_buffer = data_blob_null;
4612 DATA_BLOB in_output_buffer = data_blob_null;
4613
4614 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_splice_state);
4615 if (req == NULL) {
4616 return NULL;
4617 }
4618 state->cli = cli;
4619 state->ev = ev;
4620 state->splice_cb = splice_cb;
4621 state->priv = priv;
4622 state->size = size;
4623 state->written = 0;
4624 state->src_offset = src_offset;
4625 state->dst_offset = dst_offset;
4626 state->cc_copy.chunks = talloc_array(state,
4627 struct srv_copychunk,
4628 smb2cli_conn_cc_max_chunks(cli->conn));
4629 if (state->cc_copy.chunks == NULL) {
4630 return NULL;
4631 }
4632
4633 status = map_fnum_to_smb2_handle(cli, src_fnum, &state->src_ph);
4634 if (tevent_req_nterror(req, status))
4635 return tevent_req_post(req, ev);
4636
4637 status = map_fnum_to_smb2_handle(cli, dst_fnum, &state->dst_ph);
4638 if (tevent_req_nterror(req, status))
4639 return tevent_req_post(req, ev);
4640
4641 subreq = smb2cli_ioctl_send(state, ev, cli->conn,
4642 cli->timeout,
4643 cli->smb2.session,
4644 cli->smb2.tcon,
4645 state->src_ph->fid_persistent, /* in_fid_persistent */
4646 state->src_ph->fid_volatile, /* in_fid_volatile */
4647 FSCTL_SRV_REQUEST_RESUME_KEY,
4648 0, /* in_max_input_length */
4649 &in_input_buffer,
4650 32, /* in_max_output_length */
4651 &in_output_buffer,
4652 SMB2_IOCTL_FLAG_IS_FSCTL);
4653 if (tevent_req_nomem(subreq, req)) {
4654 return NULL;
4655 }
4656 tevent_req_set_callback(subreq,
4657 cli_splice_key_done,
4658 req);
4659
4660 return req;
4661 }
4662
4663 NTSTATUS cli_smb2_splice_recv(struct tevent_req *req, off_t *written)
4664 {
4665 struct cli_smb2_splice_state *state = tevent_req_data(
4666 req, struct cli_smb2_splice_state);
4667 NTSTATUS status;
4668
4669 if (tevent_req_is_nterror(req, &status)) {
4670 state->cli->raw_status = status;
4671 tevent_req_received(req);
4672 return status;
4673 }
4674 if (written != NULL) {
4675 *written = state->written;
4676 }
4677 state->cli->raw_status = NT_STATUS_OK;
4678 tevent_req_received(req);
4679 return NT_STATUS_OK;
4680 }
4681
4682 /***************************************************************
4683 SMB2 enum shadow copy data.
4684 ***************************************************************/
4685
4686 struct cli_smb2_shadow_copy_data_fnum_state {
4687 struct cli_state *cli;
4688 uint16_t fnum;
4689 struct smb2_hnd *ph;
4690 DATA_BLOB out_input_buffer;
4691 DATA_BLOB out_output_buffer;
4692 };
4693
4694 static void cli_smb2_shadow_copy_data_fnum_done(struct tevent_req *subreq);
4695
4696 static struct tevent_req *cli_smb2_shadow_copy_data_fnum_send(
4697 TALLOC_CTX *mem_ctx,
4698 struct tevent_context *ev,
4699 struct cli_state *cli,
4700 uint16_t fnum,
4701 bool get_names)
4702 {
4703 struct tevent_req *req, *subreq;
4704 struct cli_smb2_shadow_copy_data_fnum_state *state;
4705 NTSTATUS status;
4706
4707 req = tevent_req_create(mem_ctx, &state,
4708 struct cli_smb2_shadow_copy_data_fnum_state);
4709 if (req == NULL) {
4710 return NULL;
4711 }
4712
4713 state->cli = cli;
4714 state->fnum = fnum;
4715
4716 status = map_fnum_to_smb2_handle(cli, fnum, &state->ph);
4717 if (tevent_req_nterror(req, status)) {
4718 return tevent_req_post(req, ev);
4719 }
4720
4721 /*
4722 * TODO. Under SMB2 we should send a zero max_output_length
4723 * ioctl to get the required size, then send another ioctl
4724 * to get the data, but the current SMB1 implementation just
4725 * does one roundtrip with a 64K buffer size. Do the same
4726 * for now. JRA.
4727 */
4728
4729 subreq = smb2cli_ioctl_send(state, ev, state->cli->conn,
4730 state->cli->timeout,
4731 state->cli->smb2.session,
4732 state->cli->smb2.tcon,
4733 state->ph->fid_persistent, /* in_fid_persistent */
4734 state->ph->fid_volatile, /* in_fid_volatile */
4735 FSCTL_GET_SHADOW_COPY_DATA,
4736 0, /* in_max_input_length */
4737 NULL, /* in_input_buffer */
4738 get_names ?
4739 CLI_BUFFER_SIZE : 16, /* in_max_output_length */
4740 NULL, /* in_output_buffer */
4741 SMB2_IOCTL_FLAG_IS_FSCTL);
4742
4743 if (tevent_req_nomem(subreq, req)) {
4744 return tevent_req_post(req, ev);
4745 }
4746 tevent_req_set_callback(subreq,
4747 cli_smb2_shadow_copy_data_fnum_done,
4748 req);
4749
4750 return req;
4751 }
4752
4753 static void cli_smb2_shadow_copy_data_fnum_done(struct tevent_req *subreq)
4754 {
4755 struct tevent_req *req = tevent_req_callback_data(
4756 subreq, struct tevent_req);
4757 struct cli_smb2_shadow_copy_data_fnum_state *state = tevent_req_data(
4758 req, struct cli_smb2_shadow_copy_data_fnum_state);
4759 NTSTATUS status;
4760
4761 status = smb2cli_ioctl_recv(subreq, state,
4762 &state->out_input_buffer,
4763 &state->out_output_buffer);
4764 tevent_req_simple_finish_ntstatus(subreq, status);
4765 }
4766
4767 static NTSTATUS cli_smb2_shadow_copy_data_fnum_recv(struct tevent_req *req,
4768 TALLOC_CTX *mem_ctx,
4769 bool get_names,
4770 char ***pnames,
4771 int *pnum_names)
4772 {
4773 struct cli_smb2_shadow_copy_data_fnum_state *state = tevent_req_data(
4774 req, struct cli_smb2_shadow_copy_data_fnum_state);
4775 char **names = NULL;
4776 uint32_t num_names = 0;
4777 uint32_t num_names_returned = 0;
4778 uint32_t dlength = 0;
4779 uint32_t i;
4780 uint8_t *endp = NULL;
4781 NTSTATUS status;
4782
4783 if (tevent_req_is_nterror(req, &status)) {
4784 return status;
4785 }
4786
4787 if (state->out_output_buffer.length < 16) {
4788 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4789 }
4790
4791 num_names = IVAL(state->out_output_buffer.data, 0);
4792 num_names_returned = IVAL(state->out_output_buffer.data, 4);
4793 dlength = IVAL(state->out_output_buffer.data, 8);
4794
4795 if (num_names > 0x7FFFFFFF) {
4796 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4797 }
4798
4799 if (get_names == false) {
4800 *pnum_names = (int)num_names;
4801 return NT_STATUS_OK;
4802 }
4803 if (num_names != num_names_returned) {
4804 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4805 }
4806 if (dlength + 12 < 12) {
4807 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4808 }
4809 /*
4810 * NB. The below is an allowable return if there are
4811 * more snapshots than the buffer size we told the
4812 * server we can receive. We currently don't support
4813 * this.
4814 */
4815 if (dlength + 12 > state->out_output_buffer.length) {
4816 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4817 }
4818 if (state->out_output_buffer.length +
4819 (2 * sizeof(SHADOW_COPY_LABEL)) <
4820 state->out_output_buffer.length) {
4821 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4822 }
4823
4824 names = talloc_array(mem_ctx, char *, num_names_returned);
4825 if (names == NULL) {
4826 return NT_STATUS_NO_MEMORY;
4827 }
4828
4829 endp = state->out_output_buffer.data +
4830 state->out_output_buffer.length;
4831
4832 for (i=0; i<num_names_returned; i++) {
4833 bool ret;
4834 uint8_t *src;
4835 size_t converted_size;
4836
4837 src = state->out_output_buffer.data + 12 +
4838 (i * 2 * sizeof(SHADOW_COPY_LABEL));
4839
4840 if (src + (2 * sizeof(SHADOW_COPY_LABEL)) > endp) {
4841 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4842 }
4843 ret = convert_string_talloc(
4844 names, CH_UTF16LE, CH_UNIX,
4845 src, 2 * sizeof(SHADOW_COPY_LABEL),
4846 &names[i], &converted_size);
4847 if (!ret) {
4848 TALLOC_FREE(names);
4849 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4850 }
4851 }
4852 *pnum_names = num_names;
4853 *pnames = names;
4854 return NT_STATUS_OK;
4855 }
4856
4857 NTSTATUS cli_smb2_shadow_copy_data(TALLOC_CTX *mem_ctx,
4858 struct cli_state *cli,
4859 uint16_t fnum,
4860 bool get_names,
4861 char ***pnames,
4862 int *pnum_names)
4863 {
4864 TALLOC_CTX *frame = talloc_stackframe();
4865 struct tevent_context *ev;
4866 struct tevent_req *req;
4867 NTSTATUS status = NT_STATUS_NO_MEMORY;
4868
4869 if (smbXcli_conn_has_async_calls(cli->conn)) {
4870 /*
4871 * Can't use sync call while an async call is in flight
4872 */
4873 status = NT_STATUS_INVALID_PARAMETER;
4874 goto fail;
4875 }
4876 ev = samba_tevent_context_init(frame);
4877 if (ev == NULL) {
4878 goto fail;
4879 }
4880 req = cli_smb2_shadow_copy_data_fnum_send(frame,
4881 ev,
4882 cli,
4883 fnum,
4884 get_names);
4885 if (req == NULL) {
4886 goto fail;
4887 }
4888 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
4889 goto fail;
4890 }
4891 status = cli_smb2_shadow_copy_data_fnum_recv(req,
4892 mem_ctx,
4893 get_names,
4894 pnames,
4895 pnum_names);
4896 fail:
4897 cli->raw_status = status;
4898
4899 TALLOC_FREE(frame);
4900 return status;
4901 }
4902
4903 /***************************************************************
4904 Wrapper that allows SMB2 to truncate a file.
4905 Synchronous only.
4906 ***************************************************************/
4907
4908 NTSTATUS cli_smb2_ftruncate(struct cli_state *cli,
4909 uint16_t fnum,
4910 uint64_t newsize)
4911 {
4912 NTSTATUS status;
4913 uint8_t buf[8] = {0};
4914 DATA_BLOB inbuf = { .data = buf, .length = sizeof(buf) };
4915 TALLOC_CTX *frame = talloc_stackframe();
4916
4917 if (smbXcli_conn_has_async_calls(cli->conn)) {
4918 /*
4919 * Can't use sync call while an async call is in flight
4920 */
4921 status = NT_STATUS_INVALID_PARAMETER;
4922 goto fail;
4923 }
4924
4925 SBVAL(buf, 0, newsize);
4926
4927 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
4928 level 20 (SMB_FILE_END_OF_FILE_INFORMATION - 1000). */
4929
4930 status = cli_smb2_set_info_fnum(
4931 cli,
4932 fnum,
4933 1, /* in_info_type */
4934 SMB_FILE_END_OF_FILE_INFORMATION-1000, /* in_file_info_class */
4935 &inbuf, /* in_input_buffer */
4936 0);
4937
4938 fail:
4939
4940 cli->raw_status = status;
4941
4942 TALLOC_FREE(frame);
4943 return status;
4944 }
4945
4946 struct cli_smb2_notify_state {
4947 struct tevent_req *subreq;
4948 struct notify_change *changes;
4949 size_t num_changes;
4950 };
4951
4952 static void cli_smb2_notify_done(struct tevent_req *subreq);
4953 static bool cli_smb2_notify_cancel(struct tevent_req *req);
4954
4955 struct tevent_req *cli_smb2_notify_send(
4956 TALLOC_CTX *mem_ctx,
4957 struct tevent_context *ev,
4958 struct cli_state *cli,
4959 uint16_t fnum,
4960 uint32_t buffer_size,
4961 uint32_t completion_filter,
4962 bool recursive)
4963 {
4964 struct tevent_req *req = NULL;
4965 struct cli_smb2_notify_state *state = NULL;
4966 struct smb2_hnd *ph = NULL;
4967 NTSTATUS status;
4968
4969 req = tevent_req_create(mem_ctx, &state,
4970 struct cli_smb2_notify_state);
4971 if (req == NULL) {
4972 return NULL;
4973 }
4974
4975 status = map_fnum_to_smb2_handle(cli, fnum, &ph);
4976 if (tevent_req_nterror(req, status)) {
4977 return tevent_req_post(req, ev);
4978 }
4979
4980 state->subreq = smb2cli_notify_send(
4981 state,
4982 ev,
4983 cli->conn,
4984 cli->timeout,
4985 cli->smb2.session,
4986 cli->smb2.tcon,
4987 buffer_size,
4988 ph->fid_persistent,
4989 ph->fid_volatile,
4990 completion_filter,
4991 recursive);
4992 if (tevent_req_nomem(state->subreq, req)) {
4993 return tevent_req_post(req, ev);
4994 }
4995 tevent_req_set_callback(state->subreq, cli_smb2_notify_done, req);
4996 tevent_req_set_cancel_fn(req, cli_smb2_notify_cancel);
4997 return req;
4998 }
4999
5000 static bool cli_smb2_notify_cancel(struct tevent_req *req)
5001 {
5002 struct cli_smb2_notify_state *state = tevent_req_data(
5003 req, struct cli_smb2_notify_state);
5004 bool ok;
5005
5006 ok = tevent_req_cancel(state->subreq);
5007 return ok;
5008 }
5009
5010 static void cli_smb2_notify_done(struct tevent_req *subreq)
5011 {
5012 struct tevent_req *req = tevent_req_callback_data(
5013 subreq, struct tevent_req);
5014 struct cli_smb2_notify_state *state = tevent_req_data(
5015 req, struct cli_smb2_notify_state);
5016 uint8_t *base;
5017 uint32_t len;
5018 uint32_t ofs;
5019 NTSTATUS status;
5020
5021 status = smb2cli_notify_recv(subreq, state, &base, &len);
5022 TALLOC_FREE(subreq);
5023
5024 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
5025 tevent_req_done(req);
5026 return;
5027 }
5028 if (tevent_req_nterror(req, status)) {
5029 return;
5030 }
5031
5032 ofs = 0;
5033
5034 while (len - ofs >= 12) {
5035 struct notify_change *tmp;
5036 struct notify_change *c;
5037 uint32_t next_ofs = IVAL(base, ofs);
5038 uint32_t file_name_length = IVAL(base, ofs+8);
5039 size_t namelen;
5040 bool ok;
5041
5042 tmp = talloc_realloc(
5043 state,
5044 state->changes,
5045 struct notify_change,
5046 state->num_changes + 1);
5047 if (tevent_req_nomem(tmp, req)) {
5048 return;
5049 }
5050 state->changes = tmp;
5051 c = &state->changes[state->num_changes];
5052 state->num_changes += 1;
5053
5054 if (smb_buffer_oob(len, ofs, next_ofs) ||
5055 smb_buffer_oob(len, ofs+12, file_name_length)) {
5056 tevent_req_nterror(
5057 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
5058 return;
5059 }
5060
5061 c->action = IVAL(base, ofs+4);
5062
5063 ok = convert_string_talloc(
5064 state->changes,
5065 CH_UTF16LE,
5066 CH_UNIX,
5067 base + ofs + 12,
5068 file_name_length,
5069 &c->name,
5070 &namelen);
5071 if (!ok) {
5072 tevent_req_nterror(
5073 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
5074 return;
5075 }
5076
5077 if (next_ofs == 0) {
5078 break;
5079 }
5080 ofs += next_ofs;
5081 }
5082
5083 tevent_req_done(req);
5084 }
5085
5086 NTSTATUS cli_smb2_notify_recv(struct tevent_req *req,
5087 TALLOC_CTX *mem_ctx,
5088 struct notify_change **pchanges,
5089 uint32_t *pnum_changes)
5090 {
5091 struct cli_smb2_notify_state *state = tevent_req_data(
5092 req, struct cli_smb2_notify_state);
5093 NTSTATUS status;
5094
5095 if (tevent_req_is_nterror(req, &status)) {
5096 return status;
5097 }
5098 *pchanges = talloc_move(mem_ctx, &state->changes);
5099 *pnum_changes = state->num_changes;
5100 return NT_STATUS_OK;
5101 }
5102
5103 NTSTATUS cli_smb2_notify(struct cli_state *cli, uint16_t fnum,
5104 uint32_t buffer_size, uint32_t completion_filter,
5105 bool recursive, TALLOC_CTX *mem_ctx,
5106 struct notify_change **pchanges,
5107 uint32_t *pnum_changes)
5108 {
5109 TALLOC_CTX *frame = talloc_stackframe();
5110 struct tevent_context *ev;
5111 struct tevent_req *req;
5112 NTSTATUS status = NT_STATUS_NO_MEMORY;
5113
5114 if (smbXcli_conn_has_async_calls(cli->conn)) {
5115 /*
5116 * Can't use sync call while an async call is in flight
5117 */
5118 status = NT_STATUS_INVALID_PARAMETER;
5119 goto fail;
5120 }
5121 ev = samba_tevent_context_init(frame);
5122 if (ev == NULL) {
5123 goto fail;
5124 }
5125 req = cli_smb2_notify_send(
5126 frame,
5127 ev,
5128 cli,
5129 fnum,
5130 buffer_size,
5131 completion_filter,
5132 recursive);
5133 if (req == NULL) {
5134 goto fail;
5135 }
5136 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5137 goto fail;
5138 }
5139 status = cli_smb2_notify_recv(req, mem_ctx, pchanges, pnum_changes);
5140 fail:
5141 TALLOC_FREE(frame);
5142 return status;
5143 }
5144
5145 struct cli_smb2_fsctl_state {
5146 DATA_BLOB out;
5147 };
5148
5149 static void cli_smb2_fsctl_done(struct tevent_req *subreq);
5150
5151 struct tevent_req *cli_smb2_fsctl_send(
5152 TALLOC_CTX *mem_ctx,
5153 struct tevent_context *ev,
5154 struct cli_state *cli,
5155 uint16_t fnum,
5156 uint32_t ctl_code,
5157 const DATA_BLOB *in,
5158 uint32_t max_out)
5159 {
5160 struct tevent_req *req = NULL, *subreq = NULL;
5161 struct cli_smb2_fsctl_state *state = NULL;
5162 struct smb2_hnd *ph = NULL;
5163 NTSTATUS status;
5164
5165 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_fsctl_state);
5166 if (req == NULL) {
5167 return NULL;
5168 }
5169
5170 status = map_fnum_to_smb2_handle(cli, fnum, &ph);
5171 if (tevent_req_nterror(req, status)) {
5172 return tevent_req_post(req, ev);
5173 }
5174
5175 subreq = smb2cli_ioctl_send(
5176 state,
5177 ev,
5178 cli->conn,
5179 cli->timeout,
5180 cli->smb2.session,
5181 cli->smb2.tcon,
5182 ph->fid_persistent,
5183 ph->fid_volatile,
5184 ctl_code,
5185 0, /* in_max_input_length */
5186 in,
5187 max_out,
5188 NULL,
5189 SMB2_IOCTL_FLAG_IS_FSCTL);
5190
5191 if (tevent_req_nomem(subreq, req)) {
5192 return tevent_req_post(req, ev);
5193 }
5194 tevent_req_set_callback(subreq, cli_smb2_fsctl_done, req);
5195 return req;
5196 }
5197
5198 static void cli_smb2_fsctl_done(struct tevent_req *subreq)
5199 {
5200 struct tevent_req *req = tevent_req_callback_data(
5201 subreq, struct tevent_req);
5202 struct cli_smb2_fsctl_state *state = tevent_req_data(
5203 req, struct cli_smb2_fsctl_state);
5204 NTSTATUS status;
5205
5206 status = smb2cli_ioctl_recv(subreq, state, NULL, &state->out);
5207 tevent_req_simple_finish_ntstatus(subreq, status);
5208 }
5209
5210 NTSTATUS cli_smb2_fsctl_recv(
5211 struct tevent_req *req, TALLOC_CTX *mem_ctx, DATA_BLOB *out)
5212 {
5213 struct cli_smb2_fsctl_state *state = tevent_req_data(
5214 req, struct cli_smb2_fsctl_state);
5215 NTSTATUS status = NT_STATUS_OK;
5216
5217 if (tevent_req_is_nterror(req, &status)) {
5218 tevent_req_received(req);
5219 return status;
5220 }
5221
5222 if (state->out.length == 0) {
5223 *out = (DATA_BLOB) { .data = NULL, };
5224 } else {
5225 /*
5226 * Can't use talloc_move() here, the outblobs from
5227 * smb2cli_ioctl_recv() are not standalone talloc
5228 * objects but just peek into the larger buffers
5229 * received, hanging off "state".
5230 */
5231 *out = data_blob_talloc(
5232 mem_ctx, state->out.data, state->out.length);
5233 if (out->data == NULL) {
5234 status = NT_STATUS_NO_MEMORY;
5235 }
5236 }
5237
5238 tevent_req_received(req);
5239 return NT_STATUS_OK;
5240 }
Samba GIT mirror