?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libsmb: Make cli_smb2_create_fnum cancellable
[Samba.git] / source3 / libsmb / cli_smb2_fnum.c
blob87edf4e29820a8ff647cd89627bb2e80995e4feb
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 "smb2cli.h"
34 #include "cli_smb2_fnum.h"
35 #include "trans2.h"
36 #include "clirap.h"
37 #include "../libcli/smb/smb2_create_blob.h"
38 #include "libsmb/proto.h"
39 #include "lib/util/tevent_ntstatus.h"
40 #include "../libcli/security/security.h"
41 #include "lib/util_ea.h"
42
43 struct smb2_hnd {
44 uint64_t fid_persistent;
45 uint64_t fid_volatile;
46 };
47
48 /*
49 * Handle mapping code.
50 */
51
52 /***************************************************************
53 Allocate a new fnum between 1 and 0xFFFE from an smb2_hnd.
54 Ensures handle is owned by cli struct.
55 ***************************************************************/
56
57 static NTSTATUS map_smb2_handle_to_fnum(struct cli_state *cli,
58 const struct smb2_hnd *ph, /* In */
59 uint16_t *pfnum) /* Out */
60 {
61 int ret;
62 struct idr_context *idp = cli->smb2.open_handles;
63 struct smb2_hnd *owned_h = talloc_memdup(cli,
64 ph,
65 sizeof(struct smb2_hnd));
66
67 if (owned_h == NULL) {
68 return NT_STATUS_NO_MEMORY;
69 }
70
71 if (idp == NULL) {
72 /* Lazy init */
73 cli->smb2.open_handles = idr_init(cli);
74 if (cli->smb2.open_handles == NULL) {
75 TALLOC_FREE(owned_h);
76 return NT_STATUS_NO_MEMORY;
77 }
78 idp = cli->smb2.open_handles;
79 }
80
81 ret = idr_get_new_above(idp, owned_h, 1, 0xFFFE);
82 if (ret == -1) {
83 TALLOC_FREE(owned_h);
84 return NT_STATUS_NO_MEMORY;
85 }
86
87 *pfnum = (uint16_t)ret;
88 return NT_STATUS_OK;
89 }
90
91 /***************************************************************
92 Return the smb2_hnd pointer associated with the given fnum.
93 ***************************************************************/
94
95 static NTSTATUS map_fnum_to_smb2_handle(struct cli_state *cli,
96 uint16_t fnum, /* In */
97 struct smb2_hnd **pph) /* Out */
98 {
99 struct idr_context *idp = cli->smb2.open_handles;
100
101 if (idp == NULL) {
102 return NT_STATUS_INVALID_PARAMETER;
103 }
104 *pph = (struct smb2_hnd *)idr_find(idp, fnum);
105 if (*pph == NULL) {
106 return NT_STATUS_INVALID_HANDLE;
107 }
108 return NT_STATUS_OK;
109 }
110
111 /***************************************************************
112 Delete the fnum to smb2_hnd mapping. Zeros out handle on
113 successful return.
114 ***************************************************************/
115
116 static NTSTATUS delete_smb2_handle_mapping(struct cli_state *cli,
117 struct smb2_hnd **pph, /* In */
118 uint16_t fnum) /* In */
119 {
120 struct idr_context *idp = cli->smb2.open_handles;
121 struct smb2_hnd *ph;
122
123 if (idp == NULL) {
124 return NT_STATUS_INVALID_PARAMETER;
125 }
126
127 ph = (struct smb2_hnd *)idr_find(idp, fnum);
128 if (ph != *pph) {
129 return NT_STATUS_INVALID_PARAMETER;
130 }
131 idr_remove(idp, fnum);
132 TALLOC_FREE(*pph);
133 return NT_STATUS_OK;
134 }
135
136 /***************************************************************
137 Oplock mapping code.
138 ***************************************************************/
139
140 static uint8_t flags_to_smb2_oplock(uint32_t create_flags)
141 {
142 if (create_flags & REQUEST_BATCH_OPLOCK) {
143 return SMB2_OPLOCK_LEVEL_BATCH;
144 } else if (create_flags & REQUEST_OPLOCK) {
145 return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
146 }
147
148 /* create_flags doesn't do a level2 request. */
149 return SMB2_OPLOCK_LEVEL_NONE;
150 }
151
152 /***************************************************************
153 Small wrapper that allows SMB2 create to return a uint16_t fnum.
154 ***************************************************************/
155
156 struct cli_smb2_create_fnum_state {
157 struct cli_state *cli;
158 struct smb_create_returns cr;
159 uint16_t fnum;
160 struct tevent_req *subreq;
161 };
162
163 static void cli_smb2_create_fnum_done(struct tevent_req *subreq);
164 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req);
165
166 struct tevent_req *cli_smb2_create_fnum_send(TALLOC_CTX *mem_ctx,
167 struct tevent_context *ev,
168 struct cli_state *cli,
169 const char *fname,
170 uint32_t create_flags,
171 uint32_t desired_access,
172 uint32_t file_attributes,
173 uint32_t share_access,
174 uint32_t create_disposition,
175 uint32_t create_options)
176 {
177 struct tevent_req *req, *subreq;
178 struct cli_smb2_create_fnum_state *state;
179
180 req = tevent_req_create(mem_ctx, &state,
181 struct cli_smb2_create_fnum_state);
182 if (req == NULL) {
183 return NULL;
184 }
185 state->cli = cli;
186
187 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
188 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
189 return tevent_req_post(req, ev);
190 }
191
192 if (cli->backup_intent) {
193 create_options |= FILE_OPEN_FOR_BACKUP_INTENT;
194 }
195
196 /* SMB2 is pickier about pathnames. Ensure it doesn't
197 start in a '\' */
198 if (*fname == '\\') {
199 fname++;
200 }
201
202 subreq = smb2cli_create_send(state, ev,
203 cli->conn,
204 cli->timeout,
205 cli->smb2.session,
206 cli->smb2.tcon,
207 fname,
208 flags_to_smb2_oplock(create_flags),
209 SMB2_IMPERSONATION_IMPERSONATION,
210 desired_access,
211 file_attributes,
212 share_access,
213 create_disposition,
214 create_options,
215 NULL);
216 if (tevent_req_nomem(subreq, req)) {
217 return tevent_req_post(req, ev);
218 }
219 tevent_req_set_callback(subreq, cli_smb2_create_fnum_done, req);
220
221 state->subreq = subreq;
222 tevent_req_set_cancel_fn(req, cli_smb2_create_fnum_cancel);
223
224 return req;
225 }
226
227 static void cli_smb2_create_fnum_done(struct tevent_req *subreq)
228 {
229 struct tevent_req *req = tevent_req_callback_data(
230 subreq, struct tevent_req);
231 struct cli_smb2_create_fnum_state *state = tevent_req_data(
232 req, struct cli_smb2_create_fnum_state);
233 struct smb2_hnd h;
234 NTSTATUS status;
235
236 status = smb2cli_create_recv(subreq, &h.fid_persistent,
237 &h.fid_volatile, &state->cr);
238 TALLOC_FREE(subreq);
239 if (tevent_req_nterror(req, status)) {
240 return;
241 }
242
243 status = map_smb2_handle_to_fnum(state->cli, &h, &state->fnum);
244 if (tevent_req_nterror(req, status)) {
245 return;
246 }
247 tevent_req_done(req);
248 }
249
250 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req)
251 {
252 struct cli_smb2_create_fnum_state *state = tevent_req_data(
253 req, struct cli_smb2_create_fnum_state);
254 return tevent_req_cancel(state->subreq);
255 }
256
257 NTSTATUS cli_smb2_create_fnum_recv(struct tevent_req *req, uint16_t *pfnum,
258 struct smb_create_returns *cr)
259 {
260 struct cli_smb2_create_fnum_state *state = tevent_req_data(
261 req, struct cli_smb2_create_fnum_state);
262 NTSTATUS status;
263
264 if (tevent_req_is_nterror(req, &status)) {
265 return status;
266 }
267 if (pfnum != NULL) {
268 *pfnum = state->fnum;
269 }
270 if (cr != NULL) {
271 *cr = state->cr;
272 }
273 return NT_STATUS_OK;
274 }
275
276 NTSTATUS cli_smb2_create_fnum(struct cli_state *cli,
277 const char *fname,
278 uint32_t create_flags,
279 uint32_t desired_access,
280 uint32_t file_attributes,
281 uint32_t share_access,
282 uint32_t create_disposition,
283 uint32_t create_options,
284 uint16_t *pfid,
285 struct smb_create_returns *cr)
286 {
287 TALLOC_CTX *frame = talloc_stackframe();
288 struct tevent_context *ev;
289 struct tevent_req *req;
290 NTSTATUS status = NT_STATUS_NO_MEMORY;
291
292 if (smbXcli_conn_has_async_calls(cli->conn)) {
293 /*
294 * Can't use sync call while an async call is in flight
295 */
296 status = NT_STATUS_INVALID_PARAMETER;
297 goto fail;
298 }
299 ev = samba_tevent_context_init(frame);
300 if (ev == NULL) {
301 goto fail;
302 }
303 req = cli_smb2_create_fnum_send(frame, ev, cli, fname, create_flags,
304 desired_access, file_attributes,
305 share_access, create_disposition,
306 create_options);
307 if (req == NULL) {
308 goto fail;
309 }
310 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
311 goto fail;
312 }
313 status = cli_smb2_create_fnum_recv(req, pfid, cr);
314 fail:
315 TALLOC_FREE(frame);
316 return status;
317 }
318
319 /***************************************************************
320 Small wrapper that allows SMB2 close to use a uint16_t fnum.
321 Synchronous only.
322 ***************************************************************/
323
324 NTSTATUS cli_smb2_close_fnum(struct cli_state *cli, uint16_t fnum)
325 {
326 struct smb2_hnd *ph = NULL;
327 NTSTATUS status;
328
329 if (smbXcli_conn_has_async_calls(cli->conn)) {
330 /*
331 * Can't use sync call while an async call is in flight
332 */
333 return NT_STATUS_INVALID_PARAMETER;
334 }
335
336 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
337 return NT_STATUS_INVALID_PARAMETER;
338 }
339
340 status = map_fnum_to_smb2_handle(cli,
341 fnum,
342 &ph);
343 if (!NT_STATUS_IS_OK(status)) {
344 return status;
345 }
346
347 status = smb2cli_close(cli->conn,
348 cli->timeout,
349 cli->smb2.session,
350 cli->smb2.tcon,
351 0,
352 ph->fid_persistent,
353 ph->fid_volatile);
354
355 /* Delete the fnum -> handle mapping. */
356 if (NT_STATUS_IS_OK(status)) {
357 status = delete_smb2_handle_mapping(cli, &ph, fnum);
358 }
359
360 return status;
361 }
362
363 /***************************************************************
364 Small wrapper that allows SMB2 to create a directory
365 Synchronous only.
366 ***************************************************************/
367
368 NTSTATUS cli_smb2_mkdir(struct cli_state *cli, const char *dname)
369 {
370 NTSTATUS status;
371 uint16_t fnum;
372
373 if (smbXcli_conn_has_async_calls(cli->conn)) {
374 /*
375 * Can't use sync call while an async call is in flight
376 */
377 return NT_STATUS_INVALID_PARAMETER;
378 }
379
380 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
381 return NT_STATUS_INVALID_PARAMETER;
382 }
383
384 status = cli_smb2_create_fnum(cli,
385 dname,
386 0, /* create_flags */
387 FILE_READ_ATTRIBUTES, /* desired_access */
388 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
389 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
390 FILE_CREATE, /* create_disposition */
391 FILE_DIRECTORY_FILE, /* create_options */
392 &fnum,
393 NULL);
394
395 if (!NT_STATUS_IS_OK(status)) {
396 return status;
397 }
398 return cli_smb2_close_fnum(cli, fnum);
399 }
400
401 /***************************************************************
402 Small wrapper that allows SMB2 to delete a directory
403 Synchronous only.
404 ***************************************************************/
405
406 NTSTATUS cli_smb2_rmdir(struct cli_state *cli, const char *dname)
407 {
408 NTSTATUS status;
409 uint16_t fnum;
410
411 if (smbXcli_conn_has_async_calls(cli->conn)) {
412 /*
413 * Can't use sync call while an async call is in flight
414 */
415 return NT_STATUS_INVALID_PARAMETER;
416 }
417
418 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
419 return NT_STATUS_INVALID_PARAMETER;
420 }
421
422 status = cli_smb2_create_fnum(cli,
423 dname,
424 0, /* create_flags */
425 DELETE_ACCESS, /* desired_access */
426 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
427 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
428 FILE_OPEN, /* create_disposition */
429 FILE_DIRECTORY_FILE|FILE_DELETE_ON_CLOSE, /* create_options */
430 &fnum,
431 NULL);
432
433 if (!NT_STATUS_IS_OK(status)) {
434 return status;
435 }
436 return cli_smb2_close_fnum(cli, fnum);
437 }
438
439 /***************************************************************
440 Small wrapper that allows SMB2 to unlink a pathname.
441 Synchronous only.
442 ***************************************************************/
443
444 NTSTATUS cli_smb2_unlink(struct cli_state *cli, const char *fname)
445 {
446 NTSTATUS status;
447 uint16_t fnum;
448
449 if (smbXcli_conn_has_async_calls(cli->conn)) {
450 /*
451 * Can't use sync call while an async call is in flight
452 */
453 return NT_STATUS_INVALID_PARAMETER;
454 }
455
456 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
457 return NT_STATUS_INVALID_PARAMETER;
458 }
459
460 status = cli_smb2_create_fnum(cli,
461 fname,
462 0, /* create_flags */
463 DELETE_ACCESS, /* desired_access */
464 FILE_ATTRIBUTE_NORMAL, /* file attributes */
465 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
466 FILE_OPEN, /* create_disposition */
467 FILE_DELETE_ON_CLOSE, /* create_options */
468 &fnum,
469 NULL);
470
471 if (!NT_STATUS_IS_OK(status)) {
472 return status;
473 }
474 return cli_smb2_close_fnum(cli, fnum);
475 }
476
477 /***************************************************************
478 Utility function to parse a SMB2_FIND_ID_BOTH_DIRECTORY_INFO reply.
479 ***************************************************************/
480
481 static NTSTATUS parse_finfo_id_both_directory_info(uint8_t *dir_data,
482 uint32_t dir_data_length,
483 struct file_info *finfo,
484 uint32_t *next_offset)
485 {
486 size_t namelen = 0;
487 size_t slen = 0;
488 size_t ret = 0;
489
490 if (dir_data_length < 4) {
491 return NT_STATUS_INFO_LENGTH_MISMATCH;
492 }
493
494 *next_offset = IVAL(dir_data, 0);
495
496 if (*next_offset > dir_data_length) {
497 return NT_STATUS_INFO_LENGTH_MISMATCH;
498 }
499
500 if (*next_offset != 0) {
501 /* Ensure we only read what in this record. */
502 dir_data_length = *next_offset;
503 }
504
505 if (dir_data_length < 105) {
506 return NT_STATUS_INFO_LENGTH_MISMATCH;
507 }
508
509 finfo->atime_ts = interpret_long_date((const char *)dir_data + 16);
510 finfo->mtime_ts = interpret_long_date((const char *)dir_data + 24);
511 finfo->ctime_ts = interpret_long_date((const char *)dir_data + 32);
512 finfo->size = IVAL2_TO_SMB_BIG_UINT(dir_data + 40, 0);
513 finfo->mode = CVAL(dir_data + 56, 0);
514 namelen = IVAL(dir_data + 60,0);
515 if (namelen > (dir_data_length - 104)) {
516 return NT_STATUS_INFO_LENGTH_MISMATCH;
517 }
518 slen = CVAL(dir_data + 68, 0);
519 if (slen > 24) {
520 return NT_STATUS_INFO_LENGTH_MISMATCH;
521 }
522 ret = pull_string_talloc(finfo,
523 dir_data,
524 FLAGS2_UNICODE_STRINGS,
525 &finfo->short_name,
526 dir_data + 70,
527 slen,
528 STR_UNICODE);
529 if (ret == (size_t)-1) {
530 /* Bad conversion. */
531 return NT_STATUS_INVALID_NETWORK_RESPONSE;
532 }
533
534 ret = pull_string_talloc(finfo,
535 dir_data,
536 FLAGS2_UNICODE_STRINGS,
537 &finfo->name,
538 dir_data + 104,
539 namelen,
540 STR_UNICODE);
541 if (ret == (size_t)-1) {
542 /* Bad conversion. */
543 return NT_STATUS_INVALID_NETWORK_RESPONSE;
544 }
545 return NT_STATUS_OK;
546 }
547
548 /*******************************************************************
549 Given a filename - get its directory name
550 ********************************************************************/
551
552 static bool windows_parent_dirname(TALLOC_CTX *mem_ctx,
553 const char *dir,
554 char **parent,
555 const char **name)
556 {
557 char *p;
558 ptrdiff_t len;
559
560 p = strrchr_m(dir, '\\'); /* Find final '\\', if any */
561
562 if (p == NULL) {
563 if (!(*parent = talloc_strdup(mem_ctx, "\\"))) {
564 return false;
565 }
566 if (name) {
567 *name = dir;
568 }
569 return true;
570 }
571
572 len = p-dir;
573
574 if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
575 return false;
576 }
577 (*parent)[len] = '\0';
578
579 if (name) {
580 *name = p+1;
581 }
582 return true;
583 }
584
585 /***************************************************************
586 Wrapper that allows SMB2 to list a directory.
587 Synchronous only.
588 ***************************************************************/
589
590 NTSTATUS cli_smb2_list(struct cli_state *cli,
591 const char *pathname,
592 uint16_t attribute,
593 NTSTATUS (*fn)(const char *,
594 struct file_info *,
595 const char *,
596 void *),
597 void *state)
598 {
599 NTSTATUS status;
600 uint16_t fnum = 0xffff;
601 char *parent_dir = NULL;
602 const char *mask = NULL;
603 struct smb2_hnd *ph = NULL;
604 bool processed_file = false;
605 TALLOC_CTX *frame = talloc_stackframe();
606 TALLOC_CTX *subframe = NULL;
607
608 if (smbXcli_conn_has_async_calls(cli->conn)) {
609 /*
610 * Can't use sync call while an async call is in flight
611 */
612 status = NT_STATUS_INVALID_PARAMETER;
613 goto fail;
614 }
615
616 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
617 status = NT_STATUS_INVALID_PARAMETER;
618 goto fail;
619 }
620
621 /* Get the directory name. */
622 if (!windows_parent_dirname(frame,
623 pathname,
624 &parent_dir,
625 &mask)) {
626 status = NT_STATUS_NO_MEMORY;
627 goto fail;
628 }
629
630 status = cli_smb2_create_fnum(cli,
631 parent_dir,
632 0, /* create_flags */
633 SEC_DIR_LIST|SEC_DIR_READ_ATTRIBUTE,/* desired_access */
634 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
635 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
636 FILE_OPEN, /* create_disposition */
637 FILE_DIRECTORY_FILE, /* create_options */
638 &fnum,
639 NULL);
640
641 if (!NT_STATUS_IS_OK(status)) {
642 goto fail;
643 }
644
645 status = map_fnum_to_smb2_handle(cli,
646 fnum,
647 &ph);
648 if (!NT_STATUS_IS_OK(status)) {
649 goto fail;
650 }
651
652 do {
653 uint8_t *dir_data = NULL;
654 uint32_t dir_data_length = 0;
655 uint32_t next_offset = 0;
656 subframe = talloc_stackframe();
657
658 status = smb2cli_query_directory(cli->conn,
659 cli->timeout,
660 cli->smb2.session,
661 cli->smb2.tcon,
662 SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
663 0, /* flags */
664 0, /* file_index */
665 ph->fid_persistent,
666 ph->fid_volatile,
667 mask,
668 0xffff,
669 subframe,
670 &dir_data,
671 &dir_data_length);
672
673 if (!NT_STATUS_IS_OK(status)) {
674 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
675 break;
676 }
677 goto fail;
678 }
679
680 do {
681 struct file_info *finfo = talloc_zero(subframe,
682 struct file_info);
683
684 if (finfo == NULL) {
685 status = NT_STATUS_NO_MEMORY;
686 goto fail;
687 }
688
689 status = parse_finfo_id_both_directory_info(dir_data,
690 dir_data_length,
691 finfo,
692 &next_offset);
693
694 if (!NT_STATUS_IS_OK(status)) {
695 goto fail;
696 }
697
698 if (dir_check_ftype((uint32_t)finfo->mode,
699 (uint32_t)attribute)) {
700 /*
701 * Only process if attributes match.
702 * On SMB1 server does this, so on
703 * SMB2 we need to emulate in the
704 * client.
705 *
706 * https://bugzilla.samba.org/show_bug.cgi?id=10260
707 */
708 processed_file = true;
709
710 status = fn(cli->dfs_mountpoint,
711 finfo,
712 pathname,
713 state);
714
715 if (!NT_STATUS_IS_OK(status)) {
716 break;
717 }
718 }
719
720 TALLOC_FREE(finfo);
721
722 /* Move to next entry. */
723 if (next_offset) {
724 dir_data += next_offset;
725 dir_data_length -= next_offset;
726 }
727 } while (next_offset != 0);
728
729 TALLOC_FREE(subframe);
730
731 } while (NT_STATUS_IS_OK(status));
732
733 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
734 status = NT_STATUS_OK;
735 }
736
737 if (NT_STATUS_IS_OK(status) && !processed_file) {
738 /*
739 * In SMB1 findfirst returns NT_STATUS_NO_SUCH_FILE
740 * if no files match. Emulate this in the client.
741 */
742 status = NT_STATUS_NO_SUCH_FILE;
743 }
744
745 fail:
746
747 if (fnum != 0xffff) {
748 cli_smb2_close_fnum(cli, fnum);
749 }
750 TALLOC_FREE(subframe);
751 TALLOC_FREE(frame);
752 return status;
753 }
754
755 /***************************************************************
756 Wrapper that allows SMB2 to query a path info (basic level).
757 Synchronous only.
758 ***************************************************************/
759
760 NTSTATUS cli_smb2_qpathinfo_basic(struct cli_state *cli,
761 const char *name,
762 SMB_STRUCT_STAT *sbuf,
763 uint32_t *attributes)
764 {
765 NTSTATUS status;
766 struct smb_create_returns cr;
767 uint16_t fnum = 0xffff;
768 size_t namelen = strlen(name);
769
770 if (smbXcli_conn_has_async_calls(cli->conn)) {
771 /*
772 * Can't use sync call while an async call is in flight
773 */
774 return NT_STATUS_INVALID_PARAMETER;
775 }
776
777 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
778 return NT_STATUS_INVALID_PARAMETER;
779 }
780
781 /* SMB2 is pickier about pathnames. Ensure it doesn't
782 end in a '\' */
783 if (namelen > 0 && name[namelen-1] == '\\') {
784 char *modname = talloc_strdup(talloc_tos(), name);
785 modname[namelen-1] = '\0';
786 name = modname;
787 }
788
789 /* This is commonly used as a 'cd'. Try qpathinfo on
790 a directory handle first. */
791
792 status = cli_smb2_create_fnum(cli,
793 name,
794 0, /* create_flags */
795 FILE_READ_ATTRIBUTES, /* desired_access */
796 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
797 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
798 FILE_OPEN, /* create_disposition */
799 FILE_DIRECTORY_FILE, /* create_options */
800 &fnum,
801 &cr);
802
803 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
804 /* Maybe a file ? */
805 status = cli_smb2_create_fnum(cli,
806 name,
807 0, /* create_flags */
808 FILE_READ_ATTRIBUTES, /* desired_access */
809 0, /* file attributes */
810 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
811 FILE_OPEN, /* create_disposition */
812 0, /* create_options */
813 &fnum,
814 &cr);
815 }
816
817 if (!NT_STATUS_IS_OK(status)) {
818 return status;
819 }
820
821 cli_smb2_close_fnum(cli, fnum);
822
823 ZERO_STRUCTP(sbuf);
824
825 sbuf->st_ex_atime = nt_time_to_unix_timespec(&cr.last_access_time);
826 sbuf->st_ex_mtime = nt_time_to_unix_timespec(&cr.last_write_time);
827 sbuf->st_ex_ctime = nt_time_to_unix_timespec(&cr.change_time);
828 sbuf->st_ex_size = cr.end_of_file;
829 *attributes = cr.file_attributes;
830
831 return NT_STATUS_OK;
832 }
833
834 /***************************************************************
835 Helper function for pathname operations.
836 ***************************************************************/
837
838 static NTSTATUS get_fnum_from_path(struct cli_state *cli,
839 const char *name,
840 uint32_t desired_access,
841 uint16_t *pfnum)
842 {
843 NTSTATUS status;
844 size_t namelen = strlen(name);
845 TALLOC_CTX *frame = talloc_stackframe();
846
847 /* SMB2 is pickier about pathnames. Ensure it doesn't
848 end in a '\' */
849 if (namelen > 0 && name[namelen-1] == '\\') {
850 char *modname = talloc_strdup(frame, name);
851 if (modname == NULL) {
852 status = NT_STATUS_NO_MEMORY;
853 goto fail;
854 }
855 modname[namelen-1] = '\0';
856 name = modname;
857 }
858
859 /* Try to open a file handle first. */
860 status = cli_smb2_create_fnum(cli,
861 name,
862 0, /* create_flags */
863 desired_access,
864 0, /* file attributes */
865 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
866 FILE_OPEN, /* create_disposition */
867 0, /* create_options */
868 pfnum,
869 NULL);
870
871 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
872 status = cli_smb2_create_fnum(cli,
873 name,
874 0, /* create_flags */
875 desired_access,
876 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
877 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
878 FILE_OPEN, /* create_disposition */
879 FILE_DIRECTORY_FILE, /* create_options */
880 pfnum,
881 NULL);
882 }
883
884 fail:
885
886 TALLOC_FREE(frame);
887 return status;
888 }
889
890 /***************************************************************
891 Wrapper that allows SMB2 to query a path info (ALTNAME level).
892 Synchronous only.
893 ***************************************************************/
894
895 NTSTATUS cli_smb2_qpathinfo_alt_name(struct cli_state *cli,
896 const char *name,
897 fstring alt_name)
898 {
899 NTSTATUS status;
900 DATA_BLOB outbuf = data_blob_null;
901 uint16_t fnum = 0xffff;
902 struct smb2_hnd *ph = NULL;
903 uint32_t altnamelen = 0;
904 TALLOC_CTX *frame = talloc_stackframe();
905
906 if (smbXcli_conn_has_async_calls(cli->conn)) {
907 /*
908 * Can't use sync call while an async call is in flight
909 */
910 status = NT_STATUS_INVALID_PARAMETER;
911 goto fail;
912 }
913
914 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
915 status = NT_STATUS_INVALID_PARAMETER;
916 goto fail;
917 }
918
919 status = get_fnum_from_path(cli,
920 name,
921 FILE_READ_ATTRIBUTES,
922 &fnum);
923
924 if (!NT_STATUS_IS_OK(status)) {
925 goto fail;
926 }
927
928 status = map_fnum_to_smb2_handle(cli,
929 fnum,
930 &ph);
931 if (!NT_STATUS_IS_OK(status)) {
932 goto fail;
933 }
934
935 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
936 level SMB_FILE_ALTERNATE_NAME_INFORMATION (1021) == SMB2 21 */
937
938 status = smb2cli_query_info(cli->conn,
939 cli->timeout,
940 cli->smb2.session,
941 cli->smb2.tcon,
942 1, /* in_info_type */
943 (SMB_FILE_ALTERNATE_NAME_INFORMATION - 1000), /* in_file_info_class */
944 0xFFFF, /* in_max_output_length */
945 NULL, /* in_input_buffer */
946 0, /* in_additional_info */
947 0, /* in_flags */
948 ph->fid_persistent,
949 ph->fid_volatile,
950 frame,
951 &outbuf);
952
953 if (!NT_STATUS_IS_OK(status)) {
954 goto fail;
955 }
956
957 /* Parse the reply. */
958 if (outbuf.length < 4) {
959 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
960 goto fail;
961 }
962
963 altnamelen = IVAL(outbuf.data, 0);
964 if (altnamelen > outbuf.length - 4) {
965 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
966 goto fail;
967 }
968
969 if (altnamelen > 0) {
970 size_t ret = 0;
971 char *short_name = NULL;
972 ret = pull_string_talloc(frame,
973 outbuf.data,
974 FLAGS2_UNICODE_STRINGS,
975 &short_name,
976 outbuf.data + 4,
977 altnamelen,
978 STR_UNICODE);
979 if (ret == (size_t)-1) {
980 /* Bad conversion. */
981 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
982 goto fail;
983 }
984
985 fstrcpy(alt_name, short_name);
986 } else {
987 alt_name[0] = '\0';
988 }
989
990 status = NT_STATUS_OK;
991
992 fail:
993
994 if (fnum != 0xffff) {
995 cli_smb2_close_fnum(cli, fnum);
996 }
997 TALLOC_FREE(frame);
998 return status;
999 }
1000
1001
1002 /***************************************************************
1003 Wrapper that allows SMB2 to query a fnum info (basic level).
1004 Synchronous only.
1005 ***************************************************************/
1006
1007 NTSTATUS cli_smb2_qfileinfo_basic(struct cli_state *cli,
1008 uint16_t fnum,
1009 uint16_t *mode,
1010 off_t *size,
1011 struct timespec *create_time,
1012 struct timespec *access_time,
1013 struct timespec *write_time,
1014 struct timespec *change_time,
1015 SMB_INO_T *ino)
1016 {
1017 NTSTATUS status;
1018 DATA_BLOB outbuf = data_blob_null;
1019 struct smb2_hnd *ph = NULL;
1020 TALLOC_CTX *frame = talloc_stackframe();
1021
1022 if (smbXcli_conn_has_async_calls(cli->conn)) {
1023 /*
1024 * Can't use sync call while an async call is in flight
1025 */
1026 status = NT_STATUS_INVALID_PARAMETER;
1027 goto fail;
1028 }
1029
1030 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1031 status = NT_STATUS_INVALID_PARAMETER;
1032 goto fail;
1033 }
1034
1035 status = map_fnum_to_smb2_handle(cli,
1036 fnum,
1037 &ph);
1038 if (!NT_STATUS_IS_OK(status)) {
1039 goto fail;
1040 }
1041
1042 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1043 level 0x12 (SMB2_FILE_ALL_INFORMATION). */
1044
1045 status = smb2cli_query_info(cli->conn,
1046 cli->timeout,
1047 cli->smb2.session,
1048 cli->smb2.tcon,
1049 1, /* in_info_type */
1050 (SMB_FILE_ALL_INFORMATION - 1000), /* in_file_info_class */
1051 0xFFFF, /* in_max_output_length */
1052 NULL, /* in_input_buffer */
1053 0, /* in_additional_info */
1054 0, /* in_flags */
1055 ph->fid_persistent,
1056 ph->fid_volatile,
1057 frame,
1058 &outbuf);
1059 if (!NT_STATUS_IS_OK(status)) {
1060 goto fail;
1061 }
1062
1063 /* Parse the reply. */
1064 if (outbuf.length < 0x60) {
1065 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1066 goto fail;
1067 }
1068
1069 if (create_time) {
1070 *create_time = interpret_long_date((const char *)outbuf.data + 0x0);
1071 }
1072 if (access_time) {
1073 *access_time = interpret_long_date((const char *)outbuf.data + 0x8);
1074 }
1075 if (write_time) {
1076 *write_time = interpret_long_date((const char *)outbuf.data + 0x10);
1077 }
1078 if (change_time) {
1079 *change_time = interpret_long_date((const char *)outbuf.data + 0x18);
1080 }
1081 if (mode) {
1082 uint32_t attr = IVAL(outbuf.data, 0x20);
1083 *mode = (uint16_t)attr;
1084 }
1085 if (size) {
1086 uint64_t file_size = BVAL(outbuf.data, 0x30);
1087 *size = (off_t)file_size;
1088 }
1089 if (ino) {
1090 uint64_t file_index = BVAL(outbuf.data, 0x40);
1091 *ino = (SMB_INO_T)file_index;
1092 }
1093
1094 fail:
1095
1096 TALLOC_FREE(frame);
1097 return status;
1098 }
1099
1100 /***************************************************************
1101 Wrapper that allows SMB2 to query an fnum.
1102 Implement on top of cli_smb2_qfileinfo_basic().
1103 Synchronous only.
1104 ***************************************************************/
1105
1106 NTSTATUS cli_smb2_getattrE(struct cli_state *cli,
1107 uint16_t fnum,
1108 uint16_t *attr,
1109 off_t *size,
1110 time_t *change_time,
1111 time_t *access_time,
1112 time_t *write_time)
1113 {
1114 struct timespec access_time_ts;
1115 struct timespec write_time_ts;
1116 struct timespec change_time_ts;
1117 NTSTATUS status = cli_smb2_qfileinfo_basic(cli,
1118 fnum,
1119 attr,
1120 size,
1121 NULL,
1122 &access_time_ts,
1123 &write_time_ts,
1124 &change_time_ts,
1125 NULL);
1126
1127 if (!NT_STATUS_IS_OK(status)) {
1128 return status;
1129 }
1130
1131 if (change_time) {
1132 *change_time = change_time_ts.tv_sec;
1133 }
1134 if (access_time) {
1135 *access_time = access_time_ts.tv_sec;
1136 }
1137 if (write_time) {
1138 *write_time = write_time_ts.tv_sec;
1139 }
1140 return NT_STATUS_OK;
1141 }
1142
1143 /***************************************************************
1144 Wrapper that allows SMB2 to get pathname attributes.
1145 Synchronous only.
1146 ***************************************************************/
1147
1148 NTSTATUS cli_smb2_getatr(struct cli_state *cli,
1149 const char *name,
1150 uint16_t *attr,
1151 off_t *size,
1152 time_t *write_time)
1153 {
1154 NTSTATUS status;
1155 uint16_t fnum = 0xffff;
1156 struct smb2_hnd *ph = NULL;
1157 TALLOC_CTX *frame = talloc_stackframe();
1158
1159 if (smbXcli_conn_has_async_calls(cli->conn)) {
1160 /*
1161 * Can't use sync call while an async call is in flight
1162 */
1163 status = NT_STATUS_INVALID_PARAMETER;
1164 goto fail;
1165 }
1166
1167 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1168 status = NT_STATUS_INVALID_PARAMETER;
1169 goto fail;
1170 }
1171
1172 status = get_fnum_from_path(cli,
1173 name,
1174 FILE_READ_ATTRIBUTES,
1175 &fnum);
1176
1177 if (!NT_STATUS_IS_OK(status)) {
1178 goto fail;
1179 }
1180
1181 status = map_fnum_to_smb2_handle(cli,
1182 fnum,
1183 &ph);
1184 if (!NT_STATUS_IS_OK(status)) {
1185 goto fail;
1186 }
1187 status = cli_smb2_getattrE(cli,
1188 fnum,
1189 attr,
1190 size,
1191 NULL,
1192 NULL,
1193 write_time);
1194 if (!NT_STATUS_IS_OK(status)) {
1195 goto fail;
1196 }
1197
1198 fail:
1199
1200 if (fnum != 0xffff) {
1201 cli_smb2_close_fnum(cli, fnum);
1202 }
1203
1204 TALLOC_FREE(frame);
1205 return status;
1206 }
1207
1208 /***************************************************************
1209 Wrapper that allows SMB2 to query a pathname info (basic level).
1210 Implement on top of cli_smb2_qfileinfo_basic().
1211 Synchronous only.
1212 ***************************************************************/
1213
1214 NTSTATUS cli_smb2_qpathinfo2(struct cli_state *cli,
1215 const char *name,
1216 struct timespec *create_time,
1217 struct timespec *access_time,
1218 struct timespec *write_time,
1219 struct timespec *change_time,
1220 off_t *size,
1221 uint16_t *mode,
1222 SMB_INO_T *ino)
1223 {
1224 NTSTATUS status;
1225 struct smb2_hnd *ph = NULL;
1226 uint16_t fnum = 0xffff;
1227 TALLOC_CTX *frame = talloc_stackframe();
1228
1229 if (smbXcli_conn_has_async_calls(cli->conn)) {
1230 /*
1231 * Can't use sync call while an async call is in flight
1232 */
1233 status = NT_STATUS_INVALID_PARAMETER;
1234 goto fail;
1235 }
1236
1237 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1238 status = NT_STATUS_INVALID_PARAMETER;
1239 goto fail;
1240 }
1241
1242 status = get_fnum_from_path(cli,
1243 name,
1244 FILE_READ_ATTRIBUTES,
1245 &fnum);
1246
1247 if (!NT_STATUS_IS_OK(status)) {
1248 goto fail;
1249 }
1250
1251 status = map_fnum_to_smb2_handle(cli,
1252 fnum,
1253 &ph);
1254 if (!NT_STATUS_IS_OK(status)) {
1255 goto fail;
1256 }
1257
1258 status = cli_smb2_qfileinfo_basic(cli,
1259 fnum,
1260 mode,
1261 size,
1262 create_time,
1263 access_time,
1264 write_time,
1265 change_time,
1266 ino);
1267
1268 fail:
1269
1270 if (fnum != 0xffff) {
1271 cli_smb2_close_fnum(cli, fnum);
1272 }
1273
1274 TALLOC_FREE(frame);
1275 return status;
1276 }
1277
1278 /***************************************************************
1279 Wrapper that allows SMB2 to query pathname streams.
1280 Synchronous only.
1281 ***************************************************************/
1282
1283 NTSTATUS cli_smb2_qpathinfo_streams(struct cli_state *cli,
1284 const char *name,
1285 TALLOC_CTX *mem_ctx,
1286 unsigned int *pnum_streams,
1287 struct stream_struct **pstreams)
1288 {
1289 NTSTATUS status;
1290 struct smb2_hnd *ph = NULL;
1291 uint16_t fnum = 0xffff;
1292 DATA_BLOB outbuf = data_blob_null;
1293 TALLOC_CTX *frame = talloc_stackframe();
1294
1295 if (smbXcli_conn_has_async_calls(cli->conn)) {
1296 /*
1297 * Can't use sync call while an async call is in flight
1298 */
1299 status = NT_STATUS_INVALID_PARAMETER;
1300 goto fail;
1301 }
1302
1303 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1304 status = NT_STATUS_INVALID_PARAMETER;
1305 goto fail;
1306 }
1307
1308 status = get_fnum_from_path(cli,
1309 name,
1310 FILE_READ_ATTRIBUTES,
1311 &fnum);
1312
1313 if (!NT_STATUS_IS_OK(status)) {
1314 goto fail;
1315 }
1316
1317 status = map_fnum_to_smb2_handle(cli,
1318 fnum,
1319 &ph);
1320 if (!NT_STATUS_IS_OK(status)) {
1321 goto fail;
1322 }
1323
1324 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1325 level 22 (SMB2_FILE_STREAM_INFORMATION). */
1326
1327 status = smb2cli_query_info(cli->conn,
1328 cli->timeout,
1329 cli->smb2.session,
1330 cli->smb2.tcon,
1331 1, /* in_info_type */
1332 (SMB_FILE_STREAM_INFORMATION - 1000), /* in_file_info_class */
1333 0xFFFF, /* in_max_output_length */
1334 NULL, /* in_input_buffer */
1335 0, /* in_additional_info */
1336 0, /* in_flags */
1337 ph->fid_persistent,
1338 ph->fid_volatile,
1339 frame,
1340 &outbuf);
1341
1342 if (!NT_STATUS_IS_OK(status)) {
1343 goto fail;
1344 }
1345
1346 /* Parse the reply. */
1347 if (!parse_streams_blob(mem_ctx,
1348 outbuf.data,
1349 outbuf.length,
1350 pnum_streams,
1351 pstreams)) {
1352 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1353 goto fail;
1354 }
1355
1356 fail:
1357
1358 if (fnum != 0xffff) {
1359 cli_smb2_close_fnum(cli, fnum);
1360 }
1361
1362 TALLOC_FREE(frame);
1363 return status;
1364 }
1365
1366 /***************************************************************
1367 Wrapper that allows SMB2 to set pathname attributes.
1368 Synchronous only.
1369 ***************************************************************/
1370
1371 NTSTATUS cli_smb2_setatr(struct cli_state *cli,
1372 const char *name,
1373 uint16_t attr,
1374 time_t mtime)
1375 {
1376 NTSTATUS status;
1377 uint16_t fnum = 0xffff;
1378 struct smb2_hnd *ph = NULL;
1379 uint8_t inbuf_store[40];
1380 DATA_BLOB inbuf = data_blob_null;
1381 TALLOC_CTX *frame = talloc_stackframe();
1382
1383 if (smbXcli_conn_has_async_calls(cli->conn)) {
1384 /*
1385 * Can't use sync call while an async call is in flight
1386 */
1387 status = NT_STATUS_INVALID_PARAMETER;
1388 goto fail;
1389 }
1390
1391 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1392 status = NT_STATUS_INVALID_PARAMETER;
1393 goto fail;
1394 }
1395
1396 status = get_fnum_from_path(cli,
1397 name,
1398 FILE_WRITE_ATTRIBUTES,
1399 &fnum);
1400
1401 if (!NT_STATUS_IS_OK(status)) {
1402 goto fail;
1403 }
1404
1405 status = map_fnum_to_smb2_handle(cli,
1406 fnum,
1407 &ph);
1408 if (!NT_STATUS_IS_OK(status)) {
1409 goto fail;
1410 }
1411
1412 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1413 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1414
1415 inbuf.data = inbuf_store;
1416 inbuf.length = sizeof(inbuf_store);
1417 data_blob_clear(&inbuf);
1418
1419 SSVAL(inbuf.data, 32, attr);
1420 if (mtime != 0) {
1421 put_long_date((char *)inbuf.data + 16,mtime);
1422 }
1423 /* Set all the other times to -1. */
1424 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1425 SBVAL(inbuf.data, 8, 0xFFFFFFFFFFFFFFFFLL);
1426 SBVAL(inbuf.data, 24, 0xFFFFFFFFFFFFFFFFLL);
1427
1428 status = smb2cli_set_info(cli->conn,
1429 cli->timeout,
1430 cli->smb2.session,
1431 cli->smb2.tcon,
1432 1, /* in_info_type */
1433 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1434 &inbuf, /* in_input_buffer */
1435 0, /* in_additional_info */
1436 ph->fid_persistent,
1437 ph->fid_volatile);
1438 fail:
1439
1440 if (fnum != 0xffff) {
1441 cli_smb2_close_fnum(cli, fnum);
1442 }
1443
1444 TALLOC_FREE(frame);
1445 return status;
1446 }
1447
1448 /***************************************************************
1449 Wrapper that allows SMB2 to set file handle times.
1450 Synchronous only.
1451 ***************************************************************/
1452
1453 NTSTATUS cli_smb2_setattrE(struct cli_state *cli,
1454 uint16_t fnum,
1455 time_t change_time,
1456 time_t access_time,
1457 time_t write_time)
1458 {
1459 NTSTATUS status;
1460 struct smb2_hnd *ph = NULL;
1461 uint8_t inbuf_store[40];
1462 DATA_BLOB inbuf = data_blob_null;
1463
1464 if (smbXcli_conn_has_async_calls(cli->conn)) {
1465 /*
1466 * Can't use sync call while an async call is in flight
1467 */
1468 return NT_STATUS_INVALID_PARAMETER;
1469 }
1470
1471 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1472 return NT_STATUS_INVALID_PARAMETER;
1473 }
1474
1475 status = map_fnum_to_smb2_handle(cli,
1476 fnum,
1477 &ph);
1478 if (!NT_STATUS_IS_OK(status)) {
1479 return status;
1480 }
1481
1482 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1483 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1484
1485 inbuf.data = inbuf_store;
1486 inbuf.length = sizeof(inbuf_store);
1487 data_blob_clear(&inbuf);
1488
1489 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1490 if (change_time != 0) {
1491 put_long_date((char *)inbuf.data + 24, change_time);
1492 }
1493 if (access_time != 0) {
1494 put_long_date((char *)inbuf.data + 8, access_time);
1495 }
1496 if (write_time != 0) {
1497 put_long_date((char *)inbuf.data + 16, write_time);
1498 }
1499
1500 return smb2cli_set_info(cli->conn,
1501 cli->timeout,
1502 cli->smb2.session,
1503 cli->smb2.tcon,
1504 1, /* in_info_type */
1505 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1506 &inbuf, /* in_input_buffer */
1507 0, /* in_additional_info */
1508 ph->fid_persistent,
1509 ph->fid_volatile);
1510 }
1511
1512 /***************************************************************
1513 Wrapper that allows SMB2 to query disk attributes (size).
1514 Synchronous only.
1515 ***************************************************************/
1516
1517 NTSTATUS cli_smb2_dskattr(struct cli_state *cli, uint64_t *bsize, uint64_t *total, uint64_t *avail)
1518 {
1519 NTSTATUS status;
1520 uint16_t fnum = 0xffff;
1521 DATA_BLOB outbuf = data_blob_null;
1522 struct smb2_hnd *ph = NULL;
1523 uint32_t sectors_per_unit = 0;
1524 uint32_t bytes_per_sector = 0;
1525 uint64_t total_size = 0;
1526 uint64_t size_free = 0;
1527 TALLOC_CTX *frame = talloc_stackframe();
1528
1529 if (smbXcli_conn_has_async_calls(cli->conn)) {
1530 /*
1531 * Can't use sync call while an async call is in flight
1532 */
1533 status = NT_STATUS_INVALID_PARAMETER;
1534 goto fail;
1535 }
1536
1537 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1538 status = NT_STATUS_INVALID_PARAMETER;
1539 goto fail;
1540 }
1541
1542 /* First open the top level directory. */
1543 status = cli_smb2_create_fnum(cli,
1544 "",
1545 0, /* create_flags */
1546 FILE_READ_ATTRIBUTES, /* desired_access */
1547 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1548 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1549 FILE_OPEN, /* create_disposition */
1550 FILE_DIRECTORY_FILE, /* create_options */
1551 &fnum,
1552 NULL);
1553
1554 if (!NT_STATUS_IS_OK(status)) {
1555 goto fail;
1556 }
1557
1558 status = map_fnum_to_smb2_handle(cli,
1559 fnum,
1560 &ph);
1561 if (!NT_STATUS_IS_OK(status)) {
1562 goto fail;
1563 }
1564
1565 /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
1566 level 3 (SMB_FS_SIZE_INFORMATION). */
1567
1568 status = smb2cli_query_info(cli->conn,
1569 cli->timeout,
1570 cli->smb2.session,
1571 cli->smb2.tcon,
1572 2, /* in_info_type */
1573 3, /* in_file_info_class */
1574 0xFFFF, /* in_max_output_length */
1575 NULL, /* in_input_buffer */
1576 0, /* in_additional_info */
1577 0, /* in_flags */
1578 ph->fid_persistent,
1579 ph->fid_volatile,
1580 frame,
1581 &outbuf);
1582 if (!NT_STATUS_IS_OK(status)) {
1583 goto fail;
1584 }
1585
1586 /* Parse the reply. */
1587 if (outbuf.length != 24) {
1588 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1589 goto fail;
1590 }
1591
1592 total_size = BVAL(outbuf.data, 0);
1593 size_free = BVAL(outbuf.data, 8);
1594 sectors_per_unit = IVAL(outbuf.data, 16);
1595 bytes_per_sector = IVAL(outbuf.data, 20);
1596
1597 if (bsize) {
1598 *bsize = (uint64_t)sectors_per_unit * (uint64_t)bytes_per_sector;
1599 }
1600 if (total) {
1601 *total = total_size;
1602 }
1603 if (avail) {
1604 *avail = size_free;
1605 }
1606
1607 status = NT_STATUS_OK;
1608
1609 fail:
1610
1611 if (fnum != 0xffff) {
1612 cli_smb2_close_fnum(cli, fnum);
1613 }
1614
1615 TALLOC_FREE(frame);
1616 return status;
1617 }
1618
1619 /***************************************************************
1620 Wrapper that allows SMB2 to query a security descriptor.
1621 Synchronous only.
1622 ***************************************************************/
1623
1624 NTSTATUS cli_smb2_query_security_descriptor(struct cli_state *cli,
1625 uint16_t fnum,
1626 uint32_t sec_info,
1627 TALLOC_CTX *mem_ctx,
1628 struct security_descriptor **ppsd)
1629 {
1630 NTSTATUS status;
1631 DATA_BLOB outbuf = data_blob_null;
1632 struct smb2_hnd *ph = NULL;
1633 struct security_descriptor *lsd = NULL;
1634 TALLOC_CTX *frame = talloc_stackframe();
1635
1636 if (smbXcli_conn_has_async_calls(cli->conn)) {
1637 /*
1638 * Can't use sync call while an async call is in flight
1639 */
1640 status = NT_STATUS_INVALID_PARAMETER;
1641 goto fail;
1642 }
1643
1644 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1645 status = NT_STATUS_INVALID_PARAMETER;
1646 goto fail;
1647 }
1648
1649 status = map_fnum_to_smb2_handle(cli,
1650 fnum,
1651 &ph);
1652 if (!NT_STATUS_IS_OK(status)) {
1653 goto fail;
1654 }
1655
1656 /* getinfo on the returned handle with info_type SMB2_GETINFO_SEC (3) */
1657
1658 status = smb2cli_query_info(cli->conn,
1659 cli->timeout,
1660 cli->smb2.session,
1661 cli->smb2.tcon,
1662 3, /* in_info_type */
1663 0, /* in_file_info_class */
1664 0xFFFF, /* in_max_output_length */
1665 NULL, /* in_input_buffer */
1666 sec_info, /* in_additional_info */
1667 0, /* in_flags */
1668 ph->fid_persistent,
1669 ph->fid_volatile,
1670 frame,
1671 &outbuf);
1672
1673 if (!NT_STATUS_IS_OK(status)) {
1674 goto fail;
1675 }
1676
1677 /* Parse the reply. */
1678 status = unmarshall_sec_desc(mem_ctx,
1679 outbuf.data,
1680 outbuf.length,
1681 &lsd);
1682
1683 if (!NT_STATUS_IS_OK(status)) {
1684 goto fail;
1685 }
1686
1687 if (ppsd != NULL) {
1688 *ppsd = lsd;
1689 } else {
1690 TALLOC_FREE(lsd);
1691 }
1692
1693 fail:
1694
1695 TALLOC_FREE(frame);
1696 return status;
1697 }
1698
1699 /***************************************************************
1700 Wrapper that allows SMB2 to set a security descriptor.
1701 Synchronous only.
1702 ***************************************************************/
1703
1704 NTSTATUS cli_smb2_set_security_descriptor(struct cli_state *cli,
1705 uint16_t fnum,
1706 uint32_t sec_info,
1707 const struct security_descriptor *sd)
1708 {
1709 NTSTATUS status;
1710 DATA_BLOB inbuf = data_blob_null;
1711 struct smb2_hnd *ph = NULL;
1712 TALLOC_CTX *frame = talloc_stackframe();
1713
1714 if (smbXcli_conn_has_async_calls(cli->conn)) {
1715 /*
1716 * Can't use sync call while an async call is in flight
1717 */
1718 status = NT_STATUS_INVALID_PARAMETER;
1719 goto fail;
1720 }
1721
1722 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1723 status = NT_STATUS_INVALID_PARAMETER;
1724 goto fail;
1725 }
1726
1727 status = map_fnum_to_smb2_handle(cli,
1728 fnum,
1729 &ph);
1730 if (!NT_STATUS_IS_OK(status)) {
1731 goto fail;
1732 }
1733
1734 status = marshall_sec_desc(frame,
1735 sd,
1736 &inbuf.data,
1737 &inbuf.length);
1738
1739 if (!NT_STATUS_IS_OK(status)) {
1740 goto fail;
1741 }
1742
1743 /* setinfo on the returned handle with info_type SMB2_SETINFO_SEC (3) */
1744
1745 status = smb2cli_set_info(cli->conn,
1746 cli->timeout,
1747 cli->smb2.session,
1748 cli->smb2.tcon,
1749 3, /* in_info_type */
1750 0, /* in_file_info_class */
1751 &inbuf, /* in_input_buffer */
1752 sec_info, /* in_additional_info */
1753 ph->fid_persistent,
1754 ph->fid_volatile);
1755
1756 fail:
1757
1758 TALLOC_FREE(frame);
1759 return status;
1760 }
1761
1762 /***************************************************************
1763 Wrapper that allows SMB2 to rename a file.
1764 Synchronous only.
1765 ***************************************************************/
1766
1767 NTSTATUS cli_smb2_rename(struct cli_state *cli,
1768 const char *fname_src,
1769 const char *fname_dst)
1770 {
1771 NTSTATUS status;
1772 DATA_BLOB inbuf = data_blob_null;
1773 uint16_t fnum = 0xffff;
1774 struct smb2_hnd *ph = NULL;
1775 smb_ucs2_t *converted_str = NULL;
1776 size_t converted_size_bytes = 0;
1777 size_t namelen = 0;
1778 TALLOC_CTX *frame = talloc_stackframe();
1779
1780 if (smbXcli_conn_has_async_calls(cli->conn)) {
1781 /*
1782 * Can't use sync call while an async call is in flight
1783 */
1784 status = NT_STATUS_INVALID_PARAMETER;
1785 goto fail;
1786 }
1787
1788 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1789 status = NT_STATUS_INVALID_PARAMETER;
1790 goto fail;
1791 }
1792
1793 status = get_fnum_from_path(cli,
1794 fname_src,
1795 DELETE_ACCESS,
1796 &fnum);
1797
1798 if (!NT_STATUS_IS_OK(status)) {
1799 goto fail;
1800 }
1801
1802 status = map_fnum_to_smb2_handle(cli,
1803 fnum,
1804 &ph);
1805 if (!NT_STATUS_IS_OK(status)) {
1806 goto fail;
1807 }
1808
1809 /* SMB2 is pickier about pathnames. Ensure it doesn't
1810 start in a '\' */
1811 if (*fname_dst == '\\') {
1812 fname_dst++;
1813 }
1814
1815 /* SMB2 is pickier about pathnames. Ensure it doesn't
1816 end in a '\' */
1817 namelen = strlen(fname_dst);
1818 if (namelen > 0 && fname_dst[namelen-1] == '\\') {
1819 char *modname = talloc_strdup(frame, fname_dst);
1820 modname[namelen-1] = '\0';
1821 fname_dst = modname;
1822 }
1823
1824 if (!push_ucs2_talloc(frame,
1825 &converted_str,
1826 fname_dst,
1827 &converted_size_bytes)) {
1828 status = NT_STATUS_INVALID_PARAMETER;
1829 goto fail;
1830 }
1831
1832 /* W2K8 insists the dest name is not null
1833 terminated. Remove the last 2 zero bytes
1834 and reduce the name length. */
1835
1836 if (converted_size_bytes < 2) {
1837 status = NT_STATUS_INVALID_PARAMETER;
1838 goto fail;
1839 }
1840 converted_size_bytes -= 2;
1841
1842 inbuf = data_blob_talloc_zero(frame,
1843 20 + converted_size_bytes);
1844 if (inbuf.data == NULL) {
1845 status = NT_STATUS_NO_MEMORY;
1846 goto fail;
1847 }
1848
1849 SIVAL(inbuf.data, 16, converted_size_bytes);
1850 memcpy(inbuf.data + 20, converted_str, converted_size_bytes);
1851
1852 /* setinfo on the returned handle with info_type SMB2_GETINFO_FILE (1),
1853 level SMB2_FILE_RENAME_INFORMATION (SMB_FILE_RENAME_INFORMATION - 1000) */
1854
1855 status = smb2cli_set_info(cli->conn,
1856 cli->timeout,
1857 cli->smb2.session,
1858 cli->smb2.tcon,
1859 1, /* in_info_type */
1860 SMB_FILE_RENAME_INFORMATION - 1000, /* in_file_info_class */
1861 &inbuf, /* in_input_buffer */
1862 0, /* in_additional_info */
1863 ph->fid_persistent,
1864 ph->fid_volatile);
1865
1866 fail:
1867
1868 if (fnum != 0xffff) {
1869 cli_smb2_close_fnum(cli, fnum);
1870 }
1871
1872 TALLOC_FREE(frame);
1873 return status;
1874 }
1875
1876 /***************************************************************
1877 Wrapper that allows SMB2 to set an EA on a fnum.
1878 Synchronous only.
1879 ***************************************************************/
1880
1881 NTSTATUS cli_smb2_set_ea_fnum(struct cli_state *cli,
1882 uint16_t fnum,
1883 const char *ea_name,
1884 const char *ea_val,
1885 size_t ea_len)
1886 {
1887 NTSTATUS status;
1888 DATA_BLOB inbuf = data_blob_null;
1889 size_t bloblen = 0;
1890 char *ea_name_ascii = NULL;
1891 size_t namelen = 0;
1892 struct smb2_hnd *ph = NULL;
1893 TALLOC_CTX *frame = talloc_stackframe();
1894
1895 if (smbXcli_conn_has_async_calls(cli->conn)) {
1896 /*
1897 * Can't use sync call while an async call is in flight
1898 */
1899 status = NT_STATUS_INVALID_PARAMETER;
1900 goto fail;
1901 }
1902
1903 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1904 status = NT_STATUS_INVALID_PARAMETER;
1905 goto fail;
1906 }
1907
1908 status = map_fnum_to_smb2_handle(cli,
1909 fnum,
1910 &ph);
1911 if (!NT_STATUS_IS_OK(status)) {
1912 goto fail;
1913 }
1914
1915 /* Marshall the SMB2 EA data. */
1916 if (ea_len > 0xFFFF) {
1917 status = NT_STATUS_INVALID_PARAMETER;
1918 goto fail;
1919 }
1920
1921 if (!push_ascii_talloc(frame,
1922 &ea_name_ascii,
1923 ea_name,
1924 &namelen)) {
1925 status = NT_STATUS_INVALID_PARAMETER;
1926 goto fail;
1927 }
1928
1929 if (namelen < 2 || namelen > 0xFF) {
1930 status = NT_STATUS_INVALID_PARAMETER;
1931 goto fail;
1932 }
1933
1934 bloblen = 8 + ea_len + namelen;
1935 /* Round up to a 4 byte boundary. */
1936 bloblen = ((bloblen + 3)&~3);
1937
1938 inbuf = data_blob_talloc_zero(frame, bloblen);
1939 if (inbuf.data == NULL) {
1940 status = NT_STATUS_NO_MEMORY;
1941 goto fail;
1942 }
1943 /* namelen doesn't include the NULL byte. */
1944 SCVAL(inbuf.data, 5, namelen - 1);
1945 SSVAL(inbuf.data, 6, ea_len);
1946 memcpy(inbuf.data + 8, ea_name_ascii, namelen);
1947 memcpy(inbuf.data + 8 + namelen, ea_val, ea_len);
1948
1949 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1950 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
1951
1952 status = smb2cli_set_info(cli->conn,
1953 cli->timeout,
1954 cli->smb2.session,
1955 cli->smb2.tcon,
1956 1, /* in_info_type */
1957 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
1958 &inbuf, /* in_input_buffer */
1959 0, /* in_additional_info */
1960 ph->fid_persistent,
1961 ph->fid_volatile);
1962
1963 fail:
1964
1965 TALLOC_FREE(frame);
1966 return status;
1967 }
1968
1969 /***************************************************************
1970 Wrapper that allows SMB2 to set an EA on a pathname.
1971 Synchronous only.
1972 ***************************************************************/
1973
1974 NTSTATUS cli_smb2_set_ea_path(struct cli_state *cli,
1975 const char *name,
1976 const char *ea_name,
1977 const char *ea_val,
1978 size_t ea_len)
1979 {
1980 NTSTATUS status;
1981 uint16_t fnum = 0xffff;
1982
1983 if (smbXcli_conn_has_async_calls(cli->conn)) {
1984 /*
1985 * Can't use sync call while an async call is in flight
1986 */
1987 status = NT_STATUS_INVALID_PARAMETER;
1988 goto fail;
1989 }
1990
1991 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1992 status = NT_STATUS_INVALID_PARAMETER;
1993 goto fail;
1994 }
1995
1996 status = get_fnum_from_path(cli,
1997 name,
1998 FILE_WRITE_EA,
1999 &fnum);
2000
2001 if (!NT_STATUS_IS_OK(status)) {
2002 goto fail;
2003 }
2004
2005 status = cli_set_ea_fnum(cli,
2006 fnum,
2007 ea_name,
2008 ea_val,
2009 ea_len);
2010 if (!NT_STATUS_IS_OK(status)) {
2011 goto fail;
2012 }
2013
2014 fail:
2015
2016 if (fnum != 0xffff) {
2017 cli_smb2_close_fnum(cli, fnum);
2018 }
2019
2020 return status;
2021 }
2022
2023 /***************************************************************
2024 Wrapper that allows SMB2 to get an EA list on a pathname.
2025 Synchronous only.
2026 ***************************************************************/
2027
2028 NTSTATUS cli_smb2_get_ea_list_path(struct cli_state *cli,
2029 const char *name,
2030 TALLOC_CTX *ctx,
2031 size_t *pnum_eas,
2032 struct ea_struct **pea_array)
2033 {
2034 NTSTATUS status;
2035 uint16_t fnum = 0xffff;
2036 DATA_BLOB outbuf = data_blob_null;
2037 struct smb2_hnd *ph = NULL;
2038 struct ea_list *ea_list = NULL;
2039 struct ea_list *eal = NULL;
2040 size_t ea_count = 0;
2041 TALLOC_CTX *frame = talloc_stackframe();
2042
2043 *pnum_eas = 0;
2044 *pea_array = NULL;
2045
2046 if (smbXcli_conn_has_async_calls(cli->conn)) {
2047 /*
2048 * Can't use sync call while an async call is in flight
2049 */
2050 status = NT_STATUS_INVALID_PARAMETER;
2051 goto fail;
2052 }
2053
2054 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2055 status = NT_STATUS_INVALID_PARAMETER;
2056 goto fail;
2057 }
2058
2059 status = get_fnum_from_path(cli,
2060 name,
2061 FILE_READ_EA,
2062 &fnum);
2063
2064 if (!NT_STATUS_IS_OK(status)) {
2065 goto fail;
2066 }
2067
2068 status = map_fnum_to_smb2_handle(cli,
2069 fnum,
2070 &ph);
2071 if (!NT_STATUS_IS_OK(status)) {
2072 goto fail;
2073 }
2074
2075 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
2076 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
2077
2078 status = smb2cli_query_info(cli->conn,
2079 cli->timeout,
2080 cli->smb2.session,
2081 cli->smb2.tcon,
2082 1, /* in_info_type */
2083 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
2084 0xFFFF, /* in_max_output_length */
2085 NULL, /* in_input_buffer */
2086 0, /* in_additional_info */
2087 0, /* in_flags */
2088 ph->fid_persistent,
2089 ph->fid_volatile,
2090 frame,
2091 &outbuf);
2092
2093 if (!NT_STATUS_IS_OK(status)) {
2094 goto fail;
2095 }
2096
2097 /* Parse the reply. */
2098 ea_list = read_nttrans_ea_list(ctx,
2099 (const char *)outbuf.data,
2100 outbuf.length);
2101 if (ea_list == NULL) {
2102 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2103 goto fail;
2104 }
2105
2106 /* Convert to an array. */
2107 for (eal = ea_list; eal; eal = eal->next) {
2108 ea_count++;
2109 }
2110
2111 if (ea_count) {
2112 *pea_array = talloc_array(ctx, struct ea_struct, ea_count);
2113 if (*pea_array == NULL) {
2114 status = NT_STATUS_NO_MEMORY;
2115 goto fail;
2116 }
2117 ea_count = 0;
2118 for (eal = ea_list; eal; eal = eal->next) {
2119 (*pea_array)[ea_count++] = ea_list->ea;
2120 }
2121 *pnum_eas = ea_count;
2122 }
2123
2124 fail:
2125
2126 if (fnum != 0xffff) {
2127 cli_smb2_close_fnum(cli, fnum);
2128 }
2129
2130 TALLOC_FREE(frame);
2131 return status;
2132 }
2133
2134 struct cli_smb2_read_state {
2135 struct tevent_context *ev;
2136 struct cli_state *cli;
2137 struct smb2_hnd *ph;
2138 uint64_t start_offset;
2139 uint32_t size;
2140 uint32_t received;
2141 uint8_t *buf;
2142 };
2143
2144 static void cli_smb2_read_done(struct tevent_req *subreq);
2145
2146 struct tevent_req *cli_smb2_read_send(TALLOC_CTX *mem_ctx,
2147 struct tevent_context *ev,
2148 struct cli_state *cli,
2149 uint16_t fnum,
2150 off_t offset,
2151 size_t size)
2152 {
2153 NTSTATUS status;
2154 struct tevent_req *req, *subreq;
2155 struct cli_smb2_read_state *state;
2156
2157 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_read_state);
2158 if (req == NULL) {
2159 return NULL;
2160 }
2161 state->ev = ev;
2162 state->cli = cli;
2163 state->start_offset = (uint64_t)offset;
2164 state->size = (uint32_t)size;
2165 state->received = 0;
2166 state->buf = NULL;
2167
2168 status = map_fnum_to_smb2_handle(cli,
2169 fnum,
2170 &state->ph);
2171 if (tevent_req_nterror(req, status)) {
2172 return tevent_req_post(req, ev);
2173 }
2174
2175 subreq = smb2cli_read_send(state,
2176 state->ev,
2177 state->cli->conn,
2178 state->cli->timeout,
2179 state->cli->smb2.session,
2180 state->cli->smb2.tcon,
2181 state->size,
2182 state->start_offset,
2183 state->ph->fid_persistent,
2184 state->ph->fid_volatile,
2185 0, /* minimum_count */
2186 0); /* remaining_bytes */
2187
2188 if (tevent_req_nomem(subreq, req)) {
2189 return tevent_req_post(req, ev);
2190 }
2191 tevent_req_set_callback(subreq, cli_smb2_read_done, req);
2192 return req;
2193 }
2194
2195 static void cli_smb2_read_done(struct tevent_req *subreq)
2196 {
2197 struct tevent_req *req = tevent_req_callback_data(
2198 subreq, struct tevent_req);
2199 struct cli_smb2_read_state *state = tevent_req_data(
2200 req, struct cli_smb2_read_state);
2201 NTSTATUS status;
2202
2203 status = smb2cli_read_recv(subreq, state,
2204 &state->buf, &state->received);
2205 if (tevent_req_nterror(req, status)) {
2206 return;
2207 }
2208
2209 if (state->received > state->size) {
2210 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2211 return;
2212 }
2213
2214 tevent_req_done(req);
2215 }
2216
2217 NTSTATUS cli_smb2_read_recv(struct tevent_req *req,
2218 ssize_t *received,
2219 uint8_t **rcvbuf)
2220 {
2221 NTSTATUS status;
2222 struct cli_smb2_read_state *state = tevent_req_data(
2223 req, struct cli_smb2_read_state);
2224
2225 if (tevent_req_is_nterror(req, &status)) {
2226 return status;
2227 }
2228 /*
2229 * As in cli_read_andx_recv() rcvbuf is talloced from the request, so
2230 * better make sure that you copy it away before you talloc_free(req).
2231 * "rcvbuf" is NOT a talloc_ctx of its own, so do not talloc_move it!
2232 */
2233 *received = (ssize_t)state->received;
2234 *rcvbuf = state->buf;
2235 return NT_STATUS_OK;
2236 }
2237
2238 struct cli_smb2_write_state {
2239 struct tevent_context *ev;
2240 struct cli_state *cli;
2241 struct smb2_hnd *ph;
2242 uint32_t flags;
2243 const uint8_t *buf;
2244 uint64_t offset;
2245 uint32_t size;
2246 uint32_t written;
2247 };
2248
2249 static void cli_smb2_write_written(struct tevent_req *req);
2250
2251 struct tevent_req *cli_smb2_write_send(TALLOC_CTX *mem_ctx,
2252 struct tevent_context *ev,
2253 struct cli_state *cli,
2254 uint16_t fnum,
2255 uint16_t mode,
2256 const uint8_t *buf,
2257 off_t offset,
2258 size_t size)
2259 {
2260 NTSTATUS status;
2261 struct tevent_req *req, *subreq = NULL;
2262 struct cli_smb2_write_state *state = NULL;
2263
2264 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_write_state);
2265 if (req == NULL) {
2266 return NULL;
2267 }
2268 state->ev = ev;
2269 state->cli = cli;
2270 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2271 state->flags = (uint32_t)mode;
2272 state->buf = buf;
2273 state->offset = (uint64_t)offset;
2274 state->size = (uint32_t)size;
2275 state->written = 0;
2276
2277 status = map_fnum_to_smb2_handle(cli,
2278 fnum,
2279 &state->ph);
2280 if (tevent_req_nterror(req, status)) {
2281 return tevent_req_post(req, ev);
2282 }
2283
2284 subreq = smb2cli_write_send(state,
2285 state->ev,
2286 state->cli->conn,
2287 state->cli->timeout,
2288 state->cli->smb2.session,
2289 state->cli->smb2.tcon,
2290 state->size,
2291 state->offset,
2292 state->ph->fid_persistent,
2293 state->ph->fid_volatile,
2294 0, /* remaining_bytes */
2295 state->flags, /* flags */
2296 state->buf);
2297
2298 if (tevent_req_nomem(subreq, req)) {
2299 return tevent_req_post(req, ev);
2300 }
2301 tevent_req_set_callback(subreq, cli_smb2_write_written, req);
2302 return req;
2303 }
2304
2305 static void cli_smb2_write_written(struct tevent_req *subreq)
2306 {
2307 struct tevent_req *req = tevent_req_callback_data(
2308 subreq, struct tevent_req);
2309 struct cli_smb2_write_state *state = tevent_req_data(
2310 req, struct cli_smb2_write_state);
2311 NTSTATUS status;
2312 uint32_t written;
2313
2314 status = smb2cli_write_recv(subreq, &written);
2315 TALLOC_FREE(subreq);
2316 if (tevent_req_nterror(req, status)) {
2317 return;
2318 }
2319
2320 state->written = written;
2321
2322 tevent_req_done(req);
2323 }
2324
2325 NTSTATUS cli_smb2_write_recv(struct tevent_req *req,
2326 size_t *pwritten)
2327 {
2328 struct cli_smb2_write_state *state = tevent_req_data(
2329 req, struct cli_smb2_write_state);
2330 NTSTATUS status;
2331
2332 if (tevent_req_is_nterror(req, &status)) {
2333 tevent_req_received(req);
2334 return status;
2335 }
2336
2337 if (pwritten != NULL) {
2338 *pwritten = (size_t)state->written;
2339 }
2340 tevent_req_received(req);
2341 return NT_STATUS_OK;
2342 }
2343
2344 /***************************************************************
2345 Wrapper that allows SMB2 async write using an fnum.
2346 This is mostly cut-and-paste from Volker's code inside
2347 source3/libsmb/clireadwrite.c, adapted for SMB2.
2348
2349 Done this way so I can reuse all the logic inside cli_push()
2350 for free :-).
2351 ***************************************************************/
2352
2353 struct cli_smb2_writeall_state {
2354 struct tevent_context *ev;
2355 struct cli_state *cli;
2356 struct smb2_hnd *ph;
2357 uint32_t flags;
2358 const uint8_t *buf;
2359 uint64_t offset;
2360 uint32_t size;
2361 uint32_t written;
2362 };
2363
2364 static void cli_smb2_writeall_written(struct tevent_req *req);
2365
2366 struct tevent_req *cli_smb2_writeall_send(TALLOC_CTX *mem_ctx,
2367 struct tevent_context *ev,
2368 struct cli_state *cli,
2369 uint16_t fnum,
2370 uint16_t mode,
2371 const uint8_t *buf,
2372 off_t offset,
2373 size_t size)
2374 {
2375 NTSTATUS status;
2376 struct tevent_req *req, *subreq = NULL;
2377 struct cli_smb2_writeall_state *state = NULL;
2378 uint32_t to_write;
2379 uint32_t max_size;
2380 bool ok;
2381
2382 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_writeall_state);
2383 if (req == NULL) {
2384 return NULL;
2385 }
2386 state->ev = ev;
2387 state->cli = cli;
2388 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2389 state->flags = (uint32_t)mode;
2390 state->buf = buf;
2391 state->offset = (uint64_t)offset;
2392 state->size = (uint32_t)size;
2393 state->written = 0;
2394
2395 status = map_fnum_to_smb2_handle(cli,
2396 fnum,
2397 &state->ph);
2398 if (tevent_req_nterror(req, status)) {
2399 return tevent_req_post(req, ev);
2400 }
2401
2402 to_write = state->size;
2403 max_size = smb2cli_conn_max_write_size(state->cli->conn);
2404 to_write = MIN(max_size, to_write);
2405 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2406 if (ok) {
2407 to_write = MIN(max_size, to_write);
2408 }
2409
2410 subreq = smb2cli_write_send(state,
2411 state->ev,
2412 state->cli->conn,
2413 state->cli->timeout,
2414 state->cli->smb2.session,
2415 state->cli->smb2.tcon,
2416 to_write,
2417 state->offset,
2418 state->ph->fid_persistent,
2419 state->ph->fid_volatile,
2420 0, /* remaining_bytes */
2421 state->flags, /* flags */
2422 state->buf + state->written);
2423
2424 if (tevent_req_nomem(subreq, req)) {
2425 return tevent_req_post(req, ev);
2426 }
2427 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
2428 return req;
2429 }
2430
2431 static void cli_smb2_writeall_written(struct tevent_req *subreq)
2432 {
2433 struct tevent_req *req = tevent_req_callback_data(
2434 subreq, struct tevent_req);
2435 struct cli_smb2_writeall_state *state = tevent_req_data(
2436 req, struct cli_smb2_writeall_state);
2437 NTSTATUS status;
2438 uint32_t written, to_write;
2439 uint32_t max_size;
2440 bool ok;
2441
2442 status = smb2cli_write_recv(subreq, &written);
2443 TALLOC_FREE(subreq);
2444 if (tevent_req_nterror(req, status)) {
2445 return;
2446 }
2447
2448 state->written += written;
2449
2450 if (state->written > state->size) {
2451 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2452 return;
2453 }
2454
2455 to_write = state->size - state->written;
2456
2457 if (to_write == 0) {
2458 tevent_req_done(req);
2459 return;
2460 }
2461
2462 max_size = smb2cli_conn_max_write_size(state->cli->conn);
2463 to_write = MIN(max_size, to_write);
2464 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2465 if (ok) {
2466 to_write = MIN(max_size, to_write);
2467 }
2468
2469 subreq = smb2cli_write_send(state,
2470 state->ev,
2471 state->cli->conn,
2472 state->cli->timeout,
2473 state->cli->smb2.session,
2474 state->cli->smb2.tcon,
2475 to_write,
2476 state->offset + state->written,
2477 state->ph->fid_persistent,
2478 state->ph->fid_volatile,
2479 0, /* remaining_bytes */
2480 state->flags, /* flags */
2481 state->buf + state->written);
2482
2483 if (tevent_req_nomem(subreq, req)) {
2484 return;
2485 }
2486 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
2487 }
2488
2489 NTSTATUS cli_smb2_writeall_recv(struct tevent_req *req,
2490 size_t *pwritten)
2491 {
2492 struct cli_smb2_writeall_state *state = tevent_req_data(
2493 req, struct cli_smb2_writeall_state);
2494 NTSTATUS status;
2495
2496 if (tevent_req_is_nterror(req, &status)) {
2497 return status;
2498 }
2499 if (pwritten != NULL) {
2500 *pwritten = (size_t)state->written;
2501 }
2502 return NT_STATUS_OK;
2503 }
Samba GIT mirror