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