?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libcli/smb: move {smb,trans2}_bytes_push_{str,bytes}() to common code
[Samba.git] / source3 / libsmb / cli_smb2_fnum.c
blob325ae7812d90585a9530303aa816eb683e8231e9
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
45 struct smb2_hnd {
46 uint64_t fid_persistent;
47 uint64_t fid_volatile;
48 };
49
50 /*
51 * Handle mapping code.
52 */
53
54 /***************************************************************
55 Allocate a new fnum between 1 and 0xFFFE from an smb2_hnd.
56 Ensures handle is owned by cli struct.
57 ***************************************************************/
58
59 static NTSTATUS map_smb2_handle_to_fnum(struct cli_state *cli,
60 const struct smb2_hnd *ph, /* In */
61 uint16_t *pfnum) /* Out */
62 {
63 int ret;
64 struct idr_context *idp = cli->smb2.open_handles;
65 struct smb2_hnd *owned_h = talloc_memdup(cli,
66 ph,
67 sizeof(struct smb2_hnd));
68
69 if (owned_h == NULL) {
70 return NT_STATUS_NO_MEMORY;
71 }
72
73 if (idp == NULL) {
74 /* Lazy init */
75 cli->smb2.open_handles = idr_init(cli);
76 if (cli->smb2.open_handles == NULL) {
77 TALLOC_FREE(owned_h);
78 return NT_STATUS_NO_MEMORY;
79 }
80 idp = cli->smb2.open_handles;
81 }
82
83 ret = idr_get_new_above(idp, owned_h, 1, 0xFFFE);
84 if (ret == -1) {
85 TALLOC_FREE(owned_h);
86 return NT_STATUS_NO_MEMORY;
87 }
88
89 *pfnum = (uint16_t)ret;
90 return NT_STATUS_OK;
91 }
92
93 /***************************************************************
94 Return the smb2_hnd pointer associated with the given fnum.
95 ***************************************************************/
96
97 static NTSTATUS map_fnum_to_smb2_handle(struct cli_state *cli,
98 uint16_t fnum, /* In */
99 struct smb2_hnd **pph) /* Out */
100 {
101 struct idr_context *idp = cli->smb2.open_handles;
102
103 if (idp == NULL) {
104 return NT_STATUS_INVALID_PARAMETER;
105 }
106 *pph = (struct smb2_hnd *)idr_find(idp, fnum);
107 if (*pph == NULL) {
108 return NT_STATUS_INVALID_HANDLE;
109 }
110 return NT_STATUS_OK;
111 }
112
113 /***************************************************************
114 Delete the fnum to smb2_hnd mapping. Zeros out handle on
115 successful return.
116 ***************************************************************/
117
118 static NTSTATUS delete_smb2_handle_mapping(struct cli_state *cli,
119 struct smb2_hnd **pph, /* In */
120 uint16_t fnum) /* In */
121 {
122 struct idr_context *idp = cli->smb2.open_handles;
123 struct smb2_hnd *ph;
124
125 if (idp == NULL) {
126 return NT_STATUS_INVALID_PARAMETER;
127 }
128
129 ph = (struct smb2_hnd *)idr_find(idp, fnum);
130 if (ph != *pph) {
131 return NT_STATUS_INVALID_PARAMETER;
132 }
133 idr_remove(idp, fnum);
134 TALLOC_FREE(*pph);
135 return NT_STATUS_OK;
136 }
137
138 /***************************************************************
139 Oplock mapping code.
140 ***************************************************************/
141
142 static uint8_t flags_to_smb2_oplock(uint32_t create_flags)
143 {
144 if (create_flags & REQUEST_BATCH_OPLOCK) {
145 return SMB2_OPLOCK_LEVEL_BATCH;
146 } else if (create_flags & REQUEST_OPLOCK) {
147 return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
148 }
149
150 /* create_flags doesn't do a level2 request. */
151 return SMB2_OPLOCK_LEVEL_NONE;
152 }
153
154 /***************************************************************
155 Small wrapper that allows SMB2 create to return a uint16_t fnum.
156 ***************************************************************/
157
158 struct cli_smb2_create_fnum_state {
159 struct cli_state *cli;
160 struct smb_create_returns cr;
161 uint16_t fnum;
162 struct tevent_req *subreq;
163 };
164
165 static void cli_smb2_create_fnum_done(struct tevent_req *subreq);
166 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req);
167
168 struct tevent_req *cli_smb2_create_fnum_send(TALLOC_CTX *mem_ctx,
169 struct tevent_context *ev,
170 struct cli_state *cli,
171 const char *fname,
172 uint32_t create_flags,
173 uint32_t desired_access,
174 uint32_t file_attributes,
175 uint32_t share_access,
176 uint32_t create_disposition,
177 uint32_t create_options)
178 {
179 struct tevent_req *req, *subreq;
180 struct cli_smb2_create_fnum_state *state;
181 size_t fname_len = 0;
182 const char *startp = NULL;
183 const char *endp = NULL;
184 time_t tstamp = (time_t)0;
185 struct smb2_create_blobs *cblobs = NULL;
186
187 req = tevent_req_create(mem_ctx, &state,
188 struct cli_smb2_create_fnum_state);
189 if (req == NULL) {
190 return NULL;
191 }
192 state->cli = cli;
193
194 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
195 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
196 return tevent_req_post(req, ev);
197 }
198
199 if (cli->backup_intent) {
200 create_options |= FILE_OPEN_FOR_BACKUP_INTENT;
201 }
202
203 /* Check for @GMT- paths. Remove the @GMT and turn into TWrp if so. */
204 fname_len = strlen(fname);
205 if (clistr_is_previous_version_path(fname, &startp, &endp, &tstamp)) {
206 size_t len_before_gmt = startp - fname;
207 size_t len_after_gmt = fname + fname_len - endp;
208 DATA_BLOB twrp_blob;
209 NTTIME ntt;
210 NTSTATUS status;
211
212 char *new_fname = talloc_array(state, char,
213 len_before_gmt + len_after_gmt + 1);
214
215 if (tevent_req_nomem(new_fname, req)) {
216 return tevent_req_post(req, ev);
217 }
218
219 memcpy(new_fname, fname, len_before_gmt);
220 memcpy(new_fname + len_before_gmt, endp, len_after_gmt + 1);
221 fname = new_fname;
222 fname_len = len_before_gmt + len_after_gmt;
223
224 unix_to_nt_time(&ntt, tstamp);
225 twrp_blob = data_blob_const((const void *)&ntt, 8);
226
227 cblobs = talloc_zero(state, struct smb2_create_blobs);
228 if (tevent_req_nomem(cblobs, req)) {
229 return tevent_req_post(req, ev);
230 }
231
232 status = smb2_create_blob_add(state, cblobs,
233 SMB2_CREATE_TAG_TWRP, twrp_blob);
234 if (!NT_STATUS_IS_OK(status)) {
235 tevent_req_nterror(req, status);
236 return tevent_req_post(req, ev);
237 }
238 }
239
240 /* SMB2 is pickier about pathnames. Ensure it doesn't
241 start in a '\' */
242 if (*fname == '\\') {
243 fname++;
244 fname_len--;
245 }
246
247 /* Or end in a '\' */
248 if (fname_len > 0 && fname[fname_len-1] == '\\') {
249 char *new_fname = talloc_strdup(state, fname);
250 if (tevent_req_nomem(new_fname, req)) {
251 return tevent_req_post(req, ev);
252 }
253 new_fname[fname_len-1] = '\0';
254 fname = new_fname;
255 }
256
257 subreq = smb2cli_create_send(state, ev,
258 cli->conn,
259 cli->timeout,
260 cli->smb2.session,
261 cli->smb2.tcon,
262 fname,
263 flags_to_smb2_oplock(create_flags),
264 SMB2_IMPERSONATION_IMPERSONATION,
265 desired_access,
266 file_attributes,
267 share_access,
268 create_disposition,
269 create_options,
270 cblobs);
271 if (tevent_req_nomem(subreq, req)) {
272 return tevent_req_post(req, ev);
273 }
274 tevent_req_set_callback(subreq, cli_smb2_create_fnum_done, req);
275
276 state->subreq = subreq;
277 tevent_req_set_cancel_fn(req, cli_smb2_create_fnum_cancel);
278
279 return req;
280 }
281
282 static void cli_smb2_create_fnum_done(struct tevent_req *subreq)
283 {
284 struct tevent_req *req = tevent_req_callback_data(
285 subreq, struct tevent_req);
286 struct cli_smb2_create_fnum_state *state = tevent_req_data(
287 req, struct cli_smb2_create_fnum_state);
288 struct smb2_hnd h;
289 NTSTATUS status;
290
291 status = smb2cli_create_recv(subreq, &h.fid_persistent,
292 &h.fid_volatile, &state->cr, NULL, NULL);
293 TALLOC_FREE(subreq);
294 if (tevent_req_nterror(req, status)) {
295 return;
296 }
297
298 status = map_smb2_handle_to_fnum(state->cli, &h, &state->fnum);
299 if (tevent_req_nterror(req, status)) {
300 return;
301 }
302 tevent_req_done(req);
303 }
304
305 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req)
306 {
307 struct cli_smb2_create_fnum_state *state = tevent_req_data(
308 req, struct cli_smb2_create_fnum_state);
309 return tevent_req_cancel(state->subreq);
310 }
311
312 NTSTATUS cli_smb2_create_fnum_recv(struct tevent_req *req, uint16_t *pfnum,
313 struct smb_create_returns *cr)
314 {
315 struct cli_smb2_create_fnum_state *state = tevent_req_data(
316 req, struct cli_smb2_create_fnum_state);
317 NTSTATUS status;
318
319 if (tevent_req_is_nterror(req, &status)) {
320 state->cli->raw_status = status;
321 return status;
322 }
323 if (pfnum != NULL) {
324 *pfnum = state->fnum;
325 }
326 if (cr != NULL) {
327 *cr = state->cr;
328 }
329 state->cli->raw_status = NT_STATUS_OK;
330 return NT_STATUS_OK;
331 }
332
333 NTSTATUS cli_smb2_create_fnum(struct cli_state *cli,
334 const char *fname,
335 uint32_t create_flags,
336 uint32_t desired_access,
337 uint32_t file_attributes,
338 uint32_t share_access,
339 uint32_t create_disposition,
340 uint32_t create_options,
341 uint16_t *pfid,
342 struct smb_create_returns *cr)
343 {
344 TALLOC_CTX *frame = talloc_stackframe();
345 struct tevent_context *ev;
346 struct tevent_req *req;
347 NTSTATUS status = NT_STATUS_NO_MEMORY;
348
349 if (smbXcli_conn_has_async_calls(cli->conn)) {
350 /*
351 * Can't use sync call while an async call is in flight
352 */
353 status = NT_STATUS_INVALID_PARAMETER;
354 goto fail;
355 }
356 ev = samba_tevent_context_init(frame);
357 if (ev == NULL) {
358 goto fail;
359 }
360 req = cli_smb2_create_fnum_send(frame, ev, cli, fname, create_flags,
361 desired_access, file_attributes,
362 share_access, create_disposition,
363 create_options);
364 if (req == NULL) {
365 goto fail;
366 }
367 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
368 goto fail;
369 }
370 status = cli_smb2_create_fnum_recv(req, pfid, cr);
371 fail:
372 TALLOC_FREE(frame);
373 return status;
374 }
375
376 /***************************************************************
377 Small wrapper that allows SMB2 close to use a uint16_t fnum.
378 ***************************************************************/
379
380 struct cli_smb2_close_fnum_state {
381 struct cli_state *cli;
382 uint16_t fnum;
383 struct smb2_hnd *ph;
384 };
385
386 static void cli_smb2_close_fnum_done(struct tevent_req *subreq);
387
388 struct tevent_req *cli_smb2_close_fnum_send(TALLOC_CTX *mem_ctx,
389 struct tevent_context *ev,
390 struct cli_state *cli,
391 uint16_t fnum)
392 {
393 struct tevent_req *req, *subreq;
394 struct cli_smb2_close_fnum_state *state;
395 NTSTATUS status;
396
397 req = tevent_req_create(mem_ctx, &state,
398 struct cli_smb2_close_fnum_state);
399 if (req == NULL) {
400 return NULL;
401 }
402 state->cli = cli;
403 state->fnum = fnum;
404
405 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
406 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
407 return tevent_req_post(req, ev);
408 }
409
410 status = map_fnum_to_smb2_handle(cli, fnum, &state->ph);
411 if (tevent_req_nterror(req, status)) {
412 return tevent_req_post(req, ev);
413 }
414
415 subreq = smb2cli_close_send(state, ev, cli->conn, cli->timeout,
416 cli->smb2.session, cli->smb2.tcon,
417 0, state->ph->fid_persistent,
418 state->ph->fid_volatile);
419 if (tevent_req_nomem(subreq, req)) {
420 return tevent_req_post(req, ev);
421 }
422 tevent_req_set_callback(subreq, cli_smb2_close_fnum_done, req);
423 return req;
424 }
425
426 static void cli_smb2_close_fnum_done(struct tevent_req *subreq)
427 {
428 struct tevent_req *req = tevent_req_callback_data(
429 subreq, struct tevent_req);
430 struct cli_smb2_close_fnum_state *state = tevent_req_data(
431 req, struct cli_smb2_close_fnum_state);
432 NTSTATUS status;
433
434 status = smb2cli_close_recv(subreq);
435 if (tevent_req_nterror(req, status)) {
436 return;
437 }
438
439 /* Delete the fnum -> handle mapping. */
440 status = delete_smb2_handle_mapping(state->cli, &state->ph,
441 state->fnum);
442 if (tevent_req_nterror(req, status)) {
443 return;
444 }
445 tevent_req_done(req);
446 }
447
448 NTSTATUS cli_smb2_close_fnum_recv(struct tevent_req *req)
449 {
450 struct cli_smb2_close_fnum_state *state = tevent_req_data(
451 req, struct cli_smb2_close_fnum_state);
452 NTSTATUS status = tevent_req_simple_recv_ntstatus(req);
453 state->cli->raw_status = status;
454 return status;
455 }
456
457 NTSTATUS cli_smb2_close_fnum(struct cli_state *cli, uint16_t fnum)
458 {
459 TALLOC_CTX *frame = talloc_stackframe();
460 struct tevent_context *ev;
461 struct tevent_req *req;
462 NTSTATUS status = NT_STATUS_NO_MEMORY;
463
464 if (smbXcli_conn_has_async_calls(cli->conn)) {
465 /*
466 * Can't use sync call while an async call is in flight
467 */
468 status = NT_STATUS_INVALID_PARAMETER;
469 goto fail;
470 }
471 ev = samba_tevent_context_init(frame);
472 if (ev == NULL) {
473 goto fail;
474 }
475 req = cli_smb2_close_fnum_send(frame, ev, cli, fnum);
476 if (req == NULL) {
477 goto fail;
478 }
479 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
480 goto fail;
481 }
482 status = cli_smb2_close_fnum_recv(req);
483 fail:
484 TALLOC_FREE(frame);
485 return status;
486 }
487
488 /***************************************************************
489 Small wrapper that allows SMB2 to create a directory
490 Synchronous only.
491 ***************************************************************/
492
493 NTSTATUS cli_smb2_mkdir(struct cli_state *cli, const char *dname)
494 {
495 NTSTATUS status;
496 uint16_t fnum;
497
498 if (smbXcli_conn_has_async_calls(cli->conn)) {
499 /*
500 * Can't use sync call while an async call is in flight
501 */
502 return NT_STATUS_INVALID_PARAMETER;
503 }
504
505 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
506 return NT_STATUS_INVALID_PARAMETER;
507 }
508
509 status = cli_smb2_create_fnum(cli,
510 dname,
511 0, /* create_flags */
512 FILE_READ_ATTRIBUTES, /* desired_access */
513 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
514 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
515 FILE_CREATE, /* create_disposition */
516 FILE_DIRECTORY_FILE, /* create_options */
517 &fnum,
518 NULL);
519
520 if (!NT_STATUS_IS_OK(status)) {
521 return status;
522 }
523 return cli_smb2_close_fnum(cli, fnum);
524 }
525
526 /***************************************************************
527 Small wrapper that allows SMB2 to delete a directory
528 Synchronous only.
529 ***************************************************************/
530
531 NTSTATUS cli_smb2_rmdir(struct cli_state *cli, const char *dname)
532 {
533 NTSTATUS status;
534 uint16_t fnum;
535
536 if (smbXcli_conn_has_async_calls(cli->conn)) {
537 /*
538 * Can't use sync call while an async call is in flight
539 */
540 return NT_STATUS_INVALID_PARAMETER;
541 }
542
543 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
544 return NT_STATUS_INVALID_PARAMETER;
545 }
546
547 status = cli_smb2_create_fnum(cli,
548 dname,
549 0, /* create_flags */
550 DELETE_ACCESS, /* desired_access */
551 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
552 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
553 FILE_OPEN, /* create_disposition */
554 FILE_DIRECTORY_FILE|FILE_DELETE_ON_CLOSE, /* create_options */
555 &fnum,
556 NULL);
557
558 if (!NT_STATUS_IS_OK(status)) {
559 return status;
560 }
561 return cli_smb2_close_fnum(cli, fnum);
562 }
563
564 /***************************************************************
565 Small wrapper that allows SMB2 to unlink a pathname.
566 Synchronous only.
567 ***************************************************************/
568
569 NTSTATUS cli_smb2_unlink(struct cli_state *cli, const char *fname)
570 {
571 NTSTATUS status;
572 uint16_t fnum;
573
574 if (smbXcli_conn_has_async_calls(cli->conn)) {
575 /*
576 * Can't use sync call while an async call is in flight
577 */
578 return NT_STATUS_INVALID_PARAMETER;
579 }
580
581 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
582 return NT_STATUS_INVALID_PARAMETER;
583 }
584
585 status = cli_smb2_create_fnum(cli,
586 fname,
587 0, /* create_flags */
588 DELETE_ACCESS, /* desired_access */
589 FILE_ATTRIBUTE_NORMAL, /* file attributes */
590 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
591 FILE_OPEN, /* create_disposition */
592 FILE_DELETE_ON_CLOSE, /* create_options */
593 &fnum,
594 NULL);
595
596 if (!NT_STATUS_IS_OK(status)) {
597 return status;
598 }
599 return cli_smb2_close_fnum(cli, fnum);
600 }
601
602 /***************************************************************
603 Utility function to parse a SMB2_FIND_ID_BOTH_DIRECTORY_INFO reply.
604 ***************************************************************/
605
606 static NTSTATUS parse_finfo_id_both_directory_info(uint8_t *dir_data,
607 uint32_t dir_data_length,
608 struct file_info *finfo,
609 uint32_t *next_offset)
610 {
611 size_t namelen = 0;
612 size_t slen = 0;
613 size_t ret = 0;
614
615 if (dir_data_length < 4) {
616 return NT_STATUS_INFO_LENGTH_MISMATCH;
617 }
618
619 *next_offset = IVAL(dir_data, 0);
620
621 if (*next_offset > dir_data_length) {
622 return NT_STATUS_INFO_LENGTH_MISMATCH;
623 }
624
625 if (*next_offset != 0) {
626 /* Ensure we only read what in this record. */
627 dir_data_length = *next_offset;
628 }
629
630 if (dir_data_length < 105) {
631 return NT_STATUS_INFO_LENGTH_MISMATCH;
632 }
633
634 finfo->atime_ts = interpret_long_date((const char *)dir_data + 16);
635 finfo->mtime_ts = interpret_long_date((const char *)dir_data + 24);
636 finfo->ctime_ts = interpret_long_date((const char *)dir_data + 32);
637 finfo->size = IVAL2_TO_SMB_BIG_UINT(dir_data + 40, 0);
638 finfo->mode = CVAL(dir_data + 56, 0);
639 namelen = IVAL(dir_data + 60,0);
640 if (namelen > (dir_data_length - 104)) {
641 return NT_STATUS_INFO_LENGTH_MISMATCH;
642 }
643 slen = CVAL(dir_data + 68, 0);
644 if (slen > 24) {
645 return NT_STATUS_INFO_LENGTH_MISMATCH;
646 }
647 ret = pull_string_talloc(finfo,
648 dir_data,
649 FLAGS2_UNICODE_STRINGS,
650 &finfo->short_name,
651 dir_data + 70,
652 slen,
653 STR_UNICODE);
654 if (ret == (size_t)-1) {
655 /* Bad conversion. */
656 return NT_STATUS_INVALID_NETWORK_RESPONSE;
657 }
658
659 ret = pull_string_talloc(finfo,
660 dir_data,
661 FLAGS2_UNICODE_STRINGS,
662 &finfo->name,
663 dir_data + 104,
664 namelen,
665 STR_UNICODE);
666 if (ret == (size_t)-1) {
667 /* Bad conversion. */
668 return NT_STATUS_INVALID_NETWORK_RESPONSE;
669 }
670 return NT_STATUS_OK;
671 }
672
673 /*******************************************************************
674 Given a filename - get its directory name
675 ********************************************************************/
676
677 static bool windows_parent_dirname(TALLOC_CTX *mem_ctx,
678 const char *dir,
679 char **parent,
680 const char **name)
681 {
682 char *p;
683 ptrdiff_t len;
684
685 p = strrchr_m(dir, '\\'); /* Find final '\\', if any */
686
687 if (p == NULL) {
688 if (!(*parent = talloc_strdup(mem_ctx, "\\"))) {
689 return false;
690 }
691 if (name) {
692 *name = dir;
693 }
694 return true;
695 }
696
697 len = p-dir;
698
699 if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
700 return false;
701 }
702 (*parent)[len] = '\0';
703
704 if (name) {
705 *name = p+1;
706 }
707 return true;
708 }
709
710 /***************************************************************
711 Wrapper that allows SMB2 to list a directory.
712 Synchronous only.
713 ***************************************************************/
714
715 NTSTATUS cli_smb2_list(struct cli_state *cli,
716 const char *pathname,
717 uint16_t attribute,
718 NTSTATUS (*fn)(const char *,
719 struct file_info *,
720 const char *,
721 void *),
722 void *state)
723 {
724 NTSTATUS status;
725 uint16_t fnum = 0xffff;
726 char *parent_dir = NULL;
727 const char *mask = NULL;
728 struct smb2_hnd *ph = NULL;
729 bool processed_file = false;
730 TALLOC_CTX *frame = talloc_stackframe();
731 TALLOC_CTX *subframe = NULL;
732 bool mask_has_wild;
733
734 if (smbXcli_conn_has_async_calls(cli->conn)) {
735 /*
736 * Can't use sync call while an async call is in flight
737 */
738 status = NT_STATUS_INVALID_PARAMETER;
739 goto fail;
740 }
741
742 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
743 status = NT_STATUS_INVALID_PARAMETER;
744 goto fail;
745 }
746
747 /* Get the directory name. */
748 if (!windows_parent_dirname(frame,
749 pathname,
750 &parent_dir,
751 &mask)) {
752 status = NT_STATUS_NO_MEMORY;
753 goto fail;
754 }
755
756 mask_has_wild = ms_has_wild(mask);
757
758 status = cli_smb2_create_fnum(cli,
759 parent_dir,
760 0, /* create_flags */
761 SEC_DIR_LIST|SEC_DIR_READ_ATTRIBUTE,/* desired_access */
762 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
763 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
764 FILE_OPEN, /* create_disposition */
765 FILE_DIRECTORY_FILE, /* create_options */
766 &fnum,
767 NULL);
768
769 if (!NT_STATUS_IS_OK(status)) {
770 goto fail;
771 }
772
773 status = map_fnum_to_smb2_handle(cli,
774 fnum,
775 &ph);
776 if (!NT_STATUS_IS_OK(status)) {
777 goto fail;
778 }
779
780 do {
781 uint8_t *dir_data = NULL;
782 uint32_t dir_data_length = 0;
783 uint32_t next_offset = 0;
784 subframe = talloc_stackframe();
785
786 status = smb2cli_query_directory(cli->conn,
787 cli->timeout,
788 cli->smb2.session,
789 cli->smb2.tcon,
790 SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
791 0, /* flags */
792 0, /* file_index */
793 ph->fid_persistent,
794 ph->fid_volatile,
795 mask,
796 0xffff,
797 subframe,
798 &dir_data,
799 &dir_data_length);
800
801 if (!NT_STATUS_IS_OK(status)) {
802 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
803 break;
804 }
805 goto fail;
806 }
807
808 do {
809 struct file_info *finfo = talloc_zero(subframe,
810 struct file_info);
811
812 if (finfo == NULL) {
813 status = NT_STATUS_NO_MEMORY;
814 goto fail;
815 }
816
817 status = parse_finfo_id_both_directory_info(dir_data,
818 dir_data_length,
819 finfo,
820 &next_offset);
821
822 if (!NT_STATUS_IS_OK(status)) {
823 goto fail;
824 }
825
826 if (dir_check_ftype((uint32_t)finfo->mode,
827 (uint32_t)attribute)) {
828 /*
829 * Only process if attributes match.
830 * On SMB1 server does this, so on
831 * SMB2 we need to emulate in the
832 * client.
833 *
834 * https://bugzilla.samba.org/show_bug.cgi?id=10260
835 */
836 processed_file = true;
837
838 status = fn(cli->dfs_mountpoint,
839 finfo,
840 pathname,
841 state);
842
843 if (!NT_STATUS_IS_OK(status)) {
844 break;
845 }
846 }
847
848 TALLOC_FREE(finfo);
849
850 /* Move to next entry. */
851 if (next_offset) {
852 dir_data += next_offset;
853 dir_data_length -= next_offset;
854 }
855 } while (next_offset != 0);
856
857 TALLOC_FREE(subframe);
858
859 if (!mask_has_wild) {
860 /*
861 * MacOSX 10 doesn't set STATUS_NO_MORE_FILES
862 * when handed a non-wildcard path. Do it
863 * for the server (with a non-wildcard path
864 * there should only ever be one file returned.
865 */
866 status = STATUS_NO_MORE_FILES;
867 break;
868 }
869
870 } while (NT_STATUS_IS_OK(status));
871
872 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
873 status = NT_STATUS_OK;
874 }
875
876 if (NT_STATUS_IS_OK(status) && !processed_file) {
877 /*
878 * In SMB1 findfirst returns NT_STATUS_NO_SUCH_FILE
879 * if no files match. Emulate this in the client.
880 */
881 status = NT_STATUS_NO_SUCH_FILE;
882 }
883
884 fail:
885
886 if (fnum != 0xffff) {
887 cli_smb2_close_fnum(cli, fnum);
888 }
889 TALLOC_FREE(subframe);
890 TALLOC_FREE(frame);
891 return status;
892 }
893
894 /***************************************************************
895 Wrapper that allows SMB2 to query a path info (basic level).
896 Synchronous only.
897 ***************************************************************/
898
899 NTSTATUS cli_smb2_qpathinfo_basic(struct cli_state *cli,
900 const char *name,
901 SMB_STRUCT_STAT *sbuf,
902 uint32_t *attributes)
903 {
904 NTSTATUS status;
905 struct smb_create_returns cr;
906 uint16_t fnum = 0xffff;
907 size_t namelen = strlen(name);
908
909 if (smbXcli_conn_has_async_calls(cli->conn)) {
910 /*
911 * Can't use sync call while an async call is in flight
912 */
913 return NT_STATUS_INVALID_PARAMETER;
914 }
915
916 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
917 return NT_STATUS_INVALID_PARAMETER;
918 }
919
920 /* SMB2 is pickier about pathnames. Ensure it doesn't
921 end in a '\' */
922 if (namelen > 0 && name[namelen-1] == '\\') {
923 char *modname = talloc_strdup(talloc_tos(), name);
924 modname[namelen-1] = '\0';
925 name = modname;
926 }
927
928 /* This is commonly used as a 'cd'. Try qpathinfo on
929 a directory handle first. */
930
931 status = cli_smb2_create_fnum(cli,
932 name,
933 0, /* create_flags */
934 FILE_READ_ATTRIBUTES, /* desired_access */
935 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
936 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
937 FILE_OPEN, /* create_disposition */
938 FILE_DIRECTORY_FILE, /* create_options */
939 &fnum,
940 &cr);
941
942 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
943 /* Maybe a file ? */
944 status = cli_smb2_create_fnum(cli,
945 name,
946 0, /* create_flags */
947 FILE_READ_ATTRIBUTES, /* desired_access */
948 0, /* file attributes */
949 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
950 FILE_OPEN, /* create_disposition */
951 0, /* create_options */
952 &fnum,
953 &cr);
954 }
955
956 if (!NT_STATUS_IS_OK(status)) {
957 return status;
958 }
959
960 cli_smb2_close_fnum(cli, fnum);
961
962 ZERO_STRUCTP(sbuf);
963
964 sbuf->st_ex_atime = nt_time_to_unix_timespec(cr.last_access_time);
965 sbuf->st_ex_mtime = nt_time_to_unix_timespec(cr.last_write_time);
966 sbuf->st_ex_ctime = nt_time_to_unix_timespec(cr.change_time);
967 sbuf->st_ex_size = cr.end_of_file;
968 *attributes = cr.file_attributes;
969
970 return NT_STATUS_OK;
971 }
972
973 /***************************************************************
974 Helper function for pathname operations.
975 ***************************************************************/
976
977 static NTSTATUS get_fnum_from_path(struct cli_state *cli,
978 const char *name,
979 uint32_t desired_access,
980 uint16_t *pfnum)
981 {
982 NTSTATUS status;
983 size_t namelen = strlen(name);
984 TALLOC_CTX *frame = talloc_stackframe();
985
986 /* SMB2 is pickier about pathnames. Ensure it doesn't
987 end in a '\' */
988 if (namelen > 0 && name[namelen-1] == '\\') {
989 char *modname = talloc_strdup(frame, name);
990 if (modname == NULL) {
991 status = NT_STATUS_NO_MEMORY;
992 goto fail;
993 }
994 modname[namelen-1] = '\0';
995 name = modname;
996 }
997
998 /* Try to open a file handle first. */
999 status = cli_smb2_create_fnum(cli,
1000 name,
1001 0, /* create_flags */
1002 desired_access,
1003 0, /* file attributes */
1004 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1005 FILE_OPEN, /* create_disposition */
1006 0, /* create_options */
1007 pfnum,
1008 NULL);
1009
1010 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
1011 status = cli_smb2_create_fnum(cli,
1012 name,
1013 0, /* create_flags */
1014 desired_access,
1015 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1016 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1017 FILE_OPEN, /* create_disposition */
1018 FILE_DIRECTORY_FILE, /* create_options */
1019 pfnum,
1020 NULL);
1021 }
1022
1023 fail:
1024
1025 TALLOC_FREE(frame);
1026 return status;
1027 }
1028
1029 /***************************************************************
1030 Wrapper that allows SMB2 to query a path info (ALTNAME level).
1031 Synchronous only.
1032 ***************************************************************/
1033
1034 NTSTATUS cli_smb2_qpathinfo_alt_name(struct cli_state *cli,
1035 const char *name,
1036 fstring alt_name)
1037 {
1038 NTSTATUS status;
1039 DATA_BLOB outbuf = data_blob_null;
1040 uint16_t fnum = 0xffff;
1041 struct smb2_hnd *ph = NULL;
1042 uint32_t altnamelen = 0;
1043 TALLOC_CTX *frame = talloc_stackframe();
1044
1045 if (smbXcli_conn_has_async_calls(cli->conn)) {
1046 /*
1047 * Can't use sync call while an async call is in flight
1048 */
1049 status = NT_STATUS_INVALID_PARAMETER;
1050 goto fail;
1051 }
1052
1053 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1054 status = NT_STATUS_INVALID_PARAMETER;
1055 goto fail;
1056 }
1057
1058 status = get_fnum_from_path(cli,
1059 name,
1060 FILE_READ_ATTRIBUTES,
1061 &fnum);
1062
1063 if (!NT_STATUS_IS_OK(status)) {
1064 goto fail;
1065 }
1066
1067 status = map_fnum_to_smb2_handle(cli,
1068 fnum,
1069 &ph);
1070 if (!NT_STATUS_IS_OK(status)) {
1071 goto fail;
1072 }
1073
1074 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1075 level SMB_FILE_ALTERNATE_NAME_INFORMATION (1021) == SMB2 21 */
1076
1077 status = smb2cli_query_info(cli->conn,
1078 cli->timeout,
1079 cli->smb2.session,
1080 cli->smb2.tcon,
1081 1, /* in_info_type */
1082 (SMB_FILE_ALTERNATE_NAME_INFORMATION - 1000), /* in_file_info_class */
1083 0xFFFF, /* in_max_output_length */
1084 NULL, /* in_input_buffer */
1085 0, /* in_additional_info */
1086 0, /* in_flags */
1087 ph->fid_persistent,
1088 ph->fid_volatile,
1089 frame,
1090 &outbuf);
1091
1092 if (!NT_STATUS_IS_OK(status)) {
1093 goto fail;
1094 }
1095
1096 /* Parse the reply. */
1097 if (outbuf.length < 4) {
1098 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1099 goto fail;
1100 }
1101
1102 altnamelen = IVAL(outbuf.data, 0);
1103 if (altnamelen > outbuf.length - 4) {
1104 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1105 goto fail;
1106 }
1107
1108 if (altnamelen > 0) {
1109 size_t ret = 0;
1110 char *short_name = NULL;
1111 ret = pull_string_talloc(frame,
1112 outbuf.data,
1113 FLAGS2_UNICODE_STRINGS,
1114 &short_name,
1115 outbuf.data + 4,
1116 altnamelen,
1117 STR_UNICODE);
1118 if (ret == (size_t)-1) {
1119 /* Bad conversion. */
1120 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1121 goto fail;
1122 }
1123
1124 fstrcpy(alt_name, short_name);
1125 } else {
1126 alt_name[0] = '\0';
1127 }
1128
1129 status = NT_STATUS_OK;
1130
1131 fail:
1132
1133 if (fnum != 0xffff) {
1134 cli_smb2_close_fnum(cli, fnum);
1135 }
1136 TALLOC_FREE(frame);
1137 return status;
1138 }
1139
1140
1141 /***************************************************************
1142 Wrapper that allows SMB2 to query a fnum info (basic level).
1143 Synchronous only.
1144 ***************************************************************/
1145
1146 NTSTATUS cli_smb2_qfileinfo_basic(struct cli_state *cli,
1147 uint16_t fnum,
1148 uint16_t *mode,
1149 off_t *size,
1150 struct timespec *create_time,
1151 struct timespec *access_time,
1152 struct timespec *write_time,
1153 struct timespec *change_time,
1154 SMB_INO_T *ino)
1155 {
1156 NTSTATUS status;
1157 DATA_BLOB outbuf = data_blob_null;
1158 struct smb2_hnd *ph = NULL;
1159 TALLOC_CTX *frame = talloc_stackframe();
1160
1161 if (smbXcli_conn_has_async_calls(cli->conn)) {
1162 /*
1163 * Can't use sync call while an async call is in flight
1164 */
1165 status = NT_STATUS_INVALID_PARAMETER;
1166 goto fail;
1167 }
1168
1169 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1170 status = NT_STATUS_INVALID_PARAMETER;
1171 goto fail;
1172 }
1173
1174 status = map_fnum_to_smb2_handle(cli,
1175 fnum,
1176 &ph);
1177 if (!NT_STATUS_IS_OK(status)) {
1178 goto fail;
1179 }
1180
1181 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1182 level 0x12 (SMB2_FILE_ALL_INFORMATION). */
1183
1184 status = smb2cli_query_info(cli->conn,
1185 cli->timeout,
1186 cli->smb2.session,
1187 cli->smb2.tcon,
1188 1, /* in_info_type */
1189 (SMB_FILE_ALL_INFORMATION - 1000), /* in_file_info_class */
1190 0xFFFF, /* in_max_output_length */
1191 NULL, /* in_input_buffer */
1192 0, /* in_additional_info */
1193 0, /* in_flags */
1194 ph->fid_persistent,
1195 ph->fid_volatile,
1196 frame,
1197 &outbuf);
1198 if (!NT_STATUS_IS_OK(status)) {
1199 goto fail;
1200 }
1201
1202 /* Parse the reply. */
1203 if (outbuf.length < 0x60) {
1204 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1205 goto fail;
1206 }
1207
1208 if (create_time) {
1209 *create_time = interpret_long_date((const char *)outbuf.data + 0x0);
1210 }
1211 if (access_time) {
1212 *access_time = interpret_long_date((const char *)outbuf.data + 0x8);
1213 }
1214 if (write_time) {
1215 *write_time = interpret_long_date((const char *)outbuf.data + 0x10);
1216 }
1217 if (change_time) {
1218 *change_time = interpret_long_date((const char *)outbuf.data + 0x18);
1219 }
1220 if (mode) {
1221 uint32_t attr = IVAL(outbuf.data, 0x20);
1222 *mode = (uint16_t)attr;
1223 }
1224 if (size) {
1225 uint64_t file_size = BVAL(outbuf.data, 0x30);
1226 *size = (off_t)file_size;
1227 }
1228 if (ino) {
1229 uint64_t file_index = BVAL(outbuf.data, 0x40);
1230 *ino = (SMB_INO_T)file_index;
1231 }
1232
1233 fail:
1234
1235 TALLOC_FREE(frame);
1236 return status;
1237 }
1238
1239 /***************************************************************
1240 Wrapper that allows SMB2 to query an fnum.
1241 Implement on top of cli_smb2_qfileinfo_basic().
1242 Synchronous only.
1243 ***************************************************************/
1244
1245 NTSTATUS cli_smb2_getattrE(struct cli_state *cli,
1246 uint16_t fnum,
1247 uint16_t *attr,
1248 off_t *size,
1249 time_t *change_time,
1250 time_t *access_time,
1251 time_t *write_time)
1252 {
1253 struct timespec access_time_ts;
1254 struct timespec write_time_ts;
1255 struct timespec change_time_ts;
1256 NTSTATUS status = cli_smb2_qfileinfo_basic(cli,
1257 fnum,
1258 attr,
1259 size,
1260 NULL,
1261 &access_time_ts,
1262 &write_time_ts,
1263 &change_time_ts,
1264 NULL);
1265
1266 if (!NT_STATUS_IS_OK(status)) {
1267 return status;
1268 }
1269
1270 if (change_time) {
1271 *change_time = change_time_ts.tv_sec;
1272 }
1273 if (access_time) {
1274 *access_time = access_time_ts.tv_sec;
1275 }
1276 if (write_time) {
1277 *write_time = write_time_ts.tv_sec;
1278 }
1279 return NT_STATUS_OK;
1280 }
1281
1282 /***************************************************************
1283 Wrapper that allows SMB2 to get pathname attributes.
1284 Synchronous only.
1285 ***************************************************************/
1286
1287 NTSTATUS cli_smb2_getatr(struct cli_state *cli,
1288 const char *name,
1289 uint16_t *attr,
1290 off_t *size,
1291 time_t *write_time)
1292 {
1293 NTSTATUS status;
1294 uint16_t fnum = 0xffff;
1295 struct smb2_hnd *ph = NULL;
1296 TALLOC_CTX *frame = talloc_stackframe();
1297
1298 if (smbXcli_conn_has_async_calls(cli->conn)) {
1299 /*
1300 * Can't use sync call while an async call is in flight
1301 */
1302 status = NT_STATUS_INVALID_PARAMETER;
1303 goto fail;
1304 }
1305
1306 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1307 status = NT_STATUS_INVALID_PARAMETER;
1308 goto fail;
1309 }
1310
1311 status = get_fnum_from_path(cli,
1312 name,
1313 FILE_READ_ATTRIBUTES,
1314 &fnum);
1315
1316 if (!NT_STATUS_IS_OK(status)) {
1317 goto fail;
1318 }
1319
1320 status = map_fnum_to_smb2_handle(cli,
1321 fnum,
1322 &ph);
1323 if (!NT_STATUS_IS_OK(status)) {
1324 goto fail;
1325 }
1326 status = cli_smb2_getattrE(cli,
1327 fnum,
1328 attr,
1329 size,
1330 NULL,
1331 NULL,
1332 write_time);
1333 if (!NT_STATUS_IS_OK(status)) {
1334 goto fail;
1335 }
1336
1337 fail:
1338
1339 if (fnum != 0xffff) {
1340 cli_smb2_close_fnum(cli, fnum);
1341 }
1342
1343 TALLOC_FREE(frame);
1344 return status;
1345 }
1346
1347 /***************************************************************
1348 Wrapper that allows SMB2 to query a pathname info (basic level).
1349 Implement on top of cli_smb2_qfileinfo_basic().
1350 Synchronous only.
1351 ***************************************************************/
1352
1353 NTSTATUS cli_smb2_qpathinfo2(struct cli_state *cli,
1354 const char *name,
1355 struct timespec *create_time,
1356 struct timespec *access_time,
1357 struct timespec *write_time,
1358 struct timespec *change_time,
1359 off_t *size,
1360 uint16_t *mode,
1361 SMB_INO_T *ino)
1362 {
1363 NTSTATUS status;
1364 struct smb2_hnd *ph = NULL;
1365 uint16_t fnum = 0xffff;
1366 TALLOC_CTX *frame = talloc_stackframe();
1367
1368 if (smbXcli_conn_has_async_calls(cli->conn)) {
1369 /*
1370 * Can't use sync call while an async call is in flight
1371 */
1372 status = NT_STATUS_INVALID_PARAMETER;
1373 goto fail;
1374 }
1375
1376 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1377 status = NT_STATUS_INVALID_PARAMETER;
1378 goto fail;
1379 }
1380
1381 status = get_fnum_from_path(cli,
1382 name,
1383 FILE_READ_ATTRIBUTES,
1384 &fnum);
1385
1386 if (!NT_STATUS_IS_OK(status)) {
1387 goto fail;
1388 }
1389
1390 status = map_fnum_to_smb2_handle(cli,
1391 fnum,
1392 &ph);
1393 if (!NT_STATUS_IS_OK(status)) {
1394 goto fail;
1395 }
1396
1397 status = cli_smb2_qfileinfo_basic(cli,
1398 fnum,
1399 mode,
1400 size,
1401 create_time,
1402 access_time,
1403 write_time,
1404 change_time,
1405 ino);
1406
1407 fail:
1408
1409 if (fnum != 0xffff) {
1410 cli_smb2_close_fnum(cli, fnum);
1411 }
1412
1413 TALLOC_FREE(frame);
1414 return status;
1415 }
1416
1417 /***************************************************************
1418 Wrapper that allows SMB2 to query pathname streams.
1419 Synchronous only.
1420 ***************************************************************/
1421
1422 NTSTATUS cli_smb2_qpathinfo_streams(struct cli_state *cli,
1423 const char *name,
1424 TALLOC_CTX *mem_ctx,
1425 unsigned int *pnum_streams,
1426 struct stream_struct **pstreams)
1427 {
1428 NTSTATUS status;
1429 struct smb2_hnd *ph = NULL;
1430 uint16_t fnum = 0xffff;
1431 DATA_BLOB outbuf = data_blob_null;
1432 TALLOC_CTX *frame = talloc_stackframe();
1433
1434 if (smbXcli_conn_has_async_calls(cli->conn)) {
1435 /*
1436 * Can't use sync call while an async call is in flight
1437 */
1438 status = NT_STATUS_INVALID_PARAMETER;
1439 goto fail;
1440 }
1441
1442 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1443 status = NT_STATUS_INVALID_PARAMETER;
1444 goto fail;
1445 }
1446
1447 status = get_fnum_from_path(cli,
1448 name,
1449 FILE_READ_ATTRIBUTES,
1450 &fnum);
1451
1452 if (!NT_STATUS_IS_OK(status)) {
1453 goto fail;
1454 }
1455
1456 status = map_fnum_to_smb2_handle(cli,
1457 fnum,
1458 &ph);
1459 if (!NT_STATUS_IS_OK(status)) {
1460 goto fail;
1461 }
1462
1463 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1464 level 22 (SMB2_FILE_STREAM_INFORMATION). */
1465
1466 status = smb2cli_query_info(cli->conn,
1467 cli->timeout,
1468 cli->smb2.session,
1469 cli->smb2.tcon,
1470 1, /* in_info_type */
1471 (SMB_FILE_STREAM_INFORMATION - 1000), /* in_file_info_class */
1472 0xFFFF, /* in_max_output_length */
1473 NULL, /* in_input_buffer */
1474 0, /* in_additional_info */
1475 0, /* in_flags */
1476 ph->fid_persistent,
1477 ph->fid_volatile,
1478 frame,
1479 &outbuf);
1480
1481 if (!NT_STATUS_IS_OK(status)) {
1482 goto fail;
1483 }
1484
1485 /* Parse the reply. */
1486 if (!parse_streams_blob(mem_ctx,
1487 outbuf.data,
1488 outbuf.length,
1489 pnum_streams,
1490 pstreams)) {
1491 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1492 goto fail;
1493 }
1494
1495 fail:
1496
1497 if (fnum != 0xffff) {
1498 cli_smb2_close_fnum(cli, fnum);
1499 }
1500
1501 TALLOC_FREE(frame);
1502 return status;
1503 }
1504
1505 /***************************************************************
1506 Wrapper that allows SMB2 to set pathname attributes.
1507 Synchronous only.
1508 ***************************************************************/
1509
1510 NTSTATUS cli_smb2_setatr(struct cli_state *cli,
1511 const char *name,
1512 uint16_t attr,
1513 time_t mtime)
1514 {
1515 NTSTATUS status;
1516 uint16_t fnum = 0xffff;
1517 struct smb2_hnd *ph = NULL;
1518 uint8_t inbuf_store[40];
1519 DATA_BLOB inbuf = data_blob_null;
1520 TALLOC_CTX *frame = talloc_stackframe();
1521
1522 if (smbXcli_conn_has_async_calls(cli->conn)) {
1523 /*
1524 * Can't use sync call while an async call is in flight
1525 */
1526 status = NT_STATUS_INVALID_PARAMETER;
1527 goto fail;
1528 }
1529
1530 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1531 status = NT_STATUS_INVALID_PARAMETER;
1532 goto fail;
1533 }
1534
1535 status = get_fnum_from_path(cli,
1536 name,
1537 FILE_WRITE_ATTRIBUTES,
1538 &fnum);
1539
1540 if (!NT_STATUS_IS_OK(status)) {
1541 goto fail;
1542 }
1543
1544 status = map_fnum_to_smb2_handle(cli,
1545 fnum,
1546 &ph);
1547 if (!NT_STATUS_IS_OK(status)) {
1548 goto fail;
1549 }
1550
1551 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1552 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1553
1554 inbuf.data = inbuf_store;
1555 inbuf.length = sizeof(inbuf_store);
1556 data_blob_clear(&inbuf);
1557
1558 SSVAL(inbuf.data, 32, attr);
1559 if (mtime != 0) {
1560 put_long_date((char *)inbuf.data + 16,mtime);
1561 }
1562 /* Set all the other times to -1. */
1563 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1564 SBVAL(inbuf.data, 8, 0xFFFFFFFFFFFFFFFFLL);
1565 SBVAL(inbuf.data, 24, 0xFFFFFFFFFFFFFFFFLL);
1566
1567 status = smb2cli_set_info(cli->conn,
1568 cli->timeout,
1569 cli->smb2.session,
1570 cli->smb2.tcon,
1571 1, /* in_info_type */
1572 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1573 &inbuf, /* in_input_buffer */
1574 0, /* in_additional_info */
1575 ph->fid_persistent,
1576 ph->fid_volatile);
1577 fail:
1578
1579 if (fnum != 0xffff) {
1580 cli_smb2_close_fnum(cli, fnum);
1581 }
1582
1583 TALLOC_FREE(frame);
1584 return status;
1585 }
1586
1587 /***************************************************************
1588 Wrapper that allows SMB2 to set file handle times.
1589 Synchronous only.
1590 ***************************************************************/
1591
1592 NTSTATUS cli_smb2_setattrE(struct cli_state *cli,
1593 uint16_t fnum,
1594 time_t change_time,
1595 time_t access_time,
1596 time_t write_time)
1597 {
1598 NTSTATUS status;
1599 struct smb2_hnd *ph = NULL;
1600 uint8_t inbuf_store[40];
1601 DATA_BLOB inbuf = data_blob_null;
1602
1603 if (smbXcli_conn_has_async_calls(cli->conn)) {
1604 /*
1605 * Can't use sync call while an async call is in flight
1606 */
1607 return NT_STATUS_INVALID_PARAMETER;
1608 }
1609
1610 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1611 return NT_STATUS_INVALID_PARAMETER;
1612 }
1613
1614 status = map_fnum_to_smb2_handle(cli,
1615 fnum,
1616 &ph);
1617 if (!NT_STATUS_IS_OK(status)) {
1618 return status;
1619 }
1620
1621 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1622 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1623
1624 inbuf.data = inbuf_store;
1625 inbuf.length = sizeof(inbuf_store);
1626 data_blob_clear(&inbuf);
1627
1628 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1629 if (change_time != 0) {
1630 put_long_date((char *)inbuf.data + 24, change_time);
1631 }
1632 if (access_time != 0) {
1633 put_long_date((char *)inbuf.data + 8, access_time);
1634 }
1635 if (write_time != 0) {
1636 put_long_date((char *)inbuf.data + 16, write_time);
1637 }
1638
1639 return smb2cli_set_info(cli->conn,
1640 cli->timeout,
1641 cli->smb2.session,
1642 cli->smb2.tcon,
1643 1, /* in_info_type */
1644 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1645 &inbuf, /* in_input_buffer */
1646 0, /* in_additional_info */
1647 ph->fid_persistent,
1648 ph->fid_volatile);
1649 }
1650
1651 /***************************************************************
1652 Wrapper that allows SMB2 to query disk attributes (size).
1653 Synchronous only.
1654 ***************************************************************/
1655
1656 NTSTATUS cli_smb2_dskattr(struct cli_state *cli, const char *path,
1657 uint64_t *bsize, uint64_t *total, uint64_t *avail)
1658 {
1659 NTSTATUS status;
1660 uint16_t fnum = 0xffff;
1661 DATA_BLOB outbuf = data_blob_null;
1662 struct smb2_hnd *ph = NULL;
1663 uint32_t sectors_per_unit = 0;
1664 uint32_t bytes_per_sector = 0;
1665 uint64_t total_size = 0;
1666 uint64_t size_free = 0;
1667 TALLOC_CTX *frame = talloc_stackframe();
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
1677 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1678 status = NT_STATUS_INVALID_PARAMETER;
1679 goto fail;
1680 }
1681
1682 /* First open the top level directory. */
1683 status = cli_smb2_create_fnum(cli,
1684 path,
1685 0, /* create_flags */
1686 FILE_READ_ATTRIBUTES, /* desired_access */
1687 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1688 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1689 FILE_OPEN, /* create_disposition */
1690 FILE_DIRECTORY_FILE, /* create_options */
1691 &fnum,
1692 NULL);
1693
1694 if (!NT_STATUS_IS_OK(status)) {
1695 goto fail;
1696 }
1697
1698 status = map_fnum_to_smb2_handle(cli,
1699 fnum,
1700 &ph);
1701 if (!NT_STATUS_IS_OK(status)) {
1702 goto fail;
1703 }
1704
1705 /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
1706 level 3 (SMB_FS_SIZE_INFORMATION). */
1707
1708 status = smb2cli_query_info(cli->conn,
1709 cli->timeout,
1710 cli->smb2.session,
1711 cli->smb2.tcon,
1712 2, /* in_info_type */
1713 3, /* in_file_info_class */
1714 0xFFFF, /* in_max_output_length */
1715 NULL, /* in_input_buffer */
1716 0, /* in_additional_info */
1717 0, /* in_flags */
1718 ph->fid_persistent,
1719 ph->fid_volatile,
1720 frame,
1721 &outbuf);
1722 if (!NT_STATUS_IS_OK(status)) {
1723 goto fail;
1724 }
1725
1726 /* Parse the reply. */
1727 if (outbuf.length != 24) {
1728 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1729 goto fail;
1730 }
1731
1732 total_size = BVAL(outbuf.data, 0);
1733 size_free = BVAL(outbuf.data, 8);
1734 sectors_per_unit = IVAL(outbuf.data, 16);
1735 bytes_per_sector = IVAL(outbuf.data, 20);
1736
1737 if (bsize) {
1738 *bsize = (uint64_t)sectors_per_unit * (uint64_t)bytes_per_sector;
1739 }
1740 if (total) {
1741 *total = total_size;
1742 }
1743 if (avail) {
1744 *avail = size_free;
1745 }
1746
1747 status = NT_STATUS_OK;
1748
1749 fail:
1750
1751 if (fnum != 0xffff) {
1752 cli_smb2_close_fnum(cli, fnum);
1753 }
1754
1755 TALLOC_FREE(frame);
1756 return status;
1757 }
1758
1759 /***************************************************************
1760 Wrapper that allows SMB2 to query file system attributes.
1761 Synchronous only.
1762 ***************************************************************/
1763
1764 NTSTATUS cli_smb2_get_fs_attr_info(struct cli_state *cli, uint32_t *fs_attr)
1765 {
1766 NTSTATUS status;
1767 uint16_t fnum = 0xffff;
1768 DATA_BLOB outbuf = data_blob_null;
1769 struct smb2_hnd *ph = NULL;
1770 TALLOC_CTX *frame = talloc_stackframe();
1771
1772 if (smbXcli_conn_has_async_calls(cli->conn)) {
1773 /*
1774 * Can't use sync call while an async call is in flight
1775 */
1776 status = NT_STATUS_INVALID_PARAMETER;
1777 goto fail;
1778 }
1779
1780 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1781 status = NT_STATUS_INVALID_PARAMETER;
1782 goto fail;
1783 }
1784
1785 /* First open the top level directory. */
1786 status =
1787 cli_smb2_create_fnum(cli, "", 0, /* create_flags */
1788 FILE_READ_ATTRIBUTES, /* desired_access */
1789 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1790 FILE_SHARE_READ | FILE_SHARE_WRITE |
1791 FILE_SHARE_DELETE, /* share_access */
1792 FILE_OPEN, /* create_disposition */
1793 FILE_DIRECTORY_FILE, /* create_options */
1794 &fnum,
1795 NULL);
1796
1797 if (!NT_STATUS_IS_OK(status)) {
1798 goto fail;
1799 }
1800
1801 status = map_fnum_to_smb2_handle(cli, fnum, &ph);
1802 if (!NT_STATUS_IS_OK(status)) {
1803 goto fail;
1804 }
1805
1806 status = smb2cli_query_info(cli->conn, cli->timeout, cli->smb2.session,
1807 cli->smb2.tcon, 2, /* in_info_type */
1808 5, /* in_file_info_class */
1809 0xFFFF, /* in_max_output_length */
1810 NULL, /* in_input_buffer */
1811 0, /* in_additional_info */
1812 0, /* in_flags */
1813 ph->fid_persistent, ph->fid_volatile, frame,
1814 &outbuf);
1815 if (!NT_STATUS_IS_OK(status)) {
1816 goto fail;
1817 }
1818
1819 if (outbuf.length < 12) {
1820 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1821 goto fail;
1822 }
1823
1824 *fs_attr = IVAL(outbuf.data, 0);
1825
1826 fail:
1827
1828 if (fnum != 0xffff) {
1829 cli_smb2_close_fnum(cli, fnum);
1830 }
1831
1832 TALLOC_FREE(frame);
1833 return status;
1834 }
1835
1836 /***************************************************************
1837 Wrapper that allows SMB2 to query a security descriptor.
1838 Synchronous only.
1839 ***************************************************************/
1840
1841 NTSTATUS cli_smb2_query_security_descriptor(struct cli_state *cli,
1842 uint16_t fnum,
1843 uint32_t sec_info,
1844 TALLOC_CTX *mem_ctx,
1845 struct security_descriptor **ppsd)
1846 {
1847 NTSTATUS status;
1848 DATA_BLOB outbuf = data_blob_null;
1849 struct smb2_hnd *ph = NULL;
1850 struct security_descriptor *lsd = NULL;
1851 TALLOC_CTX *frame = talloc_stackframe();
1852
1853 if (smbXcli_conn_has_async_calls(cli->conn)) {
1854 /*
1855 * Can't use sync call while an async call is in flight
1856 */
1857 status = NT_STATUS_INVALID_PARAMETER;
1858 goto fail;
1859 }
1860
1861 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1862 status = NT_STATUS_INVALID_PARAMETER;
1863 goto fail;
1864 }
1865
1866 status = map_fnum_to_smb2_handle(cli,
1867 fnum,
1868 &ph);
1869 if (!NT_STATUS_IS_OK(status)) {
1870 goto fail;
1871 }
1872
1873 /* getinfo on the returned handle with info_type SMB2_GETINFO_SEC (3) */
1874
1875 status = smb2cli_query_info(cli->conn,
1876 cli->timeout,
1877 cli->smb2.session,
1878 cli->smb2.tcon,
1879 3, /* in_info_type */
1880 0, /* in_file_info_class */
1881 0xFFFF, /* in_max_output_length */
1882 NULL, /* in_input_buffer */
1883 sec_info, /* in_additional_info */
1884 0, /* in_flags */
1885 ph->fid_persistent,
1886 ph->fid_volatile,
1887 frame,
1888 &outbuf);
1889
1890 if (!NT_STATUS_IS_OK(status)) {
1891 goto fail;
1892 }
1893
1894 /* Parse the reply. */
1895 status = unmarshall_sec_desc(mem_ctx,
1896 outbuf.data,
1897 outbuf.length,
1898 &lsd);
1899
1900 if (!NT_STATUS_IS_OK(status)) {
1901 goto fail;
1902 }
1903
1904 if (ppsd != NULL) {
1905 *ppsd = lsd;
1906 } else {
1907 TALLOC_FREE(lsd);
1908 }
1909
1910 fail:
1911
1912 TALLOC_FREE(frame);
1913 return status;
1914 }
1915
1916 /***************************************************************
1917 Wrapper that allows SMB2 to set a security descriptor.
1918 Synchronous only.
1919 ***************************************************************/
1920
1921 NTSTATUS cli_smb2_set_security_descriptor(struct cli_state *cli,
1922 uint16_t fnum,
1923 uint32_t sec_info,
1924 const struct security_descriptor *sd)
1925 {
1926 NTSTATUS status;
1927 DATA_BLOB inbuf = data_blob_null;
1928 struct smb2_hnd *ph = NULL;
1929 TALLOC_CTX *frame = talloc_stackframe();
1930
1931 if (smbXcli_conn_has_async_calls(cli->conn)) {
1932 /*
1933 * Can't use sync call while an async call is in flight
1934 */
1935 status = NT_STATUS_INVALID_PARAMETER;
1936 goto fail;
1937 }
1938
1939 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1940 status = NT_STATUS_INVALID_PARAMETER;
1941 goto fail;
1942 }
1943
1944 status = map_fnum_to_smb2_handle(cli,
1945 fnum,
1946 &ph);
1947 if (!NT_STATUS_IS_OK(status)) {
1948 goto fail;
1949 }
1950
1951 status = marshall_sec_desc(frame,
1952 sd,
1953 &inbuf.data,
1954 &inbuf.length);
1955
1956 if (!NT_STATUS_IS_OK(status)) {
1957 goto fail;
1958 }
1959
1960 /* setinfo on the returned handle with info_type SMB2_SETINFO_SEC (3) */
1961
1962 status = smb2cli_set_info(cli->conn,
1963 cli->timeout,
1964 cli->smb2.session,
1965 cli->smb2.tcon,
1966 3, /* in_info_type */
1967 0, /* in_file_info_class */
1968 &inbuf, /* in_input_buffer */
1969 sec_info, /* in_additional_info */
1970 ph->fid_persistent,
1971 ph->fid_volatile);
1972
1973 fail:
1974
1975 TALLOC_FREE(frame);
1976 return status;
1977 }
1978
1979 /***************************************************************
1980 Wrapper that allows SMB2 to rename a file.
1981 Synchronous only.
1982 ***************************************************************/
1983
1984 NTSTATUS cli_smb2_rename(struct cli_state *cli,
1985 const char *fname_src,
1986 const char *fname_dst)
1987 {
1988 NTSTATUS status;
1989 DATA_BLOB inbuf = data_blob_null;
1990 uint16_t fnum = 0xffff;
1991 struct smb2_hnd *ph = NULL;
1992 smb_ucs2_t *converted_str = NULL;
1993 size_t converted_size_bytes = 0;
1994 size_t namelen = 0;
1995 TALLOC_CTX *frame = talloc_stackframe();
1996
1997 if (smbXcli_conn_has_async_calls(cli->conn)) {
1998 /*
1999 * Can't use sync call while an async call is in flight
2000 */
2001 status = NT_STATUS_INVALID_PARAMETER;
2002 goto fail;
2003 }
2004
2005 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2006 status = NT_STATUS_INVALID_PARAMETER;
2007 goto fail;
2008 }
2009
2010 status = get_fnum_from_path(cli,
2011 fname_src,
2012 DELETE_ACCESS,
2013 &fnum);
2014
2015 if (!NT_STATUS_IS_OK(status)) {
2016 goto fail;
2017 }
2018
2019 status = map_fnum_to_smb2_handle(cli,
2020 fnum,
2021 &ph);
2022 if (!NT_STATUS_IS_OK(status)) {
2023 goto fail;
2024 }
2025
2026 /* SMB2 is pickier about pathnames. Ensure it doesn't
2027 start in a '\' */
2028 if (*fname_dst == '\\') {
2029 fname_dst++;
2030 }
2031
2032 /* SMB2 is pickier about pathnames. Ensure it doesn't
2033 end in a '\' */
2034 namelen = strlen(fname_dst);
2035 if (namelen > 0 && fname_dst[namelen-1] == '\\') {
2036 char *modname = talloc_strdup(frame, fname_dst);
2037 modname[namelen-1] = '\0';
2038 fname_dst = modname;
2039 }
2040
2041 if (!push_ucs2_talloc(frame,
2042 &converted_str,
2043 fname_dst,
2044 &converted_size_bytes)) {
2045 status = NT_STATUS_INVALID_PARAMETER;
2046 goto fail;
2047 }
2048
2049 /* W2K8 insists the dest name is not null
2050 terminated. Remove the last 2 zero bytes
2051 and reduce the name length. */
2052
2053 if (converted_size_bytes < 2) {
2054 status = NT_STATUS_INVALID_PARAMETER;
2055 goto fail;
2056 }
2057 converted_size_bytes -= 2;
2058
2059 inbuf = data_blob_talloc_zero(frame,
2060 20 + converted_size_bytes);
2061 if (inbuf.data == NULL) {
2062 status = NT_STATUS_NO_MEMORY;
2063 goto fail;
2064 }
2065
2066 SIVAL(inbuf.data, 16, converted_size_bytes);
2067 memcpy(inbuf.data + 20, converted_str, converted_size_bytes);
2068
2069 /* setinfo on the returned handle with info_type SMB2_GETINFO_FILE (1),
2070 level SMB2_FILE_RENAME_INFORMATION (SMB_FILE_RENAME_INFORMATION - 1000) */
2071
2072 status = smb2cli_set_info(cli->conn,
2073 cli->timeout,
2074 cli->smb2.session,
2075 cli->smb2.tcon,
2076 1, /* in_info_type */
2077 SMB_FILE_RENAME_INFORMATION - 1000, /* in_file_info_class */
2078 &inbuf, /* in_input_buffer */
2079 0, /* in_additional_info */
2080 ph->fid_persistent,
2081 ph->fid_volatile);
2082
2083 fail:
2084
2085 if (fnum != 0xffff) {
2086 cli_smb2_close_fnum(cli, fnum);
2087 }
2088
2089 TALLOC_FREE(frame);
2090 return status;
2091 }
2092
2093 /***************************************************************
2094 Wrapper that allows SMB2 to set an EA on a fnum.
2095 Synchronous only.
2096 ***************************************************************/
2097
2098 NTSTATUS cli_smb2_set_ea_fnum(struct cli_state *cli,
2099 uint16_t fnum,
2100 const char *ea_name,
2101 const char *ea_val,
2102 size_t ea_len)
2103 {
2104 NTSTATUS status;
2105 DATA_BLOB inbuf = data_blob_null;
2106 size_t bloblen = 0;
2107 char *ea_name_ascii = NULL;
2108 size_t namelen = 0;
2109 struct smb2_hnd *ph = NULL;
2110 TALLOC_CTX *frame = talloc_stackframe();
2111
2112 if (smbXcli_conn_has_async_calls(cli->conn)) {
2113 /*
2114 * Can't use sync call while an async call is in flight
2115 */
2116 status = NT_STATUS_INVALID_PARAMETER;
2117 goto fail;
2118 }
2119
2120 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2121 status = NT_STATUS_INVALID_PARAMETER;
2122 goto fail;
2123 }
2124
2125 status = map_fnum_to_smb2_handle(cli,
2126 fnum,
2127 &ph);
2128 if (!NT_STATUS_IS_OK(status)) {
2129 goto fail;
2130 }
2131
2132 /* Marshall the SMB2 EA data. */
2133 if (ea_len > 0xFFFF) {
2134 status = NT_STATUS_INVALID_PARAMETER;
2135 goto fail;
2136 }
2137
2138 if (!push_ascii_talloc(frame,
2139 &ea_name_ascii,
2140 ea_name,
2141 &namelen)) {
2142 status = NT_STATUS_INVALID_PARAMETER;
2143 goto fail;
2144 }
2145
2146 if (namelen < 2 || namelen > 0xFF) {
2147 status = NT_STATUS_INVALID_PARAMETER;
2148 goto fail;
2149 }
2150
2151 bloblen = 8 + ea_len + namelen;
2152 /* Round up to a 4 byte boundary. */
2153 bloblen = ((bloblen + 3)&~3);
2154
2155 inbuf = data_blob_talloc_zero(frame, bloblen);
2156 if (inbuf.data == NULL) {
2157 status = NT_STATUS_NO_MEMORY;
2158 goto fail;
2159 }
2160 /* namelen doesn't include the NULL byte. */
2161 SCVAL(inbuf.data, 5, namelen - 1);
2162 SSVAL(inbuf.data, 6, ea_len);
2163 memcpy(inbuf.data + 8, ea_name_ascii, namelen);
2164 memcpy(inbuf.data + 8 + namelen, ea_val, ea_len);
2165
2166 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
2167 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
2168
2169 status = smb2cli_set_info(cli->conn,
2170 cli->timeout,
2171 cli->smb2.session,
2172 cli->smb2.tcon,
2173 1, /* in_info_type */
2174 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
2175 &inbuf, /* in_input_buffer */
2176 0, /* in_additional_info */
2177 ph->fid_persistent,
2178 ph->fid_volatile);
2179
2180 fail:
2181
2182 TALLOC_FREE(frame);
2183 return status;
2184 }
2185
2186 /***************************************************************
2187 Wrapper that allows SMB2 to set an EA on a pathname.
2188 Synchronous only.
2189 ***************************************************************/
2190
2191 NTSTATUS cli_smb2_set_ea_path(struct cli_state *cli,
2192 const char *name,
2193 const char *ea_name,
2194 const char *ea_val,
2195 size_t ea_len)
2196 {
2197 NTSTATUS status;
2198 uint16_t fnum = 0xffff;
2199
2200 if (smbXcli_conn_has_async_calls(cli->conn)) {
2201 /*
2202 * Can't use sync call while an async call is in flight
2203 */
2204 status = NT_STATUS_INVALID_PARAMETER;
2205 goto fail;
2206 }
2207
2208 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2209 status = NT_STATUS_INVALID_PARAMETER;
2210 goto fail;
2211 }
2212
2213 status = get_fnum_from_path(cli,
2214 name,
2215 FILE_WRITE_EA,
2216 &fnum);
2217
2218 if (!NT_STATUS_IS_OK(status)) {
2219 goto fail;
2220 }
2221
2222 status = cli_set_ea_fnum(cli,
2223 fnum,
2224 ea_name,
2225 ea_val,
2226 ea_len);
2227 if (!NT_STATUS_IS_OK(status)) {
2228 goto fail;
2229 }
2230
2231 fail:
2232
2233 if (fnum != 0xffff) {
2234 cli_smb2_close_fnum(cli, fnum);
2235 }
2236
2237 return status;
2238 }
2239
2240 /***************************************************************
2241 Wrapper that allows SMB2 to get an EA list on a pathname.
2242 Synchronous only.
2243 ***************************************************************/
2244
2245 NTSTATUS cli_smb2_get_ea_list_path(struct cli_state *cli,
2246 const char *name,
2247 TALLOC_CTX *ctx,
2248 size_t *pnum_eas,
2249 struct ea_struct **pea_array)
2250 {
2251 NTSTATUS status;
2252 uint16_t fnum = 0xffff;
2253 DATA_BLOB outbuf = data_blob_null;
2254 struct smb2_hnd *ph = NULL;
2255 struct ea_list *ea_list = NULL;
2256 struct ea_list *eal = NULL;
2257 size_t ea_count = 0;
2258 TALLOC_CTX *frame = talloc_stackframe();
2259
2260 *pnum_eas = 0;
2261 *pea_array = NULL;
2262
2263 if (smbXcli_conn_has_async_calls(cli->conn)) {
2264 /*
2265 * Can't use sync call while an async call is in flight
2266 */
2267 status = NT_STATUS_INVALID_PARAMETER;
2268 goto fail;
2269 }
2270
2271 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2272 status = NT_STATUS_INVALID_PARAMETER;
2273 goto fail;
2274 }
2275
2276 status = get_fnum_from_path(cli,
2277 name,
2278 FILE_READ_EA,
2279 &fnum);
2280
2281 if (!NT_STATUS_IS_OK(status)) {
2282 goto fail;
2283 }
2284
2285 status = map_fnum_to_smb2_handle(cli,
2286 fnum,
2287 &ph);
2288 if (!NT_STATUS_IS_OK(status)) {
2289 goto fail;
2290 }
2291
2292 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
2293 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
2294
2295 status = smb2cli_query_info(cli->conn,
2296 cli->timeout,
2297 cli->smb2.session,
2298 cli->smb2.tcon,
2299 1, /* in_info_type */
2300 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
2301 0xFFFF, /* in_max_output_length */
2302 NULL, /* in_input_buffer */
2303 0, /* in_additional_info */
2304 0, /* in_flags */
2305 ph->fid_persistent,
2306 ph->fid_volatile,
2307 frame,
2308 &outbuf);
2309
2310 if (!NT_STATUS_IS_OK(status)) {
2311 goto fail;
2312 }
2313
2314 /* Parse the reply. */
2315 ea_list = read_nttrans_ea_list(ctx,
2316 (const char *)outbuf.data,
2317 outbuf.length);
2318 if (ea_list == NULL) {
2319 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2320 goto fail;
2321 }
2322
2323 /* Convert to an array. */
2324 for (eal = ea_list; eal; eal = eal->next) {
2325 ea_count++;
2326 }
2327
2328 if (ea_count) {
2329 *pea_array = talloc_array(ctx, struct ea_struct, ea_count);
2330 if (*pea_array == NULL) {
2331 status = NT_STATUS_NO_MEMORY;
2332 goto fail;
2333 }
2334 ea_count = 0;
2335 for (eal = ea_list; eal; eal = eal->next) {
2336 (*pea_array)[ea_count++] = eal->ea;
2337 }
2338 *pnum_eas = ea_count;
2339 }
2340
2341 fail:
2342
2343 if (fnum != 0xffff) {
2344 cli_smb2_close_fnum(cli, fnum);
2345 }
2346
2347 TALLOC_FREE(frame);
2348 return status;
2349 }
2350
2351 /***************************************************************
2352 Wrapper that allows SMB2 to get user quota.
2353 Synchronous only.
2354 ***************************************************************/
2355
2356 NTSTATUS cli_smb2_get_user_quota(struct cli_state *cli,
2357 int quota_fnum,
2358 SMB_NTQUOTA_STRUCT *pqt)
2359 {
2360 NTSTATUS status;
2361 DATA_BLOB inbuf = data_blob_null;
2362 DATA_BLOB outbuf = data_blob_null;
2363 struct smb2_hnd *ph = NULL;
2364 TALLOC_CTX *frame = talloc_stackframe();
2365 unsigned sid_len;
2366 unsigned int offset;
2367 uint8_t *buf;
2368
2369 if (smbXcli_conn_has_async_calls(cli->conn)) {
2370 /*
2371 * Can't use sync call while an async call is in flight
2372 */
2373 status = NT_STATUS_INVALID_PARAMETER;
2374 goto fail;
2375 }
2376
2377 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2378 status = NT_STATUS_INVALID_PARAMETER;
2379 goto fail;
2380 }
2381
2382 status = map_fnum_to_smb2_handle(cli, quota_fnum, &ph);
2383 if (!NT_STATUS_IS_OK(status)) {
2384 goto fail;
2385 }
2386
2387 sid_len = ndr_size_dom_sid(&pqt->sid, 0);
2388
2389 inbuf = data_blob_talloc_zero(frame, 24 + sid_len);
2390 if (inbuf.data == NULL) {
2391 status = NT_STATUS_NO_MEMORY;
2392 goto fail;
2393 }
2394
2395 buf = inbuf.data;
2396
2397 SCVAL(buf, 0, 1); /* ReturnSingle */
2398 SCVAL(buf, 1, 0); /* RestartScan */
2399 SSVAL(buf, 2, 0); /* Reserved */
2400 if (8 + sid_len < 8) {
2401 status = NT_STATUS_INVALID_PARAMETER;
2402 goto fail;
2403 }
2404 SIVAL(buf, 4, 8 + sid_len); /* SidListLength */
2405 SIVAL(buf, 8, 0); /* StartSidLength */
2406 SIVAL(buf, 12, 0); /* StartSidOffset */
2407 SIVAL(buf, 16, 0); /* NextEntryOffset */
2408 SIVAL(buf, 20, sid_len); /* SidLength */
2409 sid_linearize(buf + 24, sid_len, &pqt->sid);
2410
2411 status = smb2cli_query_info(cli->conn, cli->timeout, cli->smb2.session,
2412 cli->smb2.tcon, 4, /* in_info_type */
2413 0, /* in_file_info_class */
2414 0xFFFF, /* in_max_output_length */
2415 &inbuf, /* in_input_buffer */
2416 0, /* in_additional_info */
2417 0, /* in_flags */
2418 ph->fid_persistent, ph->fid_volatile, frame,
2419 &outbuf);
2420
2421 if (!NT_STATUS_IS_OK(status)) {
2422 goto fail;
2423 }
2424
2425 if (!parse_user_quota_record(outbuf.data, outbuf.length, &offset,
2426 pqt)) {
2427 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2428 DEBUG(0, ("Got invalid FILE_QUOTA_INFORMATION in reply.\n"));
2429 }
2430
2431 fail:
2432 TALLOC_FREE(frame);
2433 return status;
2434 }
2435
2436 /***************************************************************
2437 Wrapper that allows SMB2 to list user quota.
2438 Synchronous only.
2439 ***************************************************************/
2440
2441 NTSTATUS cli_smb2_list_user_quota_step(struct cli_state *cli,
2442 TALLOC_CTX *mem_ctx,
2443 int quota_fnum,
2444 SMB_NTQUOTA_LIST **pqt_list,
2445 bool first)
2446 {
2447 NTSTATUS status;
2448 DATA_BLOB inbuf = data_blob_null;
2449 DATA_BLOB outbuf = data_blob_null;
2450 struct smb2_hnd *ph = NULL;
2451 TALLOC_CTX *frame = talloc_stackframe();
2452 uint8_t *buf;
2453
2454 if (smbXcli_conn_has_async_calls(cli->conn)) {
2455 /*
2456 * Can't use sync call while an async call is in flight
2457 */
2458 status = NT_STATUS_INVALID_PARAMETER;
2459 goto cleanup;
2460 }
2461
2462 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2463 status = NT_STATUS_INVALID_PARAMETER;
2464 goto cleanup;
2465 }
2466
2467 status = map_fnum_to_smb2_handle(cli, quota_fnum, &ph);
2468 if (!NT_STATUS_IS_OK(status)) {
2469 goto cleanup;
2470 }
2471
2472 inbuf = data_blob_talloc_zero(frame, 16);
2473 if (inbuf.data == NULL) {
2474 status = NT_STATUS_NO_MEMORY;
2475 goto cleanup;
2476 }
2477
2478 buf = inbuf.data;
2479
2480 SCVAL(buf, 0, 0); /* ReturnSingle */
2481 SCVAL(buf, 1, first ? 1 : 0); /* RestartScan */
2482 SSVAL(buf, 2, 0); /* Reserved */
2483 SIVAL(buf, 4, 0); /* SidListLength */
2484 SIVAL(buf, 8, 0); /* StartSidLength */
2485 SIVAL(buf, 12, 0); /* StartSidOffset */
2486
2487 status = smb2cli_query_info(cli->conn, cli->timeout, cli->smb2.session,
2488 cli->smb2.tcon, 4, /* in_info_type */
2489 0, /* in_file_info_class */
2490 0xFFFF, /* in_max_output_length */
2491 &inbuf, /* in_input_buffer */
2492 0, /* in_additional_info */
2493 0, /* in_flags */
2494 ph->fid_persistent, ph->fid_volatile, frame,
2495 &outbuf);
2496
2497 if (!NT_STATUS_IS_OK(status)) {
2498 goto cleanup;
2499 }
2500
2501 status = parse_user_quota_list(outbuf.data, outbuf.length, mem_ctx,
2502 pqt_list);
2503
2504 cleanup:
2505 TALLOC_FREE(frame);
2506 return status;
2507 }
2508
2509 /***************************************************************
2510 Wrapper that allows SMB2 to get file system quota.
2511 Synchronous only.
2512 ***************************************************************/
2513
2514 NTSTATUS cli_smb2_get_fs_quota_info(struct cli_state *cli,
2515 int quota_fnum,
2516 SMB_NTQUOTA_STRUCT *pqt)
2517 {
2518 NTSTATUS status;
2519 DATA_BLOB outbuf = data_blob_null;
2520 struct smb2_hnd *ph = NULL;
2521 TALLOC_CTX *frame = talloc_stackframe();
2522
2523 if (smbXcli_conn_has_async_calls(cli->conn)) {
2524 /*
2525 * Can't use sync call while an async call is in flight
2526 */
2527 status = NT_STATUS_INVALID_PARAMETER;
2528 goto cleanup;
2529 }
2530
2531 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2532 status = NT_STATUS_INVALID_PARAMETER;
2533 goto cleanup;
2534 }
2535
2536 status = map_fnum_to_smb2_handle(cli, quota_fnum, &ph);
2537 if (!NT_STATUS_IS_OK(status)) {
2538 goto cleanup;
2539 }
2540
2541 status = smb2cli_query_info(
2542 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon,
2543 2, /* in_info_type */
2544 SMB_FS_QUOTA_INFORMATION - 1000, /* in_file_info_class */
2545 0xFFFF, /* in_max_output_length */
2546 NULL, /* in_input_buffer */
2547 0, /* in_additional_info */
2548 0, /* in_flags */
2549 ph->fid_persistent, ph->fid_volatile, frame, &outbuf);
2550
2551 if (!NT_STATUS_IS_OK(status)) {
2552 goto cleanup;
2553 }
2554
2555 status = parse_fs_quota_buffer(outbuf.data, outbuf.length, pqt);
2556
2557 cleanup:
2558 TALLOC_FREE(frame);
2559 return status;
2560 }
2561
2562 /***************************************************************
2563 Wrapper that allows SMB2 to set user quota.
2564 Synchronous only.
2565 ***************************************************************/
2566
2567 NTSTATUS cli_smb2_set_user_quota(struct cli_state *cli,
2568 int quota_fnum,
2569 SMB_NTQUOTA_LIST *qtl)
2570 {
2571 NTSTATUS status;
2572 DATA_BLOB inbuf = data_blob_null;
2573 struct smb2_hnd *ph = NULL;
2574 TALLOC_CTX *frame = talloc_stackframe();
2575
2576 if (smbXcli_conn_has_async_calls(cli->conn)) {
2577 /*
2578 * Can't use sync call while an async call is in flight
2579 */
2580 status = NT_STATUS_INVALID_PARAMETER;
2581 goto cleanup;
2582 }
2583
2584 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2585 status = NT_STATUS_INVALID_PARAMETER;
2586 goto cleanup;
2587 }
2588
2589 status = map_fnum_to_smb2_handle(cli, quota_fnum, &ph);
2590 if (!NT_STATUS_IS_OK(status)) {
2591 goto cleanup;
2592 }
2593
2594 status = build_user_quota_buffer(qtl, 0, talloc_tos(), &inbuf, NULL);
2595 if (!NT_STATUS_IS_OK(status)) {
2596 goto cleanup;
2597 }
2598
2599 status = smb2cli_set_info(cli->conn, cli->timeout, cli->smb2.session,
2600 cli->smb2.tcon, 4, /* in_info_type */
2601 0, /* in_file_info_class */
2602 &inbuf, /* in_input_buffer */
2603 0, /* in_additional_info */
2604 ph->fid_persistent, ph->fid_volatile);
2605 cleanup:
2606 TALLOC_FREE(frame);
2607
2608 return status;
2609 }
2610
2611 NTSTATUS cli_smb2_set_fs_quota_info(struct cli_state *cli,
2612 int quota_fnum,
2613 SMB_NTQUOTA_STRUCT *pqt)
2614 {
2615 NTSTATUS status;
2616 DATA_BLOB inbuf = data_blob_null;
2617 struct smb2_hnd *ph = NULL;
2618 TALLOC_CTX *frame = talloc_stackframe();
2619
2620 if (smbXcli_conn_has_async_calls(cli->conn)) {
2621 /*
2622 * Can't use sync call while an async call is in flight
2623 */
2624 status = NT_STATUS_INVALID_PARAMETER;
2625 goto cleanup;
2626 }
2627
2628 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2629 status = NT_STATUS_INVALID_PARAMETER;
2630 goto cleanup;
2631 }
2632
2633 status = map_fnum_to_smb2_handle(cli, quota_fnum, &ph);
2634 if (!NT_STATUS_IS_OK(status)) {
2635 goto cleanup;
2636 }
2637
2638 status = build_fs_quota_buffer(talloc_tos(), pqt, &inbuf, 0);
2639 if (!NT_STATUS_IS_OK(status)) {
2640 return status;
2641 }
2642
2643 status = smb2cli_set_info(
2644 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon,
2645 2, /* in_info_type */
2646 SMB_FS_QUOTA_INFORMATION - 1000, /* in_file_info_class */
2647 &inbuf, /* in_input_buffer */
2648 0, /* in_additional_info */
2649 ph->fid_persistent, ph->fid_volatile);
2650 cleanup:
2651 TALLOC_FREE(frame);
2652 return status;
2653 }
2654
2655 struct cli_smb2_read_state {
2656 struct tevent_context *ev;
2657 struct cli_state *cli;
2658 struct smb2_hnd *ph;
2659 uint64_t start_offset;
2660 uint32_t size;
2661 uint32_t received;
2662 uint8_t *buf;
2663 };
2664
2665 static void cli_smb2_read_done(struct tevent_req *subreq);
2666
2667 struct tevent_req *cli_smb2_read_send(TALLOC_CTX *mem_ctx,
2668 struct tevent_context *ev,
2669 struct cli_state *cli,
2670 uint16_t fnum,
2671 off_t offset,
2672 size_t size)
2673 {
2674 NTSTATUS status;
2675 struct tevent_req *req, *subreq;
2676 struct cli_smb2_read_state *state;
2677
2678 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_read_state);
2679 if (req == NULL) {
2680 return NULL;
2681 }
2682 state->ev = ev;
2683 state->cli = cli;
2684 state->start_offset = (uint64_t)offset;
2685 state->size = (uint32_t)size;
2686 state->received = 0;
2687 state->buf = NULL;
2688
2689 status = map_fnum_to_smb2_handle(cli,
2690 fnum,
2691 &state->ph);
2692 if (tevent_req_nterror(req, status)) {
2693 return tevent_req_post(req, ev);
2694 }
2695
2696 subreq = smb2cli_read_send(state,
2697 state->ev,
2698 state->cli->conn,
2699 state->cli->timeout,
2700 state->cli->smb2.session,
2701 state->cli->smb2.tcon,
2702 state->size,
2703 state->start_offset,
2704 state->ph->fid_persistent,
2705 state->ph->fid_volatile,
2706 0, /* minimum_count */
2707 0); /* remaining_bytes */
2708
2709 if (tevent_req_nomem(subreq, req)) {
2710 return tevent_req_post(req, ev);
2711 }
2712 tevent_req_set_callback(subreq, cli_smb2_read_done, req);
2713 return req;
2714 }
2715
2716 static void cli_smb2_read_done(struct tevent_req *subreq)
2717 {
2718 struct tevent_req *req = tevent_req_callback_data(
2719 subreq, struct tevent_req);
2720 struct cli_smb2_read_state *state = tevent_req_data(
2721 req, struct cli_smb2_read_state);
2722 NTSTATUS status;
2723
2724 status = smb2cli_read_recv(subreq, state,
2725 &state->buf, &state->received);
2726 if (tevent_req_nterror(req, status)) {
2727 return;
2728 }
2729
2730 if (state->received > state->size) {
2731 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2732 return;
2733 }
2734
2735 tevent_req_done(req);
2736 }
2737
2738 NTSTATUS cli_smb2_read_recv(struct tevent_req *req,
2739 ssize_t *received,
2740 uint8_t **rcvbuf)
2741 {
2742 NTSTATUS status;
2743 struct cli_smb2_read_state *state = tevent_req_data(
2744 req, struct cli_smb2_read_state);
2745
2746 if (tevent_req_is_nterror(req, &status)) {
2747 state->cli->raw_status = status;
2748 return status;
2749 }
2750 /*
2751 * As in cli_read_andx_recv() rcvbuf is talloced from the request, so
2752 * better make sure that you copy it away before you talloc_free(req).
2753 * "rcvbuf" is NOT a talloc_ctx of its own, so do not talloc_move it!
2754 */
2755 *received = (ssize_t)state->received;
2756 *rcvbuf = state->buf;
2757 state->cli->raw_status = NT_STATUS_OK;
2758 return NT_STATUS_OK;
2759 }
2760
2761 struct cli_smb2_write_state {
2762 struct tevent_context *ev;
2763 struct cli_state *cli;
2764 struct smb2_hnd *ph;
2765 uint32_t flags;
2766 const uint8_t *buf;
2767 uint64_t offset;
2768 uint32_t size;
2769 uint32_t written;
2770 };
2771
2772 static void cli_smb2_write_written(struct tevent_req *req);
2773
2774 struct tevent_req *cli_smb2_write_send(TALLOC_CTX *mem_ctx,
2775 struct tevent_context *ev,
2776 struct cli_state *cli,
2777 uint16_t fnum,
2778 uint16_t mode,
2779 const uint8_t *buf,
2780 off_t offset,
2781 size_t size)
2782 {
2783 NTSTATUS status;
2784 struct tevent_req *req, *subreq = NULL;
2785 struct cli_smb2_write_state *state = NULL;
2786
2787 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_write_state);
2788 if (req == NULL) {
2789 return NULL;
2790 }
2791 state->ev = ev;
2792 state->cli = cli;
2793 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2794 state->flags = (uint32_t)mode;
2795 state->buf = buf;
2796 state->offset = (uint64_t)offset;
2797 state->size = (uint32_t)size;
2798 state->written = 0;
2799
2800 status = map_fnum_to_smb2_handle(cli,
2801 fnum,
2802 &state->ph);
2803 if (tevent_req_nterror(req, status)) {
2804 return tevent_req_post(req, ev);
2805 }
2806
2807 subreq = smb2cli_write_send(state,
2808 state->ev,
2809 state->cli->conn,
2810 state->cli->timeout,
2811 state->cli->smb2.session,
2812 state->cli->smb2.tcon,
2813 state->size,
2814 state->offset,
2815 state->ph->fid_persistent,
2816 state->ph->fid_volatile,
2817 0, /* remaining_bytes */
2818 state->flags, /* flags */
2819 state->buf);
2820
2821 if (tevent_req_nomem(subreq, req)) {
2822 return tevent_req_post(req, ev);
2823 }
2824 tevent_req_set_callback(subreq, cli_smb2_write_written, req);
2825 return req;
2826 }
2827
2828 static void cli_smb2_write_written(struct tevent_req *subreq)
2829 {
2830 struct tevent_req *req = tevent_req_callback_data(
2831 subreq, struct tevent_req);
2832 struct cli_smb2_write_state *state = tevent_req_data(
2833 req, struct cli_smb2_write_state);
2834 NTSTATUS status;
2835 uint32_t written;
2836
2837 status = smb2cli_write_recv(subreq, &written);
2838 TALLOC_FREE(subreq);
2839 if (tevent_req_nterror(req, status)) {
2840 return;
2841 }
2842
2843 state->written = written;
2844
2845 tevent_req_done(req);
2846 }
2847
2848 NTSTATUS cli_smb2_write_recv(struct tevent_req *req,
2849 size_t *pwritten)
2850 {
2851 struct cli_smb2_write_state *state = tevent_req_data(
2852 req, struct cli_smb2_write_state);
2853 NTSTATUS status;
2854
2855 if (tevent_req_is_nterror(req, &status)) {
2856 state->cli->raw_status = status;
2857 tevent_req_received(req);
2858 return status;
2859 }
2860
2861 if (pwritten != NULL) {
2862 *pwritten = (size_t)state->written;
2863 }
2864 state->cli->raw_status = NT_STATUS_OK;
2865 tevent_req_received(req);
2866 return NT_STATUS_OK;
2867 }
2868
2869 /***************************************************************
2870 Wrapper that allows SMB2 async write using an fnum.
2871 This is mostly cut-and-paste from Volker's code inside
2872 source3/libsmb/clireadwrite.c, adapted for SMB2.
2873
2874 Done this way so I can reuse all the logic inside cli_push()
2875 for free :-).
2876 ***************************************************************/
2877
2878 struct cli_smb2_writeall_state {
2879 struct tevent_context *ev;
2880 struct cli_state *cli;
2881 struct smb2_hnd *ph;
2882 uint32_t flags;
2883 const uint8_t *buf;
2884 uint64_t offset;
2885 uint32_t size;
2886 uint32_t written;
2887 };
2888
2889 static void cli_smb2_writeall_written(struct tevent_req *req);
2890
2891 struct tevent_req *cli_smb2_writeall_send(TALLOC_CTX *mem_ctx,
2892 struct tevent_context *ev,
2893 struct cli_state *cli,
2894 uint16_t fnum,
2895 uint16_t mode,
2896 const uint8_t *buf,
2897 off_t offset,
2898 size_t size)
2899 {
2900 NTSTATUS status;
2901 struct tevent_req *req, *subreq = NULL;
2902 struct cli_smb2_writeall_state *state = NULL;
2903 uint32_t to_write;
2904 uint32_t max_size;
2905 bool ok;
2906
2907 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_writeall_state);
2908 if (req == NULL) {
2909 return NULL;
2910 }
2911 state->ev = ev;
2912 state->cli = cli;
2913 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2914 state->flags = (uint32_t)mode;
2915 state->buf = buf;
2916 state->offset = (uint64_t)offset;
2917 state->size = (uint32_t)size;
2918 state->written = 0;
2919
2920 status = map_fnum_to_smb2_handle(cli,
2921 fnum,
2922 &state->ph);
2923 if (tevent_req_nterror(req, status)) {
2924 return tevent_req_post(req, ev);
2925 }
2926
2927 to_write = state->size;
2928 max_size = smb2cli_conn_max_write_size(state->cli->conn);
2929 to_write = MIN(max_size, to_write);
2930 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2931 if (ok) {
2932 to_write = MIN(max_size, to_write);
2933 }
2934
2935 subreq = smb2cli_write_send(state,
2936 state->ev,
2937 state->cli->conn,
2938 state->cli->timeout,
2939 state->cli->smb2.session,
2940 state->cli->smb2.tcon,
2941 to_write,
2942 state->offset,
2943 state->ph->fid_persistent,
2944 state->ph->fid_volatile,
2945 0, /* remaining_bytes */
2946 state->flags, /* flags */
2947 state->buf + state->written);
2948
2949 if (tevent_req_nomem(subreq, req)) {
2950 return tevent_req_post(req, ev);
2951 }
2952 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
2953 return req;
2954 }
2955
2956 static void cli_smb2_writeall_written(struct tevent_req *subreq)
2957 {
2958 struct tevent_req *req = tevent_req_callback_data(
2959 subreq, struct tevent_req);
2960 struct cli_smb2_writeall_state *state = tevent_req_data(
2961 req, struct cli_smb2_writeall_state);
2962 NTSTATUS status;
2963 uint32_t written, to_write;
2964 uint32_t max_size;
2965 bool ok;
2966
2967 status = smb2cli_write_recv(subreq, &written);
2968 TALLOC_FREE(subreq);
2969 if (tevent_req_nterror(req, status)) {
2970 return;
2971 }
2972
2973 state->written += written;
2974
2975 if (state->written > state->size) {
2976 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2977 return;
2978 }
2979
2980 to_write = state->size - state->written;
2981
2982 if (to_write == 0) {
2983 tevent_req_done(req);
2984 return;
2985 }
2986
2987 max_size = smb2cli_conn_max_write_size(state->cli->conn);
2988 to_write = MIN(max_size, to_write);
2989 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2990 if (ok) {
2991 to_write = MIN(max_size, to_write);
2992 }
2993
2994 subreq = smb2cli_write_send(state,
2995 state->ev,
2996 state->cli->conn,
2997 state->cli->timeout,
2998 state->cli->smb2.session,
2999 state->cli->smb2.tcon,
3000 to_write,
3001 state->offset + state->written,
3002 state->ph->fid_persistent,
3003 state->ph->fid_volatile,
3004 0, /* remaining_bytes */
3005 state->flags, /* flags */
3006 state->buf + state->written);
3007
3008 if (tevent_req_nomem(subreq, req)) {
3009 return;
3010 }
3011 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
3012 }
3013
3014 NTSTATUS cli_smb2_writeall_recv(struct tevent_req *req,
3015 size_t *pwritten)
3016 {
3017 struct cli_smb2_writeall_state *state = tevent_req_data(
3018 req, struct cli_smb2_writeall_state);
3019 NTSTATUS status;
3020
3021 if (tevent_req_is_nterror(req, &status)) {
3022 state->cli->raw_status = status;
3023 return status;
3024 }
3025 if (pwritten != NULL) {
3026 *pwritten = (size_t)state->written;
3027 }
3028 state->cli->raw_status = NT_STATUS_OK;
3029 return NT_STATUS_OK;
3030 }
3031
3032 struct cli_smb2_splice_state {
3033 struct tevent_context *ev;
3034 struct cli_state *cli;
3035 struct smb2_hnd *src_ph;
3036 struct smb2_hnd *dst_ph;
3037 int (*splice_cb)(off_t n, void *priv);
3038 void *priv;
3039 off_t written;
3040 off_t size;
3041 off_t src_offset;
3042 off_t dst_offset;
3043 bool resized;
3044 struct req_resume_key_rsp resume_rsp;
3045 struct srv_copychunk_copy cc_copy;
3046 };
3047
3048 static void cli_splice_copychunk_send(struct cli_smb2_splice_state *state,
3049 struct tevent_req *req);
3050
3051 static void cli_splice_copychunk_done(struct tevent_req *subreq)
3052 {
3053 struct tevent_req *req = tevent_req_callback_data(
3054 subreq, struct tevent_req);
3055 struct cli_smb2_splice_state *state =
3056 tevent_req_data(req,
3057 struct cli_smb2_splice_state);
3058 struct smbXcli_conn *conn = state->cli->conn;
3059 DATA_BLOB out_input_buffer = data_blob_null;
3060 DATA_BLOB out_output_buffer = data_blob_null;
3061 struct srv_copychunk_rsp cc_copy_rsp;
3062 enum ndr_err_code ndr_ret;
3063 NTSTATUS status;
3064
3065 status = smb2cli_ioctl_recv(subreq, state,
3066 &out_input_buffer,
3067 &out_output_buffer);
3068 TALLOC_FREE(subreq);
3069 if ((!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER) ||
3070 state->resized) && tevent_req_nterror(req, status)) {
3071 return;
3072 }
3073
3074 ndr_ret = ndr_pull_struct_blob(&out_output_buffer, state, &cc_copy_rsp,
3075 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
3076 if (ndr_ret != NDR_ERR_SUCCESS) {
3077 DEBUG(0, ("failed to unmarshall copy chunk rsp\n"));
3078 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
3079 return;
3080 }
3081
3082 if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
3083 uint32_t max_chunks = MIN(cc_copy_rsp.chunks_written,
3084 cc_copy_rsp.total_bytes_written / cc_copy_rsp.chunk_bytes_written);
3085 if ((cc_copy_rsp.chunk_bytes_written > smb2cli_conn_cc_chunk_len(conn) ||
3086 max_chunks > smb2cli_conn_cc_max_chunks(conn)) &&
3087 tevent_req_nterror(req, status)) {
3088 return;
3089 }
3090
3091 state->resized = true;
3092 smb2cli_conn_set_cc_chunk_len(conn, cc_copy_rsp.chunk_bytes_written);
3093 smb2cli_conn_set_cc_max_chunks(conn, max_chunks);
3094 } else {
3095 if ((state->src_offset > INT64_MAX - cc_copy_rsp.total_bytes_written) ||
3096 (state->dst_offset > INT64_MAX - cc_copy_rsp.total_bytes_written) ||
3097 (state->written > INT64_MAX - cc_copy_rsp.total_bytes_written)) {
3098 tevent_req_nterror(req, NT_STATUS_FILE_TOO_LARGE);
3099 return;
3100 }
3101 state->src_offset += cc_copy_rsp.total_bytes_written;
3102 state->dst_offset += cc_copy_rsp.total_bytes_written;
3103 state->written += cc_copy_rsp.total_bytes_written;
3104 if (!state->splice_cb(state->written, state->priv)) {
3105 tevent_req_nterror(req, NT_STATUS_CANCELLED);
3106 return;
3107 }
3108 }
3109
3110 cli_splice_copychunk_send(state, req);
3111 }
3112
3113 static void cli_splice_copychunk_send(struct cli_smb2_splice_state *state,
3114 struct tevent_req *req)
3115 {
3116 struct tevent_req *subreq;
3117 enum ndr_err_code ndr_ret;
3118 struct smbXcli_conn *conn = state->cli->conn;
3119 struct srv_copychunk_copy *cc_copy = &state->cc_copy;
3120 off_t src_offset = state->src_offset;
3121 off_t dst_offset = state->dst_offset;
3122 uint32_t req_len = MIN(smb2cli_conn_cc_chunk_len(conn) * smb2cli_conn_cc_max_chunks(conn),
3123 state->size - state->written);
3124 DATA_BLOB in_input_buffer = data_blob_null;
3125 DATA_BLOB in_output_buffer = data_blob_null;
3126
3127 if (state->size - state->written == 0) {
3128 tevent_req_done(req);
3129 return;
3130 }
3131
3132 cc_copy->chunk_count = 0;
3133 while (req_len) {
3134 cc_copy->chunks[cc_copy->chunk_count].source_off = src_offset;
3135 cc_copy->chunks[cc_copy->chunk_count].target_off = dst_offset;
3136 cc_copy->chunks[cc_copy->chunk_count].length = MIN(req_len,
3137 smb2cli_conn_cc_chunk_len(conn));
3138 if (req_len < cc_copy->chunks[cc_copy->chunk_count].length) {
3139 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
3140 return;
3141 }
3142 req_len -= cc_copy->chunks[cc_copy->chunk_count].length;
3143 if ((src_offset > INT64_MAX - cc_copy->chunks[cc_copy->chunk_count].length) ||
3144 (dst_offset > INT64_MAX - cc_copy->chunks[cc_copy->chunk_count].length)) {
3145 tevent_req_nterror(req, NT_STATUS_FILE_TOO_LARGE);
3146 return;
3147 }
3148 src_offset += cc_copy->chunks[cc_copy->chunk_count].length;
3149 dst_offset += cc_copy->chunks[cc_copy->chunk_count].length;
3150 cc_copy->chunk_count++;
3151 }
3152
3153 ndr_ret = ndr_push_struct_blob(&in_input_buffer, state, cc_copy,
3154 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
3155 if (ndr_ret != NDR_ERR_SUCCESS) {
3156 DEBUG(0, ("failed to marshall copy chunk req\n"));
3157 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
3158 return;
3159 }
3160
3161 subreq = smb2cli_ioctl_send(state, state->ev, state->cli->conn,
3162 state->cli->timeout,
3163 state->cli->smb2.session,
3164 state->cli->smb2.tcon,
3165 state->dst_ph->fid_persistent, /* in_fid_persistent */
3166 state->dst_ph->fid_volatile, /* in_fid_volatile */
3167 FSCTL_SRV_COPYCHUNK_WRITE,
3168 0, /* in_max_input_length */
3169 &in_input_buffer,
3170 12, /* in_max_output_length */
3171 &in_output_buffer,
3172 SMB2_IOCTL_FLAG_IS_FSCTL);
3173 if (tevent_req_nomem(subreq, req)) {
3174 return;
3175 }
3176 tevent_req_set_callback(subreq,
3177 cli_splice_copychunk_done,
3178 req);
3179 }
3180
3181 static void cli_splice_key_done(struct tevent_req *subreq)
3182 {
3183 struct tevent_req *req = tevent_req_callback_data(
3184 subreq, struct tevent_req);
3185 struct cli_smb2_splice_state *state =
3186 tevent_req_data(req,
3187 struct cli_smb2_splice_state);
3188 enum ndr_err_code ndr_ret;
3189 NTSTATUS status;
3190
3191 DATA_BLOB out_input_buffer = data_blob_null;
3192 DATA_BLOB out_output_buffer = data_blob_null;
3193
3194 status = smb2cli_ioctl_recv(subreq, state,
3195 &out_input_buffer,
3196 &out_output_buffer);
3197 TALLOC_FREE(subreq);
3198 if (tevent_req_nterror(req, status)) {
3199 return;
3200 }
3201
3202 ndr_ret = ndr_pull_struct_blob(&out_output_buffer,
3203 state, &state->resume_rsp,
3204 (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
3205 if (ndr_ret != NDR_ERR_SUCCESS) {
3206 DEBUG(0, ("failed to unmarshall resume key rsp\n"));
3207 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
3208 return;
3209 }
3210
3211 memcpy(&state->cc_copy.source_key,
3212 &state->resume_rsp.resume_key,
3213 sizeof state->resume_rsp.resume_key);
3214
3215 cli_splice_copychunk_send(state, req);
3216 }
3217
3218 struct tevent_req *cli_smb2_splice_send(TALLOC_CTX *mem_ctx,
3219 struct tevent_context *ev,
3220 struct cli_state *cli,
3221 uint16_t src_fnum, uint16_t dst_fnum,
3222 off_t size, off_t src_offset, off_t dst_offset,
3223 int (*splice_cb)(off_t n, void *priv),
3224 void *priv)
3225 {
3226 struct tevent_req *req;
3227 struct tevent_req *subreq;
3228 struct cli_smb2_splice_state *state;
3229 NTSTATUS status;
3230 DATA_BLOB in_input_buffer = data_blob_null;
3231 DATA_BLOB in_output_buffer = data_blob_null;
3232
3233 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_splice_state);
3234 if (req == NULL) {
3235 return NULL;
3236 }
3237 state->cli = cli;
3238 state->ev = ev;
3239 state->splice_cb = splice_cb;
3240 state->priv = priv;
3241 state->size = size;
3242 state->written = 0;
3243 state->src_offset = src_offset;
3244 state->dst_offset = dst_offset;
3245 state->cc_copy.chunks = talloc_array(state,
3246 struct srv_copychunk,
3247 smb2cli_conn_cc_max_chunks(cli->conn));
3248 if (state->cc_copy.chunks == NULL) {
3249 return NULL;
3250 }
3251
3252 status = map_fnum_to_smb2_handle(cli, src_fnum, &state->src_ph);
3253 if (tevent_req_nterror(req, status))
3254 return tevent_req_post(req, ev);
3255
3256 status = map_fnum_to_smb2_handle(cli, dst_fnum, &state->dst_ph);
3257 if (tevent_req_nterror(req, status))
3258 return tevent_req_post(req, ev);
3259
3260 subreq = smb2cli_ioctl_send(state, ev, cli->conn,
3261 cli->timeout,
3262 cli->smb2.session,
3263 cli->smb2.tcon,
3264 state->src_ph->fid_persistent, /* in_fid_persistent */
3265 state->src_ph->fid_volatile, /* in_fid_volatile */
3266 FSCTL_SRV_REQUEST_RESUME_KEY,
3267 0, /* in_max_input_length */
3268 &in_input_buffer,
3269 32, /* in_max_output_length */
3270 &in_output_buffer,
3271 SMB2_IOCTL_FLAG_IS_FSCTL);
3272 if (tevent_req_nomem(subreq, req)) {
3273 return NULL;
3274 }
3275 tevent_req_set_callback(subreq,
3276 cli_splice_key_done,
3277 req);
3278
3279 return req;
3280 }
3281
3282 NTSTATUS cli_smb2_splice_recv(struct tevent_req *req, off_t *written)
3283 {
3284 struct cli_smb2_splice_state *state = tevent_req_data(
3285 req, struct cli_smb2_splice_state);
3286 NTSTATUS status;
3287
3288 if (tevent_req_is_nterror(req, &status)) {
3289 state->cli->raw_status = status;
3290 tevent_req_received(req);
3291 return status;
3292 }
3293 if (written != NULL) {
3294 *written = state->written;
3295 }
3296 state->cli->raw_status = NT_STATUS_OK;
3297 tevent_req_received(req);
3298 return NT_STATUS_OK;
3299 }
3300
3301 /***************************************************************
3302 SMB2 enum shadow copy data.
3303 ***************************************************************/
3304
3305 struct cli_smb2_shadow_copy_data_fnum_state {
3306 struct cli_state *cli;
3307 uint16_t fnum;
3308 struct smb2_hnd *ph;
3309 DATA_BLOB out_input_buffer;
3310 DATA_BLOB out_output_buffer;
3311 };
3312
3313 static void cli_smb2_shadow_copy_data_fnum_done(struct tevent_req *subreq);
3314
3315 static struct tevent_req *cli_smb2_shadow_copy_data_fnum_send(
3316 TALLOC_CTX *mem_ctx,
3317 struct tevent_context *ev,
3318 struct cli_state *cli,
3319 uint16_t fnum,
3320 bool get_names)
3321 {
3322 struct tevent_req *req, *subreq;
3323 struct cli_smb2_shadow_copy_data_fnum_state *state;
3324 NTSTATUS status;
3325
3326 req = tevent_req_create(mem_ctx, &state,
3327 struct cli_smb2_shadow_copy_data_fnum_state);
3328 if (req == NULL) {
3329 return NULL;
3330 }
3331
3332 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3333 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
3334 return tevent_req_post(req, ev);
3335 }
3336
3337 state->cli = cli;
3338 state->fnum = fnum;
3339
3340 status = map_fnum_to_smb2_handle(cli, fnum, &state->ph);
3341 if (tevent_req_nterror(req, status)) {
3342 return tevent_req_post(req, ev);
3343 }
3344
3345 /*
3346 * TODO. Under SMB2 we should send a zero max_output_length
3347 * ioctl to get the required size, then send another ioctl
3348 * to get the data, but the current SMB1 implementation just
3349 * does one roundtrip with a 64K buffer size. Do the same
3350 * for now. JRA.
3351 */
3352
3353 subreq = smb2cli_ioctl_send(state, ev, state->cli->conn,
3354 state->cli->timeout,
3355 state->cli->smb2.session,
3356 state->cli->smb2.tcon,
3357 state->ph->fid_persistent, /* in_fid_persistent */
3358 state->ph->fid_volatile, /* in_fid_volatile */
3359 FSCTL_GET_SHADOW_COPY_DATA,
3360 0, /* in_max_input_length */
3361 NULL, /* in_input_buffer */
3362 get_names ?
3363 CLI_BUFFER_SIZE : 16, /* in_max_output_length */
3364 NULL, /* in_output_buffer */
3365 SMB2_IOCTL_FLAG_IS_FSCTL);
3366
3367 if (tevent_req_nomem(subreq, req)) {
3368 return tevent_req_post(req, ev);
3369 }
3370 tevent_req_set_callback(subreq,
3371 cli_smb2_shadow_copy_data_fnum_done,
3372 req);
3373
3374 return req;
3375 }
3376
3377 static void cli_smb2_shadow_copy_data_fnum_done(struct tevent_req *subreq)
3378 {
3379 struct tevent_req *req = tevent_req_callback_data(
3380 subreq, struct tevent_req);
3381 struct cli_smb2_shadow_copy_data_fnum_state *state = tevent_req_data(
3382 req, struct cli_smb2_shadow_copy_data_fnum_state);
3383 NTSTATUS status;
3384
3385 status = smb2cli_ioctl_recv(subreq, state,
3386 &state->out_input_buffer,
3387 &state->out_output_buffer);
3388 TALLOC_FREE(subreq);
3389 if (tevent_req_nterror(req, status)) {
3390 return;
3391 }
3392 tevent_req_done(req);
3393 }
3394
3395 static NTSTATUS cli_smb2_shadow_copy_data_fnum_recv(struct tevent_req *req,
3396 TALLOC_CTX *mem_ctx,
3397 bool get_names,
3398 char ***pnames,
3399 int *pnum_names)
3400 {
3401 struct cli_smb2_shadow_copy_data_fnum_state *state = tevent_req_data(
3402 req, struct cli_smb2_shadow_copy_data_fnum_state);
3403 char **names = NULL;
3404 uint32_t num_names = 0;
3405 uint32_t num_names_returned = 0;
3406 uint32_t dlength = 0;
3407 uint32_t i;
3408 uint8_t *endp = NULL;
3409 NTSTATUS status;
3410
3411 if (tevent_req_is_nterror(req, &status)) {
3412 return status;
3413 }
3414
3415 if (state->out_output_buffer.length < 16) {
3416 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3417 }
3418
3419 num_names = IVAL(state->out_output_buffer.data, 0);
3420 num_names_returned = IVAL(state->out_output_buffer.data, 4);
3421 dlength = IVAL(state->out_output_buffer.data, 8);
3422
3423 if (num_names > 0x7FFFFFFF) {
3424 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3425 }
3426
3427 if (get_names == false) {
3428 *pnum_names = (int)num_names;
3429 return NT_STATUS_OK;
3430 }
3431 if (num_names != num_names_returned) {
3432 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3433 }
3434 if (dlength + 12 < 12) {
3435 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3436 }
3437 /*
3438 * NB. The below is an allowable return if there are
3439 * more snapshots than the buffer size we told the
3440 * server we can receive. We currently don't support
3441 * this.
3442 */
3443 if (dlength + 12 > state->out_output_buffer.length) {
3444 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3445 }
3446 if (state->out_output_buffer.length +
3447 (2 * sizeof(SHADOW_COPY_LABEL)) <
3448 state->out_output_buffer.length) {
3449 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3450 }
3451
3452 names = talloc_array(mem_ctx, char *, num_names_returned);
3453 if (names == NULL) {
3454 return NT_STATUS_NO_MEMORY;
3455 }
3456
3457 endp = state->out_output_buffer.data +
3458 state->out_output_buffer.length;
3459
3460 for (i=0; i<num_names_returned; i++) {
3461 bool ret;
3462 uint8_t *src;
3463 size_t converted_size;
3464
3465 src = state->out_output_buffer.data + 12 +
3466 (i * 2 * sizeof(SHADOW_COPY_LABEL));
3467
3468 if (src + (2 * sizeof(SHADOW_COPY_LABEL)) > endp) {
3469 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3470 }
3471 ret = convert_string_talloc(
3472 names, CH_UTF16LE, CH_UNIX,
3473 src, 2 * sizeof(SHADOW_COPY_LABEL),
3474 &names[i], &converted_size);
3475 if (!ret) {
3476 TALLOC_FREE(names);
3477 return NT_STATUS_INVALID_NETWORK_RESPONSE;
3478 }
3479 }
3480 *pnum_names = num_names;
3481 *pnames = names;
3482 return NT_STATUS_OK;
3483 }
3484
3485 NTSTATUS cli_smb2_shadow_copy_data(TALLOC_CTX *mem_ctx,
3486 struct cli_state *cli,
3487 uint16_t fnum,
3488 bool get_names,
3489 char ***pnames,
3490 int *pnum_names)
3491 {
3492 TALLOC_CTX *frame = talloc_stackframe();
3493 struct tevent_context *ev;
3494 struct tevent_req *req;
3495 NTSTATUS status = NT_STATUS_NO_MEMORY;
3496
3497 if (smbXcli_conn_has_async_calls(cli->conn)) {
3498 /*
3499 * Can't use sync call while an async call is in flight
3500 */
3501 status = NT_STATUS_INVALID_PARAMETER;
3502 goto fail;
3503 }
3504 ev = samba_tevent_context_init(frame);
3505 if (ev == NULL) {
3506 goto fail;
3507 }
3508 req = cli_smb2_shadow_copy_data_fnum_send(frame,
3509 ev,
3510 cli,
3511 fnum,
3512 get_names);
3513 if (req == NULL) {
3514 goto fail;
3515 }
3516 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
3517 goto fail;
3518 }
3519 status = cli_smb2_shadow_copy_data_fnum_recv(req,
3520 mem_ctx,
3521 get_names,
3522 pnames,
3523 pnum_names);
3524 fail:
3525 TALLOC_FREE(frame);
3526 return status;
3527 }
Samba GIT mirror