2 Unix SMB/CIFS implementation.
4 Copyright (C) Jeremy Allison 2013
5 Copyright (C) Volker Lendecke 2013
6 Copyright (C) Stefan Metzmacher 2013
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.
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.
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/>.
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.
31 #include "async_smb.h"
32 #include "../libcli/smb/smbXcli_base.h"
34 #include "cli_smb2_fnum.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"
44 uint64_t fid_persistent;
45 uint64_t fid_volatile;
49 * Handle mapping code.
52 /***************************************************************
53 Allocate a new fnum between 1 and 0xFFFE from an smb2_hnd.
54 Ensures handle is owned by cli struct.
55 ***************************************************************/
57 static NTSTATUS map_smb2_handle_to_fnum(struct cli_state *cli,
58 const struct smb2_hnd *ph, /* In */
59 uint16_t *pfnum) /* Out */
62 struct idr_context *idp = cli->smb2.open_handles;
63 struct smb2_hnd *owned_h = talloc_memdup(cli,
65 sizeof(struct smb2_hnd));
67 if (owned_h == NULL) {
68 return NT_STATUS_NO_MEMORY;
73 cli->smb2.open_handles = idr_init(cli);
74 if (cli->smb2.open_handles == NULL) {
76 return NT_STATUS_NO_MEMORY;
78 idp = cli->smb2.open_handles;
81 ret = idr_get_new_above(idp, owned_h, 1, 0xFFFE);
84 return NT_STATUS_NO_MEMORY;
87 *pfnum = (uint16_t)ret;
91 /***************************************************************
92 Return the smb2_hnd pointer associated with the given fnum.
93 ***************************************************************/
95 static NTSTATUS map_fnum_to_smb2_handle(struct cli_state *cli,
96 uint16_t fnum, /* In */
97 struct smb2_hnd **pph) /* Out */
99 struct idr_context *idp = cli->smb2.open_handles;
102 return NT_STATUS_INVALID_PARAMETER;
104 *pph = (struct smb2_hnd *)idr_find(idp, fnum);
106 return NT_STATUS_INVALID_HANDLE;
111 /***************************************************************
112 Delete the fnum to smb2_hnd mapping. Zeros out handle on
114 ***************************************************************/
116 static NTSTATUS delete_smb2_handle_mapping(struct cli_state *cli,
117 struct smb2_hnd **pph, /* In */
118 uint16_t fnum) /* In */
120 struct idr_context *idp = cli->smb2.open_handles;
124 return NT_STATUS_INVALID_PARAMETER;
127 ph = (struct smb2_hnd *)idr_find(idp, fnum);
129 return NT_STATUS_INVALID_PARAMETER;
131 idr_remove(idp, fnum);
136 /***************************************************************
138 ***************************************************************/
140 static uint8_t flags_to_smb2_oplock(uint32_t create_flags)
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;
148 /* create_flags doesn't do a level2 request. */
149 return SMB2_OPLOCK_LEVEL_NONE;
152 /***************************************************************
153 Small wrapper that allows SMB2 create to return a uint16_t fnum.
155 ***************************************************************/
157 NTSTATUS cli_smb2_create_fnum(struct cli_state *cli,
159 uint32_t create_flags,
160 uint32_t desired_access,
161 uint32_t file_attributes,
162 uint32_t share_access,
163 uint32_t create_disposition,
164 uint32_t create_options,
166 struct smb2_create_returns *cr)
171 if (smbXcli_conn_has_async_calls(cli->conn)) {
173 * Can't use sync call while an async call is in flight
175 return NT_STATUS_INVALID_PARAMETER;
178 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
179 return NT_STATUS_INVALID_PARAMETER;
182 if (cli->backup_intent) {
183 create_options |= FILE_OPEN_FOR_BACKUP_INTENT;
186 /* SMB2 is pickier about pathnames. Ensure it doesn't
188 if (*fname == '\\') {
192 status = smb2cli_create(cli->conn,
197 flags_to_smb2_oplock(create_flags),
198 SMB2_IMPERSONATION_IMPERSONATION,
209 if (NT_STATUS_IS_OK(status)) {
210 status = map_smb2_handle_to_fnum(cli, &h, pfid);
216 /***************************************************************
217 Small wrapper that allows SMB2 close to use a uint16_t fnum.
219 ***************************************************************/
221 NTSTATUS cli_smb2_close_fnum(struct cli_state *cli, uint16_t fnum)
223 struct smb2_hnd *ph = NULL;
226 if (smbXcli_conn_has_async_calls(cli->conn)) {
228 * Can't use sync call while an async call is in flight
230 return NT_STATUS_INVALID_PARAMETER;
233 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
234 return NT_STATUS_INVALID_PARAMETER;
237 status = map_fnum_to_smb2_handle(cli,
240 if (!NT_STATUS_IS_OK(status)) {
244 status = smb2cli_close(cli->conn,
252 /* Delete the fnum -> handle mapping. */
253 if (NT_STATUS_IS_OK(status)) {
254 status = delete_smb2_handle_mapping(cli, &ph, fnum);
260 /***************************************************************
261 Small wrapper that allows SMB2 to create a directory
263 ***************************************************************/
265 NTSTATUS cli_smb2_mkdir(struct cli_state *cli, const char *dname)
270 if (smbXcli_conn_has_async_calls(cli->conn)) {
272 * Can't use sync call while an async call is in flight
274 return NT_STATUS_INVALID_PARAMETER;
277 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
278 return NT_STATUS_INVALID_PARAMETER;
281 status = cli_smb2_create_fnum(cli,
283 0, /* create_flags */
284 FILE_READ_ATTRIBUTES, /* desired_access */
285 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
286 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
287 FILE_CREATE, /* create_disposition */
288 FILE_DIRECTORY_FILE, /* create_options */
292 if (!NT_STATUS_IS_OK(status)) {
295 return cli_smb2_close_fnum(cli, fnum);
298 /***************************************************************
299 Small wrapper that allows SMB2 to delete a directory
301 ***************************************************************/
303 NTSTATUS cli_smb2_rmdir(struct cli_state *cli, const char *dname)
308 if (smbXcli_conn_has_async_calls(cli->conn)) {
310 * Can't use sync call while an async call is in flight
312 return NT_STATUS_INVALID_PARAMETER;
315 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
316 return NT_STATUS_INVALID_PARAMETER;
319 status = cli_smb2_create_fnum(cli,
321 0, /* create_flags */
322 DELETE_ACCESS, /* desired_access */
323 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
324 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
325 FILE_OPEN, /* create_disposition */
326 FILE_DIRECTORY_FILE|FILE_DELETE_ON_CLOSE, /* create_options */
330 if (!NT_STATUS_IS_OK(status)) {
333 return cli_smb2_close_fnum(cli, fnum);
336 /***************************************************************
337 Small wrapper that allows SMB2 to unlink a pathname.
339 ***************************************************************/
341 NTSTATUS cli_smb2_unlink(struct cli_state *cli, const char *fname)
346 if (smbXcli_conn_has_async_calls(cli->conn)) {
348 * Can't use sync call while an async call is in flight
350 return NT_STATUS_INVALID_PARAMETER;
353 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
354 return NT_STATUS_INVALID_PARAMETER;
357 status = cli_smb2_create_fnum(cli,
359 0, /* create_flags */
360 DELETE_ACCESS, /* desired_access */
361 FILE_ATTRIBUTE_NORMAL, /* file attributes */
362 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
363 FILE_OPEN, /* create_disposition */
364 FILE_DELETE_ON_CLOSE, /* create_options */
368 if (!NT_STATUS_IS_OK(status)) {
371 return cli_smb2_close_fnum(cli, fnum);
374 /***************************************************************
375 Utility function to parse a SMB2_FIND_ID_BOTH_DIRECTORY_INFO reply.
376 ***************************************************************/
378 static NTSTATUS parse_finfo_id_both_directory_info(uint8_t *dir_data,
379 uint32_t dir_data_length,
380 struct file_info *finfo,
381 uint32_t *next_offset)
387 if (dir_data_length < 4) {
388 return NT_STATUS_INFO_LENGTH_MISMATCH;
391 *next_offset = IVAL(dir_data, 0);
393 if (*next_offset > dir_data_length) {
394 return NT_STATUS_INFO_LENGTH_MISMATCH;
397 if (*next_offset != 0) {
398 /* Ensure we only read what in this record. */
399 dir_data_length = *next_offset;
402 if (dir_data_length < 105) {
403 return NT_STATUS_INFO_LENGTH_MISMATCH;
406 finfo->atime_ts = interpret_long_date((const char *)dir_data + 16);
407 finfo->mtime_ts = interpret_long_date((const char *)dir_data + 24);
408 finfo->ctime_ts = interpret_long_date((const char *)dir_data + 32);
409 finfo->size = IVAL2_TO_SMB_BIG_UINT(dir_data + 40, 0);
410 finfo->mode = CVAL(dir_data + 56, 0);
411 namelen = IVAL(dir_data + 60,0);
412 if (namelen > (dir_data_length - 104)) {
413 return NT_STATUS_INFO_LENGTH_MISMATCH;
415 slen = CVAL(dir_data + 68, 0);
417 return NT_STATUS_INFO_LENGTH_MISMATCH;
419 ret = pull_string_talloc(finfo,
421 FLAGS2_UNICODE_STRINGS,
426 if (ret == (size_t)-1) {
427 /* Bad conversion. */
428 return NT_STATUS_INVALID_NETWORK_RESPONSE;
431 ret = pull_string_talloc(finfo,
433 FLAGS2_UNICODE_STRINGS,
438 if (ret == (size_t)-1) {
439 /* Bad conversion. */
440 return NT_STATUS_INVALID_NETWORK_RESPONSE;
445 /*******************************************************************
446 Given a filename - get its directory name
447 ********************************************************************/
449 static bool windows_parent_dirname(TALLOC_CTX *mem_ctx,
457 p = strrchr_m(dir, '\\'); /* Find final '\\', if any */
460 if (!(*parent = talloc_strdup(mem_ctx, "\\"))) {
471 if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
474 (*parent)[len] = '\0';
482 /***************************************************************
483 Wrapper that allows SMB2 to list a directory.
485 ***************************************************************/
487 NTSTATUS cli_smb2_list(struct cli_state *cli,
488 const char *pathname,
489 NTSTATUS (*fn)(const char *,
496 uint16_t fnum = 0xffff;
497 char *parent_dir = NULL;
498 const char *mask = NULL;
499 struct smb2_hnd *ph = NULL;
500 TALLOC_CTX *frame = talloc_stackframe();
501 TALLOC_CTX *subframe = NULL;
503 if (smbXcli_conn_has_async_calls(cli->conn)) {
505 * Can't use sync call while an async call is in flight
507 status = NT_STATUS_INVALID_PARAMETER;
511 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
512 status = NT_STATUS_INVALID_PARAMETER;
516 /* Get the directory name. */
517 if (!windows_parent_dirname(frame,
521 status = NT_STATUS_NO_MEMORY;
525 status = cli_smb2_create_fnum(cli,
527 0, /* create_flags */
528 SEC_DIR_LIST|SEC_DIR_READ_ATTRIBUTE,/* desired_access */
529 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
530 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
531 FILE_OPEN, /* create_disposition */
532 FILE_DIRECTORY_FILE, /* create_options */
536 if (!NT_STATUS_IS_OK(status)) {
540 status = map_fnum_to_smb2_handle(cli,
543 if (!NT_STATUS_IS_OK(status)) {
548 uint8_t *dir_data = NULL;
549 uint32_t dir_data_length = 0;
550 uint32_t next_offset = 0;
551 subframe = talloc_stackframe();
553 status = smb2cli_query_directory(cli->conn,
557 SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
568 if (!NT_STATUS_IS_OK(status)) {
569 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
576 struct file_info *finfo = talloc_zero(subframe,
580 status = NT_STATUS_NO_MEMORY;
584 status = parse_finfo_id_both_directory_info(dir_data,
589 if (!NT_STATUS_IS_OK(status)) {
593 status = fn(cli->dfs_mountpoint,
598 if (!NT_STATUS_IS_OK(status)) {
604 /* Move to next entry. */
606 dir_data += next_offset;
607 dir_data_length -= next_offset;
609 } while (next_offset != 0);
611 TALLOC_FREE(subframe);
613 } while (NT_STATUS_IS_OK(status));
615 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
616 status = NT_STATUS_OK;
621 if (fnum != 0xffff) {
622 cli_smb2_close_fnum(cli, fnum);
624 TALLOC_FREE(subframe);
629 /***************************************************************
630 Wrapper that allows SMB2 to query a path info (basic level).
632 ***************************************************************/
634 NTSTATUS cli_smb2_qpathinfo_basic(struct cli_state *cli,
636 SMB_STRUCT_STAT *sbuf,
637 uint32_t *attributes)
640 struct smb2_create_returns cr;
641 uint16_t fnum = 0xffff;
642 size_t namelen = strlen(name);
644 if (smbXcli_conn_has_async_calls(cli->conn)) {
646 * Can't use sync call while an async call is in flight
648 return NT_STATUS_INVALID_PARAMETER;
651 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
652 return NT_STATUS_INVALID_PARAMETER;
655 /* SMB2 is pickier about pathnames. Ensure it doesn't
657 if (namelen > 0 && name[namelen-1] == '\\') {
658 char *modname = talloc_strdup(talloc_tos(), name);
659 modname[namelen-1] = '\0';
663 /* This is commonly used as a 'cd'. Try qpathinfo on
664 a directory handle first. */
666 status = cli_smb2_create_fnum(cli,
668 0, /* create_flags */
669 FILE_READ_ATTRIBUTES, /* desired_access */
670 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
671 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
672 FILE_OPEN, /* create_disposition */
673 FILE_DIRECTORY_FILE, /* create_options */
677 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
679 status = cli_smb2_create_fnum(cli,
681 0, /* create_flags */
682 FILE_READ_ATTRIBUTES, /* desired_access */
683 0, /* file attributes */
684 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
685 FILE_OPEN, /* create_disposition */
686 0, /* create_options */
691 if (!NT_STATUS_IS_OK(status)) {
695 cli_smb2_close_fnum(cli, fnum);
699 sbuf->st_ex_atime = nt_time_to_unix_timespec(&cr.last_access_time);
700 sbuf->st_ex_mtime = nt_time_to_unix_timespec(&cr.last_write_time);
701 sbuf->st_ex_ctime = nt_time_to_unix_timespec(&cr.change_time);
702 sbuf->st_ex_size = cr.end_of_file;
703 *attributes = cr.file_attributes;
708 /***************************************************************
709 Helper function for pathname operations.
710 ***************************************************************/
712 static NTSTATUS get_fnum_from_path(struct cli_state *cli,
714 uint32_t desired_access,
718 size_t namelen = strlen(name);
719 TALLOC_CTX *frame = talloc_stackframe();
721 /* SMB2 is pickier about pathnames. Ensure it doesn't
723 if (namelen > 0 && name[namelen-1] == '\\') {
724 char *modname = talloc_strdup(frame, name);
725 if (modname == NULL) {
726 status = NT_STATUS_NO_MEMORY;
729 modname[namelen-1] = '\0';
733 /* Try to open a file handle first. */
734 status = cli_smb2_create_fnum(cli,
736 0, /* create_flags */
738 0, /* file attributes */
739 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
740 FILE_OPEN, /* create_disposition */
741 0, /* create_options */
745 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
746 status = cli_smb2_create_fnum(cli,
748 0, /* create_flags */
750 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
751 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
752 FILE_OPEN, /* create_disposition */
753 FILE_DIRECTORY_FILE, /* create_options */
764 /***************************************************************
765 Wrapper that allows SMB2 to query a path info (ALTNAME level).
767 ***************************************************************/
769 NTSTATUS cli_smb2_qpathinfo_alt_name(struct cli_state *cli,
774 DATA_BLOB outbuf = data_blob_null;
775 uint16_t fnum = 0xffff;
776 struct smb2_hnd *ph = NULL;
777 uint32_t altnamelen = 0;
778 TALLOC_CTX *frame = talloc_stackframe();
780 if (smbXcli_conn_has_async_calls(cli->conn)) {
782 * Can't use sync call while an async call is in flight
784 status = NT_STATUS_INVALID_PARAMETER;
788 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
789 status = NT_STATUS_INVALID_PARAMETER;
793 status = get_fnum_from_path(cli,
795 FILE_READ_ATTRIBUTES,
798 if (!NT_STATUS_IS_OK(status)) {
802 status = map_fnum_to_smb2_handle(cli,
805 if (!NT_STATUS_IS_OK(status)) {
809 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
810 level SMB_FILE_ALTERNATE_NAME_INFORMATION (1021) == SMB2 21 */
812 status = smb2cli_query_info(cli->conn,
816 1, /* in_info_type */
817 (SMB_FILE_ALTERNATE_NAME_INFORMATION - 1000), /* in_file_info_class */
818 0xFFFF, /* in_max_output_length */
819 NULL, /* in_input_buffer */
820 0, /* in_additional_info */
827 if (!NT_STATUS_IS_OK(status)) {
831 /* Parse the reply. */
832 if (outbuf.length < 4) {
833 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
837 altnamelen = IVAL(outbuf.data, 0);
838 if (altnamelen > outbuf.length - 4) {
839 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
843 if (altnamelen > 0) {
845 char *short_name = NULL;
846 ret = pull_string_talloc(frame,
848 FLAGS2_UNICODE_STRINGS,
853 if (ret == (size_t)-1) {
854 /* Bad conversion. */
855 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
859 fstrcpy(alt_name, short_name);
864 status = NT_STATUS_OK;
868 if (fnum != 0xffff) {
869 cli_smb2_close_fnum(cli, fnum);
876 /***************************************************************
877 Wrapper that allows SMB2 to query a fnum info (basic level).
879 ***************************************************************/
881 NTSTATUS cli_smb2_qfileinfo_basic(struct cli_state *cli,
885 struct timespec *create_time,
886 struct timespec *access_time,
887 struct timespec *write_time,
888 struct timespec *change_time,
892 DATA_BLOB outbuf = data_blob_null;
893 struct smb2_hnd *ph = NULL;
894 TALLOC_CTX *frame = talloc_stackframe();
896 if (smbXcli_conn_has_async_calls(cli->conn)) {
898 * Can't use sync call while an async call is in flight
900 status = NT_STATUS_INVALID_PARAMETER;
904 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
905 status = NT_STATUS_INVALID_PARAMETER;
909 status = map_fnum_to_smb2_handle(cli,
912 if (!NT_STATUS_IS_OK(status)) {
916 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
917 level 0x12 (SMB2_FILE_ALL_INFORMATION). */
919 status = smb2cli_query_info(cli->conn,
923 1, /* in_info_type */
924 (SMB_FILE_ALL_INFORMATION - 1000), /* in_file_info_class */
925 0xFFFF, /* in_max_output_length */
926 NULL, /* in_input_buffer */
927 0, /* in_additional_info */
933 if (!NT_STATUS_IS_OK(status)) {
937 /* Parse the reply. */
938 if (outbuf.length < 0x60) {
939 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
944 *create_time = interpret_long_date((const char *)outbuf.data + 0x0);
947 *access_time = interpret_long_date((const char *)outbuf.data + 0x8);
950 *write_time = interpret_long_date((const char *)outbuf.data + 0x10);
953 *change_time = interpret_long_date((const char *)outbuf.data + 0x18);
956 uint32_t attr = IVAL(outbuf.data, 0x20);
957 *mode = (uint16_t)attr;
960 uint64_t file_size = BVAL(outbuf.data, 0x30);
961 *size = (off_t)file_size;
964 uint64_t file_index = BVAL(outbuf.data, 0x40);
965 *ino = (SMB_INO_T)file_index;
974 /***************************************************************
975 Wrapper that allows SMB2 to query an fnum.
976 Implement on top of cli_smb2_qfileinfo_basic().
978 ***************************************************************/
980 NTSTATUS cli_smb2_getattrE(struct cli_state *cli,
988 struct timespec access_time_ts;
989 struct timespec write_time_ts;
990 struct timespec change_time_ts;
991 NTSTATUS status = cli_smb2_qfileinfo_basic(cli,
1001 if (!NT_STATUS_IS_OK(status)) {
1006 *change_time = change_time_ts.tv_sec;
1009 *access_time = access_time_ts.tv_sec;
1012 *write_time = write_time_ts.tv_sec;
1014 return NT_STATUS_OK;
1017 /***************************************************************
1018 Wrapper that allows SMB2 to get pathname attributes.
1020 ***************************************************************/
1022 NTSTATUS cli_smb2_getatr(struct cli_state *cli,
1029 uint16_t fnum = 0xffff;
1030 struct smb2_hnd *ph = NULL;
1031 TALLOC_CTX *frame = talloc_stackframe();
1033 if (smbXcli_conn_has_async_calls(cli->conn)) {
1035 * Can't use sync call while an async call is in flight
1037 status = NT_STATUS_INVALID_PARAMETER;
1041 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1042 status = NT_STATUS_INVALID_PARAMETER;
1046 status = get_fnum_from_path(cli,
1048 FILE_READ_ATTRIBUTES,
1051 if (!NT_STATUS_IS_OK(status)) {
1055 status = map_fnum_to_smb2_handle(cli,
1058 if (!NT_STATUS_IS_OK(status)) {
1061 status = cli_smb2_getattrE(cli,
1068 if (!NT_STATUS_IS_OK(status)) {
1074 if (fnum != 0xffff) {
1075 cli_smb2_close_fnum(cli, fnum);
1082 /***************************************************************
1083 Wrapper that allows SMB2 to query a pathname info (basic level).
1084 Implement on top of cli_smb2_qfileinfo_basic().
1086 ***************************************************************/
1088 NTSTATUS cli_smb2_qpathinfo2(struct cli_state *cli,
1090 struct timespec *create_time,
1091 struct timespec *access_time,
1092 struct timespec *write_time,
1093 struct timespec *change_time,
1099 struct smb2_hnd *ph = NULL;
1100 uint16_t fnum = 0xffff;
1101 TALLOC_CTX *frame = talloc_stackframe();
1103 if (smbXcli_conn_has_async_calls(cli->conn)) {
1105 * Can't use sync call while an async call is in flight
1107 status = NT_STATUS_INVALID_PARAMETER;
1111 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1112 status = NT_STATUS_INVALID_PARAMETER;
1116 status = get_fnum_from_path(cli,
1118 FILE_READ_ATTRIBUTES,
1121 if (!NT_STATUS_IS_OK(status)) {
1125 status = map_fnum_to_smb2_handle(cli,
1128 if (!NT_STATUS_IS_OK(status)) {
1132 status = cli_smb2_qfileinfo_basic(cli,
1144 if (fnum != 0xffff) {
1145 cli_smb2_close_fnum(cli, fnum);
1152 /***************************************************************
1153 Wrapper that allows SMB2 to query pathname streams.
1155 ***************************************************************/
1157 NTSTATUS cli_smb2_qpathinfo_streams(struct cli_state *cli,
1159 TALLOC_CTX *mem_ctx,
1160 unsigned int *pnum_streams,
1161 struct stream_struct **pstreams)
1164 struct smb2_hnd *ph = NULL;
1165 uint16_t fnum = 0xffff;
1166 DATA_BLOB outbuf = data_blob_null;
1167 TALLOC_CTX *frame = talloc_stackframe();
1169 if (smbXcli_conn_has_async_calls(cli->conn)) {
1171 * Can't use sync call while an async call is in flight
1173 status = NT_STATUS_INVALID_PARAMETER;
1177 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1178 status = NT_STATUS_INVALID_PARAMETER;
1182 status = get_fnum_from_path(cli,
1184 FILE_READ_ATTRIBUTES,
1187 if (!NT_STATUS_IS_OK(status)) {
1191 status = map_fnum_to_smb2_handle(cli,
1194 if (!NT_STATUS_IS_OK(status)) {
1198 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1199 level 22 (SMB2_FILE_STREAM_INFORMATION). */
1201 status = smb2cli_query_info(cli->conn,
1205 1, /* in_info_type */
1206 (SMB_FILE_STREAM_INFORMATION - 1000), /* in_file_info_class */
1207 0xFFFF, /* in_max_output_length */
1208 NULL, /* in_input_buffer */
1209 0, /* in_additional_info */
1216 if (!NT_STATUS_IS_OK(status)) {
1220 /* Parse the reply. */
1221 if (!parse_streams_blob(mem_ctx,
1226 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1232 if (fnum != 0xffff) {
1233 cli_smb2_close_fnum(cli, fnum);
1240 /***************************************************************
1241 Wrapper that allows SMB2 to set pathname attributes.
1243 ***************************************************************/
1245 NTSTATUS cli_smb2_setatr(struct cli_state *cli,
1251 uint16_t fnum = 0xffff;
1252 struct smb2_hnd *ph = NULL;
1253 uint8_t inbuf_store[40];
1254 DATA_BLOB inbuf = data_blob_null;
1255 TALLOC_CTX *frame = talloc_stackframe();
1257 if (smbXcli_conn_has_async_calls(cli->conn)) {
1259 * Can't use sync call while an async call is in flight
1261 status = NT_STATUS_INVALID_PARAMETER;
1265 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1266 status = NT_STATUS_INVALID_PARAMETER;
1270 status = get_fnum_from_path(cli,
1272 FILE_WRITE_ATTRIBUTES,
1275 if (!NT_STATUS_IS_OK(status)) {
1279 status = map_fnum_to_smb2_handle(cli,
1282 if (!NT_STATUS_IS_OK(status)) {
1286 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1287 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1289 inbuf.data = inbuf_store;
1290 inbuf.length = sizeof(inbuf_store);
1291 data_blob_clear(&inbuf);
1293 SIVAL(inbuf.data,32,attr);
1295 put_long_date((char *)inbuf.data + 16,mtime);
1297 /* Set all the other times to -1. */
1298 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1299 SBVAL(inbuf.data, 8, 0xFFFFFFFFFFFFFFFFLL);
1300 SBVAL(inbuf.data, 24, 0xFFFFFFFFFFFFFFFFLL);
1302 status = smb2cli_set_info(cli->conn,
1306 1, /* in_info_type */
1307 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1308 &inbuf, /* in_input_buffer */
1309 0, /* in_additional_info */
1314 if (fnum != 0xffff) {
1315 cli_smb2_close_fnum(cli, fnum);
1322 /***************************************************************
1323 Wrapper that allows SMB2 to set file handle times.
1325 ***************************************************************/
1327 NTSTATUS cli_smb2_setattrE(struct cli_state *cli,
1334 struct smb2_hnd *ph = NULL;
1335 uint8_t inbuf_store[40];
1336 DATA_BLOB inbuf = data_blob_null;
1338 if (smbXcli_conn_has_async_calls(cli->conn)) {
1340 * Can't use sync call while an async call is in flight
1342 return NT_STATUS_INVALID_PARAMETER;
1345 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1346 return NT_STATUS_INVALID_PARAMETER;
1349 status = map_fnum_to_smb2_handle(cli,
1352 if (!NT_STATUS_IS_OK(status)) {
1356 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1357 level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1359 inbuf.data = inbuf_store;
1360 inbuf.length = sizeof(inbuf_store);
1361 data_blob_clear(&inbuf);
1363 SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1364 if (change_time != 0) {
1365 put_long_date((char *)inbuf.data + 24, change_time);
1367 if (access_time != 0) {
1368 put_long_date((char *)inbuf.data + 8, access_time);
1370 if (write_time != 0) {
1371 put_long_date((char *)inbuf.data + 16, write_time);
1374 return smb2cli_set_info(cli->conn,
1378 1, /* in_info_type */
1379 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1380 &inbuf, /* in_input_buffer */
1381 0, /* in_additional_info */
1386 /***************************************************************
1387 Wrapper that allows SMB2 to query disk attributes (size).
1389 ***************************************************************/
1391 NTSTATUS cli_smb2_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
1394 uint16_t fnum = 0xffff;
1395 DATA_BLOB outbuf = data_blob_null;
1396 struct smb2_hnd *ph = NULL;
1397 uint32_t sectors_per_unit = 0;
1398 uint32_t bytes_per_sector = 0;
1399 uint64_t total_size = 0;
1400 uint64_t size_free = 0;
1401 TALLOC_CTX *frame = talloc_stackframe();
1403 if (smbXcli_conn_has_async_calls(cli->conn)) {
1405 * Can't use sync call while an async call is in flight
1407 status = NT_STATUS_INVALID_PARAMETER;
1411 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1412 status = NT_STATUS_INVALID_PARAMETER;
1416 /* First open the top level directory. */
1417 status = cli_smb2_create_fnum(cli,
1419 0, /* create_flags */
1420 FILE_READ_ATTRIBUTES, /* desired_access */
1421 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1422 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1423 FILE_OPEN, /* create_disposition */
1424 FILE_DIRECTORY_FILE, /* create_options */
1428 if (!NT_STATUS_IS_OK(status)) {
1432 status = map_fnum_to_smb2_handle(cli,
1435 if (!NT_STATUS_IS_OK(status)) {
1439 /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
1440 level 3 (SMB_FS_SIZE_INFORMATION). */
1442 status = smb2cli_query_info(cli->conn,
1446 2, /* in_info_type */
1447 3, /* in_file_info_class */
1448 0xFFFF, /* in_max_output_length */
1449 NULL, /* in_input_buffer */
1450 0, /* in_additional_info */
1456 if (!NT_STATUS_IS_OK(status)) {
1460 /* Parse the reply. */
1461 if (outbuf.length != 24) {
1462 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1466 total_size = BVAL(outbuf.data, 0);
1467 size_free = BVAL(outbuf.data, 8);
1468 sectors_per_unit = IVAL(outbuf.data, 16);
1469 bytes_per_sector = IVAL(outbuf.data, 20);
1472 *bsize = (int)(sectors_per_unit * bytes_per_sector);
1475 *total = (int)total_size;
1478 *avail = (int)size_free;
1481 status = NT_STATUS_OK;
1485 if (fnum != 0xffff) {
1486 cli_smb2_close_fnum(cli, fnum);
1493 /***************************************************************
1494 Wrapper that allows SMB2 to query a security descriptor.
1496 ***************************************************************/
1498 NTSTATUS cli_smb2_query_security_descriptor(struct cli_state *cli,
1501 TALLOC_CTX *mem_ctx,
1502 struct security_descriptor **ppsd)
1505 DATA_BLOB outbuf = data_blob_null;
1506 struct smb2_hnd *ph = NULL;
1507 struct security_descriptor *lsd = NULL;
1508 TALLOC_CTX *frame = talloc_stackframe();
1510 if (smbXcli_conn_has_async_calls(cli->conn)) {
1512 * Can't use sync call while an async call is in flight
1514 status = NT_STATUS_INVALID_PARAMETER;
1518 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1519 status = NT_STATUS_INVALID_PARAMETER;
1523 status = map_fnum_to_smb2_handle(cli,
1526 if (!NT_STATUS_IS_OK(status)) {
1530 /* getinfo on the returned handle with info_type SMB2_GETINFO_SEC (3) */
1532 status = smb2cli_query_info(cli->conn,
1536 3, /* in_info_type */
1537 0, /* in_file_info_class */
1538 0xFFFF, /* in_max_output_length */
1539 NULL, /* in_input_buffer */
1540 sec_info, /* in_additional_info */
1547 if (!NT_STATUS_IS_OK(status)) {
1551 /* Parse the reply. */
1552 status = unmarshall_sec_desc(mem_ctx,
1557 if (!NT_STATUS_IS_OK(status)) {
1573 /***************************************************************
1574 Wrapper that allows SMB2 to set a security descriptor.
1576 ***************************************************************/
1578 NTSTATUS cli_smb2_set_security_descriptor(struct cli_state *cli,
1581 const struct security_descriptor *sd)
1584 DATA_BLOB inbuf = data_blob_null;
1585 struct smb2_hnd *ph = NULL;
1586 TALLOC_CTX *frame = talloc_stackframe();
1588 if (smbXcli_conn_has_async_calls(cli->conn)) {
1590 * Can't use sync call while an async call is in flight
1592 status = NT_STATUS_INVALID_PARAMETER;
1596 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1597 status = NT_STATUS_INVALID_PARAMETER;
1601 status = map_fnum_to_smb2_handle(cli,
1604 if (!NT_STATUS_IS_OK(status)) {
1608 status = marshall_sec_desc(frame,
1613 if (!NT_STATUS_IS_OK(status)) {
1617 /* setinfo on the returned handle with info_type SMB2_SETINFO_SEC (3) */
1619 status = smb2cli_set_info(cli->conn,
1623 3, /* in_info_type */
1624 0, /* in_file_info_class */
1625 &inbuf, /* in_input_buffer */
1626 sec_info, /* in_additional_info */
1636 /***************************************************************
1637 Wrapper that allows SMB2 to rename a file.
1639 ***************************************************************/
1641 NTSTATUS cli_smb2_rename(struct cli_state *cli,
1642 const char *fname_src,
1643 const char *fname_dst)
1646 DATA_BLOB inbuf = data_blob_null;
1647 uint16_t fnum = 0xffff;
1648 struct smb2_hnd *ph = NULL;
1649 smb_ucs2_t *converted_str = NULL;
1650 size_t converted_size_bytes = 0;
1652 TALLOC_CTX *frame = talloc_stackframe();
1654 if (smbXcli_conn_has_async_calls(cli->conn)) {
1656 * Can't use sync call while an async call is in flight
1658 status = NT_STATUS_INVALID_PARAMETER;
1662 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1663 status = NT_STATUS_INVALID_PARAMETER;
1667 status = get_fnum_from_path(cli,
1672 if (!NT_STATUS_IS_OK(status)) {
1676 status = map_fnum_to_smb2_handle(cli,
1679 if (!NT_STATUS_IS_OK(status)) {
1683 /* SMB2 is pickier about pathnames. Ensure it doesn't
1685 if (*fname_dst == '\\') {
1689 /* SMB2 is pickier about pathnames. Ensure it doesn't
1691 namelen = strlen(fname_dst);
1692 if (namelen > 0 && fname_dst[namelen-1] == '\\') {
1693 char *modname = talloc_strdup(frame, fname_dst);
1694 modname[namelen-1] = '\0';
1695 fname_dst = modname;
1698 if (!push_ucs2_talloc(frame,
1701 &converted_size_bytes)) {
1702 status = NT_STATUS_INVALID_PARAMETER;
1706 /* W2K8 insists the dest name is not null
1707 terminated. Remove the last 2 zero bytes
1708 and reduce the name length. */
1710 if (converted_size_bytes < 2) {
1711 status = NT_STATUS_INVALID_PARAMETER;
1714 converted_size_bytes -= 2;
1716 inbuf = data_blob_talloc_zero(frame,
1717 20 + converted_size_bytes);
1718 if (inbuf.data == NULL) {
1719 status = NT_STATUS_NO_MEMORY;
1723 SIVAL(inbuf.data, 16, converted_size_bytes);
1724 memcpy(inbuf.data + 20, converted_str, converted_size_bytes);
1726 /* setinfo on the returned handle with info_type SMB2_GETINFO_FILE (1),
1727 level SMB2_FILE_RENAME_INFORMATION (SMB_FILE_RENAME_INFORMATION - 1000) */
1729 status = smb2cli_set_info(cli->conn,
1733 1, /* in_info_type */
1734 SMB_FILE_RENAME_INFORMATION - 1000, /* in_file_info_class */
1735 &inbuf, /* in_input_buffer */
1736 0, /* in_additional_info */
1742 if (fnum != 0xffff) {
1743 cli_smb2_close_fnum(cli, fnum);
1750 /***************************************************************
1751 Wrapper that allows SMB2 to set an EA on a fnum.
1753 ***************************************************************/
1755 NTSTATUS cli_smb2_set_ea_fnum(struct cli_state *cli,
1757 const char *ea_name,
1762 DATA_BLOB inbuf = data_blob_null;
1764 char *ea_name_ascii = NULL;
1766 struct smb2_hnd *ph = NULL;
1767 TALLOC_CTX *frame = talloc_stackframe();
1769 if (smbXcli_conn_has_async_calls(cli->conn)) {
1771 * Can't use sync call while an async call is in flight
1773 status = NT_STATUS_INVALID_PARAMETER;
1777 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1778 status = NT_STATUS_INVALID_PARAMETER;
1782 status = map_fnum_to_smb2_handle(cli,
1785 if (!NT_STATUS_IS_OK(status)) {
1789 /* Marshall the SMB2 EA data. */
1790 if (ea_len > 0xFFFF) {
1791 status = NT_STATUS_INVALID_PARAMETER;
1795 if (!push_ascii_talloc(frame,
1799 status = NT_STATUS_INVALID_PARAMETER;
1803 if (namelen < 2 || namelen > 0xFF) {
1804 status = NT_STATUS_INVALID_PARAMETER;
1808 bloblen = 8 + ea_len + namelen;
1809 /* Round up to a 4 byte boundary. */
1810 bloblen = ((bloblen + 3)&~3);
1812 inbuf = data_blob_talloc_zero(frame, bloblen);
1813 if (inbuf.data == NULL) {
1814 status = NT_STATUS_NO_MEMORY;
1817 /* namelen doesn't include the NULL byte. */
1818 SCVAL(inbuf.data, 5, namelen - 1);
1819 SSVAL(inbuf.data, 6, ea_len);
1820 memcpy(inbuf.data + 8, ea_name_ascii, namelen);
1821 memcpy(inbuf.data + 8 + namelen, ea_val, ea_len);
1823 /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1824 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
1826 status = smb2cli_set_info(cli->conn,
1830 1, /* in_info_type */
1831 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
1832 &inbuf, /* in_input_buffer */
1833 0, /* in_additional_info */
1843 /***************************************************************
1844 Wrapper that allows SMB2 to set an EA on a pathname.
1846 ***************************************************************/
1848 NTSTATUS cli_smb2_set_ea_path(struct cli_state *cli,
1850 const char *ea_name,
1855 uint16_t fnum = 0xffff;
1857 if (smbXcli_conn_has_async_calls(cli->conn)) {
1859 * Can't use sync call while an async call is in flight
1861 status = NT_STATUS_INVALID_PARAMETER;
1865 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1866 status = NT_STATUS_INVALID_PARAMETER;
1870 status = get_fnum_from_path(cli,
1875 if (!NT_STATUS_IS_OK(status)) {
1879 status = cli_set_ea_fnum(cli,
1884 if (!NT_STATUS_IS_OK(status)) {
1890 if (fnum != 0xffff) {
1891 cli_smb2_close_fnum(cli, fnum);
1897 /***************************************************************
1898 Wrapper that allows SMB2 to get an EA list on a pathname.
1900 ***************************************************************/
1902 NTSTATUS cli_smb2_get_ea_list_path(struct cli_state *cli,
1906 struct ea_struct **pea_array)
1909 uint16_t fnum = 0xffff;
1910 DATA_BLOB outbuf = data_blob_null;
1911 struct smb2_hnd *ph = NULL;
1912 struct ea_list *ea_list = NULL;
1913 struct ea_list *eal = NULL;
1914 size_t ea_count = 0;
1915 TALLOC_CTX *frame = talloc_stackframe();
1920 if (smbXcli_conn_has_async_calls(cli->conn)) {
1922 * Can't use sync call while an async call is in flight
1924 status = NT_STATUS_INVALID_PARAMETER;
1928 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1929 status = NT_STATUS_INVALID_PARAMETER;
1933 status = get_fnum_from_path(cli,
1938 if (!NT_STATUS_IS_OK(status)) {
1942 status = map_fnum_to_smb2_handle(cli,
1945 if (!NT_STATUS_IS_OK(status)) {
1949 /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1950 level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
1952 status = smb2cli_query_info(cli->conn,
1956 1, /* in_info_type */
1957 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
1958 0xFFFF, /* in_max_output_length */
1959 NULL, /* in_input_buffer */
1960 0, /* in_additional_info */
1967 if (!NT_STATUS_IS_OK(status)) {
1971 /* Parse the reply. */
1972 ea_list = read_nttrans_ea_list(ctx,
1973 (const char *)outbuf.data,
1975 if (ea_list == NULL) {
1976 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1980 /* Convert to an array. */
1981 for (eal = ea_list; eal; eal = eal->next) {
1986 *pea_array = talloc_array(ctx, struct ea_struct, ea_count);
1987 if (*pea_array == NULL) {
1988 status = NT_STATUS_NO_MEMORY;
1992 for (eal = ea_list; eal; eal = eal->next) {
1993 (*pea_array)[ea_count++] = ea_list->ea;
1995 *pnum_eas = ea_count;
2004 struct cli_smb2_read_state {
2005 struct tevent_context *ev;
2006 struct cli_state *cli;
2007 struct smb2_hnd *ph;
2008 uint64_t start_offset;
2014 static void cli_smb2_read_done(struct tevent_req *subreq);
2016 struct tevent_req *cli_smb2_read_send(TALLOC_CTX *mem_ctx,
2017 struct tevent_context *ev,
2018 struct cli_state *cli,
2024 struct tevent_req *req, *subreq;
2025 struct cli_smb2_read_state *state;
2027 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_read_state);
2033 state->start_offset = (uint64_t)offset;
2034 state->size = (uint32_t)size;
2035 state->received = 0;
2038 status = map_fnum_to_smb2_handle(cli,
2041 if (tevent_req_nterror(req, status)) {
2042 return tevent_req_post(req, ev);
2045 subreq = smb2cli_read_send(state,
2048 state->cli->timeout,
2049 state->cli->smb2.session,
2050 state->cli->smb2.tcon,
2052 state->start_offset,
2053 state->ph->fid_persistent,
2054 state->ph->fid_volatile,
2055 0, /* minimum_count */
2056 0); /* remaining_bytes */
2058 if (tevent_req_nomem(subreq, req)) {
2059 return tevent_req_post(req, ev);
2061 tevent_req_set_callback(subreq, cli_smb2_read_done, req);
2065 static void cli_smb2_read_done(struct tevent_req *subreq)
2067 struct tevent_req *req = tevent_req_callback_data(
2068 subreq, struct tevent_req);
2069 struct cli_smb2_read_state *state = tevent_req_data(
2070 req, struct cli_smb2_read_state);
2073 status = smb2cli_read_recv(subreq, state,
2074 &state->buf, &state->received);
2075 if (tevent_req_nterror(req, status)) {
2079 if (state->received > state->size) {
2080 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2084 tevent_req_done(req);
2087 NTSTATUS cli_smb2_read_recv(struct tevent_req *req,
2092 struct cli_smb2_read_state *state = tevent_req_data(
2093 req, struct cli_smb2_read_state);
2095 if (tevent_req_is_nterror(req, &status)) {
2099 * As in cli_read_andx_recv() rcvbuf is talloced from the request, so
2100 * better make sure that you copy it away before you talloc_free(req).
2101 * "rcvbuf" is NOT a talloc_ctx of its own, so do not talloc_move it!
2103 *received = (ssize_t)state->received;
2104 *rcvbuf = state->buf;
2105 return NT_STATUS_OK;
2108 struct cli_smb2_write_state {
2109 struct tevent_context *ev;
2110 struct cli_state *cli;
2111 struct smb2_hnd *ph;
2119 static void cli_smb2_write_written(struct tevent_req *req);
2121 struct tevent_req *cli_smb2_write_send(TALLOC_CTX *mem_ctx,
2122 struct tevent_context *ev,
2123 struct cli_state *cli,
2131 struct tevent_req *req, *subreq = NULL;
2132 struct cli_smb2_write_state *state = NULL;
2134 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_write_state);
2140 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2141 state->flags = (uint32_t)mode;
2143 state->offset = (uint64_t)offset;
2144 state->size = (uint32_t)size;
2147 status = map_fnum_to_smb2_handle(cli,
2150 if (tevent_req_nterror(req, status)) {
2151 return tevent_req_post(req, ev);
2154 subreq = smb2cli_write_send(state,
2157 state->cli->timeout,
2158 state->cli->smb2.session,
2159 state->cli->smb2.tcon,
2162 state->ph->fid_persistent,
2163 state->ph->fid_volatile,
2164 0, /* remaining_bytes */
2165 state->flags, /* flags */
2168 if (tevent_req_nomem(subreq, req)) {
2169 return tevent_req_post(req, ev);
2171 tevent_req_set_callback(subreq, cli_smb2_write_written, req);
2175 static void cli_smb2_write_written(struct tevent_req *subreq)
2177 struct tevent_req *req = tevent_req_callback_data(
2178 subreq, struct tevent_req);
2179 struct cli_smb2_write_state *state = tevent_req_data(
2180 req, struct cli_smb2_write_state);
2184 status = smb2cli_write_recv(subreq, &written);
2185 TALLOC_FREE(subreq);
2186 if (tevent_req_nterror(req, status)) {
2190 state->written = written;
2192 tevent_req_done(req);
2195 NTSTATUS cli_smb2_write_recv(struct tevent_req *req,
2198 struct cli_smb2_write_state *state = tevent_req_data(
2199 req, struct cli_smb2_write_state);
2202 if (tevent_req_is_nterror(req, &status)) {
2203 tevent_req_received(req);
2207 if (pwritten != NULL) {
2208 *pwritten = (size_t)state->written;
2210 tevent_req_received(req);
2211 return NT_STATUS_OK;
2214 /***************************************************************
2215 Wrapper that allows SMB2 async write using an fnum.
2216 This is mostly cut-and-paste from Volker's code inside
2217 source3/libsmb/clireadwrite.c, adapted for SMB2.
2219 Done this way so I can reuse all the logic inside cli_push()
2221 ***************************************************************/
2223 struct cli_smb2_writeall_state {
2224 struct tevent_context *ev;
2225 struct cli_state *cli;
2226 struct smb2_hnd *ph;
2234 static void cli_smb2_writeall_written(struct tevent_req *req);
2236 struct tevent_req *cli_smb2_writeall_send(TALLOC_CTX *mem_ctx,
2237 struct tevent_context *ev,
2238 struct cli_state *cli,
2246 struct tevent_req *req, *subreq = NULL;
2247 struct cli_smb2_writeall_state *state = NULL;
2252 req = tevent_req_create(mem_ctx, &state, struct cli_smb2_writeall_state);
2258 /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2259 state->flags = (uint32_t)mode;
2261 state->offset = (uint64_t)offset;
2262 state->size = (uint32_t)size;
2265 status = map_fnum_to_smb2_handle(cli,
2268 if (tevent_req_nterror(req, status)) {
2269 return tevent_req_post(req, ev);
2272 to_write = state->size;
2273 max_size = smb2cli_conn_max_write_size(state->cli->conn);
2274 to_write = MIN(max_size, to_write);
2275 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2277 to_write = MIN(max_size, to_write);
2280 subreq = smb2cli_write_send(state,
2283 state->cli->timeout,
2284 state->cli->smb2.session,
2285 state->cli->smb2.tcon,
2288 state->ph->fid_persistent,
2289 state->ph->fid_volatile,
2290 0, /* remaining_bytes */
2291 state->flags, /* flags */
2292 state->buf + state->written);
2294 if (tevent_req_nomem(subreq, req)) {
2295 return tevent_req_post(req, ev);
2297 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
2301 static void cli_smb2_writeall_written(struct tevent_req *subreq)
2303 struct tevent_req *req = tevent_req_callback_data(
2304 subreq, struct tevent_req);
2305 struct cli_smb2_writeall_state *state = tevent_req_data(
2306 req, struct cli_smb2_writeall_state);
2308 uint32_t written, to_write;
2312 status = smb2cli_write_recv(subreq, &written);
2313 TALLOC_FREE(subreq);
2314 if (tevent_req_nterror(req, status)) {
2318 state->written += written;
2320 if (state->written > state->size) {
2321 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2325 to_write = state->size - state->written;
2327 if (to_write == 0) {
2328 tevent_req_done(req);
2332 max_size = smb2cli_conn_max_write_size(state->cli->conn);
2333 to_write = MIN(max_size, to_write);
2334 ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2336 to_write = MIN(max_size, to_write);
2339 subreq = smb2cli_write_send(state,
2342 state->cli->timeout,
2343 state->cli->smb2.session,
2344 state->cli->smb2.tcon,
2346 state->offset + state->written,
2347 state->ph->fid_persistent,
2348 state->ph->fid_volatile,
2349 0, /* remaining_bytes */
2350 state->flags, /* flags */
2351 state->buf + state->written);
2353 if (tevent_req_nomem(subreq, req)) {
2356 tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
2359 NTSTATUS cli_smb2_writeall_recv(struct tevent_req *req,
2362 struct cli_smb2_writeall_state *state = tevent_req_data(
2363 req, struct cli_smb2_writeall_state);
2366 if (tevent_req_is_nterror(req, &status)) {
2369 if (pwritten != NULL) {
2370 *pwritten = (size_t)state->written;
2372 return NT_STATUS_OK;