2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Jeremy Allison 2001-2009
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 /***********************************************************
24 Common function for pushing stings, used by smb_bytes_push_str()
25 and trans_bytes_push_str(). Only difference is the align_odd
27 ***********************************************************/
29 static uint8_t *internal_bytes_push_str(uint8_t *buf
, bool ucs2
,
30 const char *str
, size_t str_len
,
32 size_t *pconverted_size
)
36 size_t converted_size
;
42 buflen
= talloc_get_size(buf
);
44 if (align_odd
&& ucs2
&& (buflen
% 2 == 0)) {
46 * We're pushing into an SMB buffer, align odd
48 buf
= TALLOC_REALLOC_ARRAY(NULL
, buf
, uint8_t, buflen
+ 1);
56 if (!convert_string_talloc(talloc_tos(), CH_UNIX
,
57 ucs2
? CH_UTF16LE
: CH_DOS
,
58 str
, str_len
, &converted
,
59 &converted_size
, true)) {
63 buf
= TALLOC_REALLOC_ARRAY(NULL
, buf
, uint8_t,
64 buflen
+ converted_size
);
66 TALLOC_FREE(converted
);
70 memcpy(buf
+ buflen
, converted
, converted_size
);
72 TALLOC_FREE(converted
);
74 if (pconverted_size
) {
75 *pconverted_size
= converted_size
;
81 /***********************************************************
82 Push a string into an SMB buffer, with odd byte alignment
83 if it's a UCS2 string.
84 ***********************************************************/
86 uint8_t *smb_bytes_push_str(uint8_t *buf
, bool ucs2
,
87 const char *str
, size_t str_len
,
88 size_t *pconverted_size
)
90 return internal_bytes_push_str(buf
, ucs2
, str
, str_len
,
91 true, pconverted_size
);
94 /***********************************************************
95 Same as smb_bytes_push_str(), but without the odd byte
96 align for ucs2 (we're pushing into a param or data block).
97 static for now, although this will probably change when
98 other modules use async trans calls.
99 ***********************************************************/
101 static uint8_t *trans2_bytes_push_str(uint8_t *buf
, bool ucs2
,
102 const char *str
, size_t str_len
,
103 size_t *pconverted_size
)
105 return internal_bytes_push_str(buf
, ucs2
, str
, str_len
,
106 false, pconverted_size
);
109 /****************************************************************************
110 Hard/Symlink a file (UNIX extensions).
111 Creates new name (sym)linked to oldname.
112 ****************************************************************************/
120 static void cli_posix_link_internal_done(struct tevent_req
*subreq
)
122 struct tevent_req
*req
= tevent_req_callback_data(
123 subreq
, struct tevent_req
);
124 struct link_state
*state
= tevent_req_data(req
, struct link_state
);
127 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
129 if (!NT_STATUS_IS_OK(status
)) {
130 tevent_req_nterror(req
, status
);
133 tevent_req_done(req
);
136 static struct tevent_req
*cli_posix_link_internal_send(TALLOC_CTX
*mem_ctx
,
137 struct event_context
*ev
,
138 struct cli_state
*cli
,
143 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
144 struct link_state
*state
= NULL
;
146 req
= tevent_req_create(mem_ctx
, &state
, struct link_state
);
151 /* Setup setup word. */
152 SSVAL(&state
->setup
, 0, TRANSACT2_SETPATHINFO
);
154 /* Setup param array. */
155 state
->param
= talloc_array(state
, uint8_t, 6);
156 if (tevent_req_nomem(state
->param
, req
)) {
157 return tevent_req_post(req
, ev
);
159 memset(state
->param
, '\0', 6);
160 SSVAL(state
->param
,0,hardlink
? SMB_SET_FILE_UNIX_HLINK
: SMB_SET_FILE_UNIX_LINK
);
162 state
->param
= trans2_bytes_push_str(state
->param
, cli_ucs2(cli
), newname
,
163 strlen(newname
)+1, NULL
);
165 if (tevent_req_nomem(state
->param
, req
)) {
166 return tevent_req_post(req
, ev
);
169 /* Setup data array. */
170 state
->data
= talloc_array(state
, uint8_t, 0);
171 if (tevent_req_nomem(state
->data
, req
)) {
172 return tevent_req_post(req
, ev
);
174 state
->data
= trans2_bytes_push_str(state
->data
, cli_ucs2(cli
), oldname
,
175 strlen(oldname
)+1, NULL
);
177 subreq
= cli_trans_send(state
, /* mem ctx. */
179 cli
, /* cli_state. */
180 SMBtrans2
, /* cmd. */
181 NULL
, /* pipe name. */
185 &state
->setup
, /* setup. */
186 1, /* num setup uint16_t words. */
187 0, /* max returned setup. */
188 state
->param
, /* param. */
189 talloc_get_size(state
->param
), /* num param. */
190 2, /* max returned param. */
191 state
->data
, /* data. */
192 talloc_get_size(state
->data
), /* num data. */
193 0); /* max returned data. */
195 if (tevent_req_nomem(subreq
, req
)) {
196 return tevent_req_post(req
, ev
);
198 tevent_req_set_callback(subreq
, cli_posix_link_internal_done
, req
);
202 /****************************************************************************
203 Symlink a file (UNIX extensions).
204 ****************************************************************************/
206 struct tevent_req
*cli_posix_symlink_send(TALLOC_CTX
*mem_ctx
,
207 struct event_context
*ev
,
208 struct cli_state
*cli
,
212 return cli_posix_link_internal_send(mem_ctx
, ev
, cli
,
213 oldname
, newname
, false);
216 NTSTATUS
cli_posix_symlink_recv(struct tevent_req
*req
)
220 if (tevent_req_is_nterror(req
, &status
)) {
226 NTSTATUS
cli_posix_symlink(struct cli_state
*cli
,
230 TALLOC_CTX
*frame
= talloc_stackframe();
231 struct event_context
*ev
= NULL
;
232 struct tevent_req
*req
= NULL
;
233 NTSTATUS status
= NT_STATUS_OK
;
235 if (cli_has_async_calls(cli
)) {
237 * Can't use sync call while an async call is in flight
239 status
= NT_STATUS_INVALID_PARAMETER
;
243 ev
= event_context_init(frame
);
245 status
= NT_STATUS_NO_MEMORY
;
249 req
= cli_posix_symlink_send(frame
,
255 status
= NT_STATUS_NO_MEMORY
;
259 if (!tevent_req_poll(req
, ev
)) {
260 status
= map_nt_error_from_unix(errno
);
264 status
= cli_posix_symlink_recv(req
);
268 if (!NT_STATUS_IS_OK(status
)) {
269 cli_set_error(cli
, status
);
274 /****************************************************************************
275 Read a POSIX symlink.
276 ****************************************************************************/
278 struct readlink_state
{
285 static void cli_posix_readlink_done(struct tevent_req
*subreq
)
287 struct tevent_req
*req
= tevent_req_callback_data(
288 subreq
, struct tevent_req
);
289 struct readlink_state
*state
= tevent_req_data(req
, struct readlink_state
);
292 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
,
293 &state
->data
, &state
->num_data
);
295 if (!NT_STATUS_IS_OK(status
)) {
296 tevent_req_nterror(req
, status
);
299 if (state
->num_data
== 0) {
300 tevent_req_nterror(req
, NT_STATUS_DATA_ERROR
);
303 if (state
->data
[state
->num_data
-1] != '\0') {
304 tevent_req_nterror(req
, NT_STATUS_DATA_ERROR
);
307 tevent_req_done(req
);
310 struct tevent_req
*cli_posix_readlink_send(TALLOC_CTX
*mem_ctx
,
311 struct event_context
*ev
,
312 struct cli_state
*cli
,
316 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
317 struct readlink_state
*state
= NULL
;
318 uint32_t maxbytelen
= (uint32_t)(cli_ucs2(cli
) ? len
*3 : len
);
320 if (maxbytelen
< len
) {
324 req
= tevent_req_create(mem_ctx
, &state
, struct readlink_state
);
329 /* Setup setup word. */
330 SSVAL(&state
->setup
, 0, TRANSACT2_QPATHINFO
);
332 /* Setup param array. */
333 state
->param
= talloc_array(state
, uint8_t, 6);
334 if (tevent_req_nomem(state
->param
, req
)) {
335 return tevent_req_post(req
, ev
);
337 memset(state
->param
, '\0', 6);
338 SSVAL(state
->param
,0,SMB_QUERY_FILE_UNIX_LINK
);
340 state
->param
= trans2_bytes_push_str(state
->param
, cli_ucs2(cli
), fname
,
341 strlen(fname
)+1, NULL
);
343 if (tevent_req_nomem(state
->param
, req
)) {
344 return tevent_req_post(req
, ev
);
347 subreq
= cli_trans_send(state
, /* mem ctx. */
349 cli
, /* cli_state. */
350 SMBtrans2
, /* cmd. */
351 NULL
, /* pipe name. */
355 &state
->setup
, /* setup. */
356 1, /* num setup uint16_t words. */
357 0, /* max returned setup. */
358 state
->param
, /* param. */
359 talloc_get_size(state
->param
), /* num param. */
360 2, /* max returned param. */
363 maxbytelen
); /* max returned data. */
365 if (tevent_req_nomem(subreq
, req
)) {
366 return tevent_req_post(req
, ev
);
368 tevent_req_set_callback(subreq
, cli_posix_readlink_done
, req
);
372 NTSTATUS
cli_posix_readlink_recv(struct tevent_req
*req
, struct cli_state
*cli
,
373 char *retpath
, size_t len
)
376 char *converted
= NULL
;
377 size_t converted_size
= 0;
378 struct readlink_state
*state
= tevent_req_data(req
, struct readlink_state
);
380 if (tevent_req_is_nterror(req
, &status
)) {
383 /* The returned data is a pushed string, not raw data. */
384 if (!convert_string_talloc(state
,
385 cli_ucs2(cli
) ? CH_UTF16LE
: CH_DOS
,
392 return NT_STATUS_NO_MEMORY
;
395 len
= MIN(len
,converted_size
);
397 return NT_STATUS_DATA_ERROR
;
399 memcpy(retpath
, converted
, len
);
403 NTSTATUS
cli_posix_readlink(struct cli_state
*cli
, const char *fname
,
404 char *linkpath
, size_t len
)
406 TALLOC_CTX
*frame
= talloc_stackframe();
407 struct event_context
*ev
= NULL
;
408 struct tevent_req
*req
= NULL
;
409 NTSTATUS status
= NT_STATUS_OK
;
411 if (cli_has_async_calls(cli
)) {
413 * Can't use sync call while an async call is in flight
415 status
= NT_STATUS_INVALID_PARAMETER
;
419 ev
= event_context_init(frame
);
421 status
= NT_STATUS_NO_MEMORY
;
425 /* Len is in bytes, we need it in UCS2 units. */
427 status
= NT_STATUS_INVALID_PARAMETER
;
431 req
= cli_posix_readlink_send(frame
,
437 status
= NT_STATUS_NO_MEMORY
;
441 if (!tevent_req_poll(req
, ev
)) {
442 status
= map_nt_error_from_unix(errno
);
446 status
= cli_posix_readlink_recv(req
, cli
, linkpath
, len
);
450 if (!NT_STATUS_IS_OK(status
)) {
451 cli_set_error(cli
, status
);
456 /****************************************************************************
457 Hard link a file (UNIX extensions).
458 ****************************************************************************/
460 struct tevent_req
*cli_posix_hardlink_send(TALLOC_CTX
*mem_ctx
,
461 struct event_context
*ev
,
462 struct cli_state
*cli
,
466 return cli_posix_link_internal_send(mem_ctx
, ev
, cli
,
467 oldname
, newname
, true);
470 NTSTATUS
cli_posix_hardlink_recv(struct tevent_req
*req
)
474 if (tevent_req_is_nterror(req
, &status
)) {
480 NTSTATUS
cli_posix_hardlink(struct cli_state
*cli
,
484 TALLOC_CTX
*frame
= talloc_stackframe();
485 struct event_context
*ev
= NULL
;
486 struct tevent_req
*req
= NULL
;
487 NTSTATUS status
= NT_STATUS_OK
;
489 if (cli_has_async_calls(cli
)) {
491 * Can't use sync call while an async call is in flight
493 status
= NT_STATUS_INVALID_PARAMETER
;
497 ev
= event_context_init(frame
);
499 status
= NT_STATUS_NO_MEMORY
;
503 req
= cli_posix_hardlink_send(frame
,
509 status
= NT_STATUS_NO_MEMORY
;
513 if (!tevent_req_poll(req
, ev
)) {
514 status
= map_nt_error_from_unix(errno
);
518 status
= cli_posix_hardlink_recv(req
);
522 if (!NT_STATUS_IS_OK(status
)) {
523 cli_set_error(cli
, status
);
528 /****************************************************************************
529 Map standard UNIX permissions onto wire representations.
530 ****************************************************************************/
532 uint32_t unix_perms_to_wire(mode_t perms
)
534 unsigned int ret
= 0;
536 ret
|= ((perms
& S_IXOTH
) ? UNIX_X_OTH
: 0);
537 ret
|= ((perms
& S_IWOTH
) ? UNIX_W_OTH
: 0);
538 ret
|= ((perms
& S_IROTH
) ? UNIX_R_OTH
: 0);
539 ret
|= ((perms
& S_IXGRP
) ? UNIX_X_GRP
: 0);
540 ret
|= ((perms
& S_IWGRP
) ? UNIX_W_GRP
: 0);
541 ret
|= ((perms
& S_IRGRP
) ? UNIX_R_GRP
: 0);
542 ret
|= ((perms
& S_IXUSR
) ? UNIX_X_USR
: 0);
543 ret
|= ((perms
& S_IWUSR
) ? UNIX_W_USR
: 0);
544 ret
|= ((perms
& S_IRUSR
) ? UNIX_R_USR
: 0);
546 ret
|= ((perms
& S_ISVTX
) ? UNIX_STICKY
: 0);
549 ret
|= ((perms
& S_ISGID
) ? UNIX_SET_GID
: 0);
552 ret
|= ((perms
& S_ISUID
) ? UNIX_SET_UID
: 0);
557 /****************************************************************************
558 Map wire permissions to standard UNIX.
559 ****************************************************************************/
561 mode_t
wire_perms_to_unix(uint32_t perms
)
563 mode_t ret
= (mode_t
)0;
565 ret
|= ((perms
& UNIX_X_OTH
) ? S_IXOTH
: 0);
566 ret
|= ((perms
& UNIX_W_OTH
) ? S_IWOTH
: 0);
567 ret
|= ((perms
& UNIX_R_OTH
) ? S_IROTH
: 0);
568 ret
|= ((perms
& UNIX_X_GRP
) ? S_IXGRP
: 0);
569 ret
|= ((perms
& UNIX_W_GRP
) ? S_IWGRP
: 0);
570 ret
|= ((perms
& UNIX_R_GRP
) ? S_IRGRP
: 0);
571 ret
|= ((perms
& UNIX_X_USR
) ? S_IXUSR
: 0);
572 ret
|= ((perms
& UNIX_W_USR
) ? S_IWUSR
: 0);
573 ret
|= ((perms
& UNIX_R_USR
) ? S_IRUSR
: 0);
575 ret
|= ((perms
& UNIX_STICKY
) ? S_ISVTX
: 0);
578 ret
|= ((perms
& UNIX_SET_GID
) ? S_ISGID
: 0);
581 ret
|= ((perms
& UNIX_SET_UID
) ? S_ISUID
: 0);
586 /****************************************************************************
587 Return the file type from the wire filetype for UNIX extensions.
588 ****************************************************************************/
590 static mode_t
unix_filetype_from_wire(uint32_t wire_type
)
598 case UNIX_TYPE_SYMLINK
:
602 case UNIX_TYPE_CHARDEV
:
606 case UNIX_TYPE_BLKDEV
:
614 case UNIX_TYPE_SOCKET
:
622 /****************************************************************************
623 Do a POSIX getfacl (UNIX extensions).
624 ****************************************************************************/
626 struct getfacl_state
{
633 static void cli_posix_getfacl_done(struct tevent_req
*subreq
)
635 struct tevent_req
*req
= tevent_req_callback_data(
636 subreq
, struct tevent_req
);
637 struct getfacl_state
*state
= tevent_req_data(req
, struct getfacl_state
);
640 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
,
641 &state
->data
, &state
->num_data
);
643 if (!NT_STATUS_IS_OK(status
)) {
644 tevent_req_nterror(req
, status
);
647 tevent_req_done(req
);
650 struct tevent_req
*cli_posix_getfacl_send(TALLOC_CTX
*mem_ctx
,
651 struct event_context
*ev
,
652 struct cli_state
*cli
,
655 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
656 struct link_state
*state
= NULL
;
658 req
= tevent_req_create(mem_ctx
, &state
, struct getfacl_state
);
663 /* Setup setup word. */
664 SSVAL(&state
->setup
, 0, TRANSACT2_QPATHINFO
);
666 /* Setup param array. */
667 state
->param
= talloc_array(state
, uint8_t, 6);
668 if (tevent_req_nomem(state
->param
, req
)) {
669 return tevent_req_post(req
, ev
);
671 memset(state
->param
, '\0', 6);
672 SSVAL(state
->param
, 0, SMB_QUERY_POSIX_ACL
);
674 state
->param
= trans2_bytes_push_str(state
->param
, cli_ucs2(cli
), fname
,
675 strlen(fname
)+1, NULL
);
677 if (tevent_req_nomem(state
->param
, req
)) {
678 return tevent_req_post(req
, ev
);
681 subreq
= cli_trans_send(state
, /* mem ctx. */
683 cli
, /* cli_state. */
684 SMBtrans2
, /* cmd. */
685 NULL
, /* pipe name. */
689 &state
->setup
, /* setup. */
690 1, /* num setup uint16_t words. */
691 0, /* max returned setup. */
692 state
->param
, /* param. */
693 talloc_get_size(state
->param
), /* num param. */
694 2, /* max returned param. */
697 cli
->max_xmit
); /* max returned data. */
699 if (tevent_req_nomem(subreq
, req
)) {
700 return tevent_req_post(req
, ev
);
702 tevent_req_set_callback(subreq
, cli_posix_getfacl_done
, req
);
706 NTSTATUS
cli_posix_getfacl_recv(struct tevent_req
*req
,
711 struct getfacl_state
*state
= tevent_req_data(req
, struct getfacl_state
);
714 if (tevent_req_is_nterror(req
, &status
)) {
717 *prb_size
= (size_t)state
->num_data
;
718 *retbuf
= (char *)talloc_move(mem_ctx
, &state
->data
);
722 NTSTATUS
cli_posix_getfacl(struct cli_state
*cli
,
728 TALLOC_CTX
*frame
= talloc_stackframe();
729 struct event_context
*ev
= NULL
;
730 struct tevent_req
*req
= NULL
;
731 NTSTATUS status
= NT_STATUS_OK
;
733 if (cli_has_async_calls(cli
)) {
735 * Can't use sync call while an async call is in flight
737 status
= NT_STATUS_INVALID_PARAMETER
;
741 ev
= event_context_init(frame
);
743 status
= NT_STATUS_NO_MEMORY
;
747 req
= cli_posix_getfacl_send(frame
,
752 status
= NT_STATUS_NO_MEMORY
;
756 if (!tevent_req_poll(req
, ev
)) {
757 status
= map_nt_error_from_unix(errno
);
761 status
= cli_posix_getfacl_recv(req
, mem_ctx
, prb_size
, retbuf
);
765 if (!NT_STATUS_IS_OK(status
)) {
766 cli_set_error(cli
, status
);
771 /****************************************************************************
772 Stat a file (UNIX extensions).
773 ****************************************************************************/
782 static void cli_posix_stat_done(struct tevent_req
*subreq
)
784 struct tevent_req
*req
= tevent_req_callback_data(
785 subreq
, struct tevent_req
);
786 struct stat_state
*state
= tevent_req_data(req
, struct stat_state
);
789 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
,
790 &state
->data
, &state
->num_data
);
792 if (!NT_STATUS_IS_OK(status
)) {
793 tevent_req_nterror(req
, status
);
796 tevent_req_done(req
);
799 struct tevent_req
*cli_posix_stat_send(TALLOC_CTX
*mem_ctx
,
800 struct event_context
*ev
,
801 struct cli_state
*cli
,
804 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
805 struct stat_state
*state
= NULL
;
807 req
= tevent_req_create(mem_ctx
, &state
, struct stat_state
);
812 /* Setup setup word. */
813 SSVAL(&state
->setup
, 0, TRANSACT2_QPATHINFO
);
815 /* Setup param array. */
816 state
->param
= talloc_array(state
, uint8_t, 6);
817 if (tevent_req_nomem(state
->param
, req
)) {
818 return tevent_req_post(req
, ev
);
820 memset(state
->param
, '\0', 6);
821 SSVAL(state
->param
, 0, SMB_QUERY_FILE_UNIX_BASIC
);
823 state
->param
= trans2_bytes_push_str(state
->param
, cli_ucs2(cli
), fname
,
824 strlen(fname
)+1, NULL
);
826 if (tevent_req_nomem(state
->param
, req
)) {
827 return tevent_req_post(req
, ev
);
830 subreq
= cli_trans_send(state
, /* mem ctx. */
832 cli
, /* cli_state. */
833 SMBtrans2
, /* cmd. */
834 NULL
, /* pipe name. */
838 &state
->setup
, /* setup. */
839 1, /* num setup uint16_t words. */
840 0, /* max returned setup. */
841 state
->param
, /* param. */
842 talloc_get_size(state
->param
), /* num param. */
843 2, /* max returned param. */
846 96); /* max returned data. */
848 if (tevent_req_nomem(subreq
, req
)) {
849 return tevent_req_post(req
, ev
);
851 tevent_req_set_callback(subreq
, cli_posix_stat_done
, req
);
855 NTSTATUS
cli_posix_stat_recv(struct tevent_req
*req
,
856 SMB_STRUCT_STAT
*sbuf
)
858 struct stat_state
*state
= tevent_req_data(req
, struct stat_state
);
861 if (tevent_req_is_nterror(req
, &status
)) {
865 if (state
->num_data
!= 96) {
866 return NT_STATUS_DATA_ERROR
;
869 sbuf
->st_ex_size
= IVAL2_TO_SMB_BIG_UINT(state
->data
,0); /* total size, in bytes */
870 sbuf
->st_ex_blocks
= IVAL2_TO_SMB_BIG_UINT(state
->data
,8); /* number of blocks allocated */
871 #if defined (HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
872 sbuf
->st_ex_blocks
/= STAT_ST_BLOCKSIZE
;
874 /* assume 512 byte blocks */
875 sbuf
->st_ex_blocks
/= 512;
877 sbuf
->st_ex_ctime
= interpret_long_date((char *)(state
->data
+ 16)); /* time of last change */
878 sbuf
->st_ex_atime
= interpret_long_date((char *)(state
->data
+ 24)); /* time of last access */
879 sbuf
->st_ex_mtime
= interpret_long_date((char *)(state
->data
+ 32)); /* time of last modification */
881 sbuf
->st_ex_uid
= (uid_t
) IVAL(state
->data
,40); /* user ID of owner */
882 sbuf
->st_ex_gid
= (gid_t
) IVAL(state
->data
,48); /* group ID of owner */
883 sbuf
->st_ex_mode
= unix_filetype_from_wire(IVAL(state
->data
, 56));
884 #if defined(HAVE_MAKEDEV)
886 uint32_t dev_major
= IVAL(state
->data
,60);
887 uint32_t dev_minor
= IVAL(state
->data
,68);
888 sbuf
->st_ex_rdev
= makedev(dev_major
, dev_minor
);
891 sbuf
->st_ex_ino
= (SMB_INO_T
)IVAL2_TO_SMB_BIG_UINT(state
->data
,76); /* inode */
892 sbuf
->st_ex_mode
|= wire_perms_to_unix(IVAL(state
->data
,84)); /* protection */
893 sbuf
->st_ex_nlink
= IVAL(state
->data
,92); /* number of hard links */
898 NTSTATUS
cli_posix_stat(struct cli_state
*cli
,
900 SMB_STRUCT_STAT
*sbuf
)
902 TALLOC_CTX
*frame
= talloc_stackframe();
903 struct event_context
*ev
= NULL
;
904 struct tevent_req
*req
= NULL
;
905 NTSTATUS status
= NT_STATUS_OK
;
907 if (cli_has_async_calls(cli
)) {
909 * Can't use sync call while an async call is in flight
911 status
= NT_STATUS_INVALID_PARAMETER
;
915 ev
= event_context_init(frame
);
917 status
= NT_STATUS_NO_MEMORY
;
921 req
= cli_posix_stat_send(frame
,
926 status
= NT_STATUS_NO_MEMORY
;
930 if (!tevent_req_poll(req
, ev
)) {
931 status
= map_nt_error_from_unix(errno
);
935 status
= cli_posix_stat_recv(req
, sbuf
);
939 if (!NT_STATUS_IS_OK(status
)) {
940 cli_set_error(cli
, status
);
945 /****************************************************************************
946 Chmod or chown a file internal (UNIX extensions).
947 ****************************************************************************/
955 static void cli_posix_chown_chmod_internal_done(struct tevent_req
*subreq
)
957 struct tevent_req
*req
= tevent_req_callback_data(
958 subreq
, struct tevent_req
);
959 struct ch_state
*state
= tevent_req_data(req
, struct ch_state
);
962 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
964 if (!NT_STATUS_IS_OK(status
)) {
965 tevent_req_nterror(req
, status
);
968 tevent_req_done(req
);
971 static struct tevent_req
*cli_posix_chown_chmod_internal_send(TALLOC_CTX
*mem_ctx
,
972 struct event_context
*ev
,
973 struct cli_state
*cli
,
979 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
980 struct ch_state
*state
= NULL
;
982 req
= tevent_req_create(mem_ctx
, &state
, struct ch_state
);
987 /* Setup setup word. */
988 SSVAL(&state
->setup
, 0, TRANSACT2_SETPATHINFO
);
990 /* Setup param array. */
991 state
->param
= talloc_array(state
, uint8_t, 6);
992 if (tevent_req_nomem(state
->param
, req
)) {
993 return tevent_req_post(req
, ev
);
995 memset(state
->param
, '\0', 6);
996 SSVAL(state
->param
,0,SMB_SET_FILE_UNIX_BASIC
);
998 state
->param
= trans2_bytes_push_str(state
->param
, cli_ucs2(cli
), fname
,
999 strlen(fname
)+1, NULL
);
1001 if (tevent_req_nomem(state
->param
, req
)) {
1002 return tevent_req_post(req
, ev
);
1005 /* Setup data array. */
1006 state
->data
= talloc_array(state
, uint8_t, 100);
1007 if (tevent_req_nomem(state
->data
, req
)) {
1008 return tevent_req_post(req
, ev
);
1010 memset(state
->data
, 0xff, 40); /* Set all sizes/times to no change. */
1011 memset(&state
->data
[40], '\0', 60);
1012 SIVAL(state
->data
,40,uid
);
1013 SIVAL(state
->data
,48,gid
);
1014 SIVAL(state
->data
,84,mode
);
1016 subreq
= cli_trans_send(state
, /* mem ctx. */
1017 ev
, /* event ctx. */
1018 cli
, /* cli_state. */
1019 SMBtrans2
, /* cmd. */
1020 NULL
, /* pipe name. */
1024 &state
->setup
, /* setup. */
1025 1, /* num setup uint16_t words. */
1026 0, /* max returned setup. */
1027 state
->param
, /* param. */
1028 talloc_get_size(state
->param
), /* num param. */
1029 2, /* max returned param. */
1030 state
->data
, /* data. */
1031 talloc_get_size(state
->data
), /* num data. */
1032 0); /* max returned data. */
1034 if (tevent_req_nomem(subreq
, req
)) {
1035 return tevent_req_post(req
, ev
);
1037 tevent_req_set_callback(subreq
, cli_posix_chown_chmod_internal_done
, req
);
1041 /****************************************************************************
1042 chmod a file (UNIX extensions).
1043 ****************************************************************************/
1045 struct tevent_req
*cli_posix_chmod_send(TALLOC_CTX
*mem_ctx
,
1046 struct event_context
*ev
,
1047 struct cli_state
*cli
,
1051 return cli_posix_chown_chmod_internal_send(mem_ctx
, ev
, cli
,
1053 unix_perms_to_wire(mode
),
1058 NTSTATUS
cli_posix_chmod_recv(struct tevent_req
*req
)
1062 if (tevent_req_is_nterror(req
, &status
)) {
1065 return NT_STATUS_OK
;
1068 NTSTATUS
cli_posix_chmod(struct cli_state
*cli
, const char *fname
, mode_t mode
)
1070 TALLOC_CTX
*frame
= talloc_stackframe();
1071 struct event_context
*ev
= NULL
;
1072 struct tevent_req
*req
= NULL
;
1073 NTSTATUS status
= NT_STATUS_OK
;
1075 if (cli_has_async_calls(cli
)) {
1077 * Can't use sync call while an async call is in flight
1079 status
= NT_STATUS_INVALID_PARAMETER
;
1083 ev
= event_context_init(frame
);
1085 status
= NT_STATUS_NO_MEMORY
;
1089 req
= cli_posix_chmod_send(frame
,
1095 status
= NT_STATUS_NO_MEMORY
;
1099 if (!tevent_req_poll(req
, ev
)) {
1100 status
= map_nt_error_from_unix(errno
);
1104 status
= cli_posix_chmod_recv(req
);
1108 if (!NT_STATUS_IS_OK(status
)) {
1109 cli_set_error(cli
, status
);
1114 /****************************************************************************
1115 chown a file (UNIX extensions).
1116 ****************************************************************************/
1118 struct tevent_req
*cli_posix_chown_send(TALLOC_CTX
*mem_ctx
,
1119 struct event_context
*ev
,
1120 struct cli_state
*cli
,
1125 return cli_posix_chown_chmod_internal_send(mem_ctx
, ev
, cli
,
1132 NTSTATUS
cli_posix_chown_recv(struct tevent_req
*req
)
1136 if (tevent_req_is_nterror(req
, &status
)) {
1139 return NT_STATUS_OK
;
1142 NTSTATUS
cli_posix_chown(struct cli_state
*cli
,
1147 TALLOC_CTX
*frame
= talloc_stackframe();
1148 struct event_context
*ev
= NULL
;
1149 struct tevent_req
*req
= NULL
;
1150 NTSTATUS status
= NT_STATUS_OK
;
1152 if (cli_has_async_calls(cli
)) {
1154 * Can't use sync call while an async call is in flight
1156 status
= NT_STATUS_INVALID_PARAMETER
;
1160 ev
= event_context_init(frame
);
1162 status
= NT_STATUS_NO_MEMORY
;
1166 req
= cli_posix_chown_send(frame
,
1173 status
= NT_STATUS_NO_MEMORY
;
1177 if (!tevent_req_poll(req
, ev
)) {
1178 status
= map_nt_error_from_unix(errno
);
1182 status
= cli_posix_chown_recv(req
);
1186 if (!NT_STATUS_IS_OK(status
)) {
1187 cli_set_error(cli
, status
);
1192 /****************************************************************************
1194 ****************************************************************************/
1196 static void cli_rename_done(struct tevent_req
*subreq
);
1198 struct cli_rename_state
{
1202 struct tevent_req
*cli_rename_send(TALLOC_CTX
*mem_ctx
,
1203 struct event_context
*ev
,
1204 struct cli_state
*cli
,
1205 const char *fname_src
,
1206 const char *fname_dst
)
1208 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
1209 struct cli_rename_state
*state
= NULL
;
1210 uint8_t additional_flags
= 0;
1211 uint8_t *bytes
= NULL
;
1213 req
= tevent_req_create(mem_ctx
, &state
, struct cli_rename_state
);
1218 SSVAL(state
->vwv
+0, 0, aSYSTEM
| aHIDDEN
| aDIR
);
1220 bytes
= talloc_array(state
, uint8_t, 1);
1221 if (tevent_req_nomem(bytes
, req
)) {
1222 return tevent_req_post(req
, ev
);
1225 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname_src
,
1226 strlen(fname_src
)+1, NULL
);
1227 if (tevent_req_nomem(bytes
, req
)) {
1228 return tevent_req_post(req
, ev
);
1231 bytes
= TALLOC_REALLOC_ARRAY(state
, bytes
, uint8_t,
1232 talloc_get_size(bytes
)+1);
1233 if (tevent_req_nomem(bytes
, req
)) {
1234 return tevent_req_post(req
, ev
);
1237 bytes
[talloc_get_size(bytes
)-1] = 4;
1238 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname_dst
,
1239 strlen(fname_dst
)+1, NULL
);
1240 if (tevent_req_nomem(bytes
, req
)) {
1241 return tevent_req_post(req
, ev
);
1244 subreq
= cli_smb_send(state
, ev
, cli
, SMBmv
, additional_flags
,
1245 1, state
->vwv
, talloc_get_size(bytes
), bytes
);
1246 if (tevent_req_nomem(subreq
, req
)) {
1247 return tevent_req_post(req
, ev
);
1249 tevent_req_set_callback(subreq
, cli_rename_done
, req
);
1253 static void cli_rename_done(struct tevent_req
*subreq
)
1255 struct tevent_req
*req
= tevent_req_callback_data(
1256 subreq
, struct tevent_req
);
1259 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
1260 TALLOC_FREE(subreq
);
1261 if (!NT_STATUS_IS_OK(status
)) {
1262 tevent_req_nterror(req
, status
);
1265 tevent_req_done(req
);
1268 NTSTATUS
cli_rename_recv(struct tevent_req
*req
)
1270 return tevent_req_simple_recv_ntstatus(req
);
1273 NTSTATUS
cli_rename(struct cli_state
*cli
, const char *fname_src
, const char *fname_dst
)
1275 TALLOC_CTX
*frame
= talloc_stackframe();
1276 struct event_context
*ev
;
1277 struct tevent_req
*req
;
1278 NTSTATUS status
= NT_STATUS_OK
;
1280 if (cli_has_async_calls(cli
)) {
1282 * Can't use sync call while an async call is in flight
1284 status
= NT_STATUS_INVALID_PARAMETER
;
1288 ev
= event_context_init(frame
);
1290 status
= NT_STATUS_NO_MEMORY
;
1294 req
= cli_rename_send(frame
, ev
, cli
, fname_src
, fname_dst
);
1296 status
= NT_STATUS_NO_MEMORY
;
1300 if (!tevent_req_poll(req
, ev
)) {
1301 status
= map_nt_error_from_unix(errno
);
1305 status
= cli_rename_recv(req
);
1309 if (!NT_STATUS_IS_OK(status
)) {
1310 cli_set_error(cli
, status
);
1315 /****************************************************************************
1317 ****************************************************************************/
1319 static void cli_ntrename_internal_done(struct tevent_req
*subreq
);
1321 struct cli_ntrename_internal_state
{
1325 static struct tevent_req
*cli_ntrename_internal_send(TALLOC_CTX
*mem_ctx
,
1326 struct event_context
*ev
,
1327 struct cli_state
*cli
,
1328 const char *fname_src
,
1329 const char *fname_dst
,
1330 uint16_t rename_flag
)
1332 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
1333 struct cli_ntrename_internal_state
*state
= NULL
;
1334 uint8_t additional_flags
= 0;
1335 uint8_t *bytes
= NULL
;
1337 req
= tevent_req_create(mem_ctx
, &state
,
1338 struct cli_ntrename_internal_state
);
1343 SSVAL(state
->vwv
+0, 0 ,aSYSTEM
| aHIDDEN
| aDIR
);
1344 SSVAL(state
->vwv
+1, 0, rename_flag
);
1346 bytes
= talloc_array(state
, uint8_t, 1);
1347 if (tevent_req_nomem(bytes
, req
)) {
1348 return tevent_req_post(req
, ev
);
1351 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname_src
,
1352 strlen(fname_src
)+1, NULL
);
1353 if (tevent_req_nomem(bytes
, req
)) {
1354 return tevent_req_post(req
, ev
);
1357 bytes
= TALLOC_REALLOC_ARRAY(state
, bytes
, uint8_t,
1358 talloc_get_size(bytes
)+1);
1359 if (tevent_req_nomem(bytes
, req
)) {
1360 return tevent_req_post(req
, ev
);
1363 bytes
[talloc_get_size(bytes
)-1] = 4;
1364 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname_dst
,
1365 strlen(fname_dst
)+1, NULL
);
1366 if (tevent_req_nomem(bytes
, req
)) {
1367 return tevent_req_post(req
, ev
);
1370 subreq
= cli_smb_send(state
, ev
, cli
, SMBntrename
, additional_flags
,
1371 4, state
->vwv
, talloc_get_size(bytes
), bytes
);
1372 if (tevent_req_nomem(subreq
, req
)) {
1373 return tevent_req_post(req
, ev
);
1375 tevent_req_set_callback(subreq
, cli_ntrename_internal_done
, req
);
1379 static void cli_ntrename_internal_done(struct tevent_req
*subreq
)
1381 struct tevent_req
*req
= tevent_req_callback_data(
1382 subreq
, struct tevent_req
);
1385 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
1386 TALLOC_FREE(subreq
);
1387 if (!NT_STATUS_IS_OK(status
)) {
1388 tevent_req_nterror(req
, status
);
1391 tevent_req_done(req
);
1394 static NTSTATUS
cli_ntrename_internal_recv(struct tevent_req
*req
)
1396 return tevent_req_simple_recv_ntstatus(req
);
1399 struct tevent_req
*cli_ntrename_send(TALLOC_CTX
*mem_ctx
,
1400 struct event_context
*ev
,
1401 struct cli_state
*cli
,
1402 const char *fname_src
,
1403 const char *fname_dst
)
1405 return cli_ntrename_internal_send(mem_ctx
,
1410 RENAME_FLAG_RENAME
);
1413 NTSTATUS
cli_ntrename_recv(struct tevent_req
*req
)
1415 return cli_ntrename_internal_recv(req
);
1418 NTSTATUS
cli_ntrename(struct cli_state
*cli
, const char *fname_src
, const char *fname_dst
)
1420 TALLOC_CTX
*frame
= talloc_stackframe();
1421 struct event_context
*ev
;
1422 struct tevent_req
*req
;
1423 NTSTATUS status
= NT_STATUS_OK
;
1425 if (cli_has_async_calls(cli
)) {
1427 * Can't use sync call while an async call is in flight
1429 status
= NT_STATUS_INVALID_PARAMETER
;
1433 ev
= event_context_init(frame
);
1435 status
= NT_STATUS_NO_MEMORY
;
1439 req
= cli_ntrename_send(frame
, ev
, cli
, fname_src
, fname_dst
);
1441 status
= NT_STATUS_NO_MEMORY
;
1445 if (!tevent_req_poll(req
, ev
)) {
1446 status
= map_nt_error_from_unix(errno
);
1450 status
= cli_ntrename_recv(req
);
1454 if (!NT_STATUS_IS_OK(status
)) {
1455 cli_set_error(cli
, status
);
1460 /****************************************************************************
1462 ****************************************************************************/
1464 struct tevent_req
*cli_nt_hardlink_send(TALLOC_CTX
*mem_ctx
,
1465 struct event_context
*ev
,
1466 struct cli_state
*cli
,
1467 const char *fname_src
,
1468 const char *fname_dst
)
1470 return cli_ntrename_internal_send(mem_ctx
,
1475 RENAME_FLAG_HARD_LINK
);
1478 NTSTATUS
cli_nt_hardlink_recv(struct tevent_req
*req
)
1480 return cli_ntrename_internal_recv(req
);
1483 NTSTATUS
cli_nt_hardlink(struct cli_state
*cli
, const char *fname_src
, const char *fname_dst
)
1485 TALLOC_CTX
*frame
= talloc_stackframe();
1486 struct event_context
*ev
;
1487 struct tevent_req
*req
;
1488 NTSTATUS status
= NT_STATUS_OK
;
1490 if (cli_has_async_calls(cli
)) {
1492 * Can't use sync call while an async call is in flight
1494 status
= NT_STATUS_INVALID_PARAMETER
;
1498 ev
= event_context_init(frame
);
1500 status
= NT_STATUS_NO_MEMORY
;
1504 req
= cli_nt_hardlink_send(frame
, ev
, cli
, fname_src
, fname_dst
);
1506 status
= NT_STATUS_NO_MEMORY
;
1510 if (!tevent_req_poll(req
, ev
)) {
1511 status
= map_nt_error_from_unix(errno
);
1515 status
= cli_nt_hardlink_recv(req
);
1519 if (!NT_STATUS_IS_OK(status
)) {
1520 cli_set_error(cli
, status
);
1525 /****************************************************************************
1527 ****************************************************************************/
1529 static void cli_unlink_done(struct tevent_req
*subreq
);
1531 struct cli_unlink_state
{
1535 struct tevent_req
*cli_unlink_send(TALLOC_CTX
*mem_ctx
,
1536 struct event_context
*ev
,
1537 struct cli_state
*cli
,
1539 uint16_t mayhave_attrs
)
1541 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
1542 struct cli_unlink_state
*state
= NULL
;
1543 uint8_t additional_flags
= 0;
1544 uint8_t *bytes
= NULL
;
1546 req
= tevent_req_create(mem_ctx
, &state
, struct cli_unlink_state
);
1551 SSVAL(state
->vwv
+0, 0, mayhave_attrs
);
1553 bytes
= talloc_array(state
, uint8_t, 1);
1554 if (tevent_req_nomem(bytes
, req
)) {
1555 return tevent_req_post(req
, ev
);
1558 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname
,
1559 strlen(fname
)+1, NULL
);
1561 if (tevent_req_nomem(bytes
, req
)) {
1562 return tevent_req_post(req
, ev
);
1565 subreq
= cli_smb_send(state
, ev
, cli
, SMBunlink
, additional_flags
,
1566 1, state
->vwv
, talloc_get_size(bytes
), bytes
);
1567 if (tevent_req_nomem(subreq
, req
)) {
1568 return tevent_req_post(req
, ev
);
1570 tevent_req_set_callback(subreq
, cli_unlink_done
, req
);
1574 static void cli_unlink_done(struct tevent_req
*subreq
)
1576 struct tevent_req
*req
= tevent_req_callback_data(
1577 subreq
, struct tevent_req
);
1580 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
1581 TALLOC_FREE(subreq
);
1582 if (!NT_STATUS_IS_OK(status
)) {
1583 tevent_req_nterror(req
, status
);
1586 tevent_req_done(req
);
1589 NTSTATUS
cli_unlink_recv(struct tevent_req
*req
)
1591 return tevent_req_simple_recv_ntstatus(req
);
1594 NTSTATUS
cli_unlink(struct cli_state
*cli
, const char *fname
, uint16_t mayhave_attrs
)
1596 TALLOC_CTX
*frame
= talloc_stackframe();
1597 struct event_context
*ev
;
1598 struct tevent_req
*req
;
1599 NTSTATUS status
= NT_STATUS_OK
;
1601 if (cli_has_async_calls(cli
)) {
1603 * Can't use sync call while an async call is in flight
1605 status
= NT_STATUS_INVALID_PARAMETER
;
1609 ev
= event_context_init(frame
);
1611 status
= NT_STATUS_NO_MEMORY
;
1615 req
= cli_unlink_send(frame
, ev
, cli
, fname
, mayhave_attrs
);
1617 status
= NT_STATUS_NO_MEMORY
;
1621 if (!tevent_req_poll(req
, ev
)) {
1622 status
= map_nt_error_from_unix(errno
);
1626 status
= cli_unlink_recv(req
);
1630 if (!NT_STATUS_IS_OK(status
)) {
1631 cli_set_error(cli
, status
);
1636 /****************************************************************************
1638 ****************************************************************************/
1640 static void cli_mkdir_done(struct tevent_req
*subreq
);
1642 struct cli_mkdir_state
{
1646 struct tevent_req
*cli_mkdir_send(TALLOC_CTX
*mem_ctx
,
1647 struct event_context
*ev
,
1648 struct cli_state
*cli
,
1651 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
1652 struct cli_mkdir_state
*state
= NULL
;
1653 uint8_t additional_flags
= 0;
1654 uint8_t *bytes
= NULL
;
1656 req
= tevent_req_create(mem_ctx
, &state
, struct cli_mkdir_state
);
1661 bytes
= talloc_array(state
, uint8_t, 1);
1662 if (tevent_req_nomem(bytes
, req
)) {
1663 return tevent_req_post(req
, ev
);
1666 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), dname
,
1667 strlen(dname
)+1, NULL
);
1669 if (tevent_req_nomem(bytes
, req
)) {
1670 return tevent_req_post(req
, ev
);
1673 subreq
= cli_smb_send(state
, ev
, cli
, SMBmkdir
, additional_flags
,
1674 0, NULL
, talloc_get_size(bytes
), bytes
);
1675 if (tevent_req_nomem(subreq
, req
)) {
1676 return tevent_req_post(req
, ev
);
1678 tevent_req_set_callback(subreq
, cli_mkdir_done
, req
);
1682 static void cli_mkdir_done(struct tevent_req
*subreq
)
1684 struct tevent_req
*req
= tevent_req_callback_data(
1685 subreq
, struct tevent_req
);
1688 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
1689 TALLOC_FREE(subreq
);
1690 if (!NT_STATUS_IS_OK(status
)) {
1691 tevent_req_nterror(req
, status
);
1694 tevent_req_done(req
);
1697 NTSTATUS
cli_mkdir_recv(struct tevent_req
*req
)
1699 return tevent_req_simple_recv_ntstatus(req
);
1702 NTSTATUS
cli_mkdir(struct cli_state
*cli
, const char *dname
)
1704 TALLOC_CTX
*frame
= talloc_stackframe();
1705 struct event_context
*ev
;
1706 struct tevent_req
*req
;
1707 NTSTATUS status
= NT_STATUS_OK
;
1709 if (cli_has_async_calls(cli
)) {
1711 * Can't use sync call while an async call is in flight
1713 status
= NT_STATUS_INVALID_PARAMETER
;
1717 ev
= event_context_init(frame
);
1719 status
= NT_STATUS_NO_MEMORY
;
1723 req
= cli_mkdir_send(frame
, ev
, cli
, dname
);
1725 status
= NT_STATUS_NO_MEMORY
;
1729 if (!tevent_req_poll(req
, ev
)) {
1730 status
= map_nt_error_from_unix(errno
);
1734 status
= cli_mkdir_recv(req
);
1738 if (!NT_STATUS_IS_OK(status
)) {
1739 cli_set_error(cli
, status
);
1744 /****************************************************************************
1746 ****************************************************************************/
1748 static void cli_rmdir_done(struct tevent_req
*subreq
);
1750 struct cli_rmdir_state
{
1754 struct tevent_req
*cli_rmdir_send(TALLOC_CTX
*mem_ctx
,
1755 struct event_context
*ev
,
1756 struct cli_state
*cli
,
1759 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
1760 struct cli_rmdir_state
*state
= NULL
;
1761 uint8_t additional_flags
= 0;
1762 uint8_t *bytes
= NULL
;
1764 req
= tevent_req_create(mem_ctx
, &state
, struct cli_rmdir_state
);
1769 bytes
= talloc_array(state
, uint8_t, 1);
1770 if (tevent_req_nomem(bytes
, req
)) {
1771 return tevent_req_post(req
, ev
);
1774 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), dname
,
1775 strlen(dname
)+1, NULL
);
1777 if (tevent_req_nomem(bytes
, req
)) {
1778 return tevent_req_post(req
, ev
);
1781 subreq
= cli_smb_send(state
, ev
, cli
, SMBrmdir
, additional_flags
,
1782 0, NULL
, talloc_get_size(bytes
), bytes
);
1783 if (tevent_req_nomem(subreq
, req
)) {
1784 return tevent_req_post(req
, ev
);
1786 tevent_req_set_callback(subreq
, cli_rmdir_done
, req
);
1790 static void cli_rmdir_done(struct tevent_req
*subreq
)
1792 struct tevent_req
*req
= tevent_req_callback_data(
1793 subreq
, struct tevent_req
);
1796 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
1797 TALLOC_FREE(subreq
);
1798 if (!NT_STATUS_IS_OK(status
)) {
1799 tevent_req_nterror(req
, status
);
1802 tevent_req_done(req
);
1805 NTSTATUS
cli_rmdir_recv(struct tevent_req
*req
)
1807 return tevent_req_simple_recv_ntstatus(req
);
1810 NTSTATUS
cli_rmdir(struct cli_state
*cli
, const char *dname
)
1812 TALLOC_CTX
*frame
= talloc_stackframe();
1813 struct event_context
*ev
;
1814 struct tevent_req
*req
;
1815 NTSTATUS status
= NT_STATUS_OK
;
1817 if (cli_has_async_calls(cli
)) {
1819 * Can't use sync call while an async call is in flight
1821 status
= NT_STATUS_INVALID_PARAMETER
;
1825 ev
= event_context_init(frame
);
1827 status
= NT_STATUS_NO_MEMORY
;
1831 req
= cli_rmdir_send(frame
, ev
, cli
, dname
);
1833 status
= NT_STATUS_NO_MEMORY
;
1837 if (!tevent_req_poll(req
, ev
)) {
1838 status
= map_nt_error_from_unix(errno
);
1842 status
= cli_rmdir_recv(req
);
1846 if (!NT_STATUS_IS_OK(status
)) {
1847 cli_set_error(cli
, status
);
1852 /****************************************************************************
1853 Set or clear the delete on close flag.
1854 ****************************************************************************/
1862 static void cli_nt_delete_on_close_done(struct tevent_req
*subreq
)
1864 struct tevent_req
*req
= tevent_req_callback_data(
1865 subreq
, struct tevent_req
);
1866 struct doc_state
*state
= tevent_req_data(req
, struct doc_state
);
1869 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1870 TALLOC_FREE(subreq
);
1871 if (!NT_STATUS_IS_OK(status
)) {
1872 tevent_req_nterror(req
, status
);
1875 tevent_req_done(req
);
1878 struct tevent_req
*cli_nt_delete_on_close_send(TALLOC_CTX
*mem_ctx
,
1879 struct event_context
*ev
,
1880 struct cli_state
*cli
,
1884 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
1885 struct doc_state
*state
= NULL
;
1887 req
= tevent_req_create(mem_ctx
, &state
, struct doc_state
);
1892 /* Setup setup word. */
1893 SSVAL(&state
->setup
, 0, TRANSACT2_SETFILEINFO
);
1895 /* Setup param array. */
1896 SSVAL(state
->param
,0,fnum
);
1897 SSVAL(state
->param
,2,SMB_SET_FILE_DISPOSITION_INFO
);
1899 /* Setup data array. */
1900 SCVAL(&state
->data
[0], 0, flag
? 1 : 0);
1902 subreq
= cli_trans_send(state
, /* mem ctx. */
1903 ev
, /* event ctx. */
1904 cli
, /* cli_state. */
1905 SMBtrans2
, /* cmd. */
1906 NULL
, /* pipe name. */
1910 &state
->setup
, /* setup. */
1911 1, /* num setup uint16_t words. */
1912 0, /* max returned setup. */
1913 state
->param
, /* param. */
1915 2, /* max returned param. */
1916 state
->data
, /* data. */
1918 0); /* max returned data. */
1920 if (tevent_req_nomem(subreq
, req
)) {
1921 return tevent_req_post(req
, ev
);
1923 tevent_req_set_callback(subreq
, cli_nt_delete_on_close_done
, req
);
1927 NTSTATUS
cli_nt_delete_on_close_recv(struct tevent_req
*req
)
1931 if (tevent_req_is_nterror(req
, &status
)) {
1934 return NT_STATUS_OK
;
1937 NTSTATUS
cli_nt_delete_on_close(struct cli_state
*cli
, uint16_t fnum
, bool flag
)
1939 TALLOC_CTX
*frame
= talloc_stackframe();
1940 struct event_context
*ev
= NULL
;
1941 struct tevent_req
*req
= NULL
;
1942 NTSTATUS status
= NT_STATUS_OK
;
1944 if (cli_has_async_calls(cli
)) {
1946 * Can't use sync call while an async call is in flight
1948 status
= NT_STATUS_INVALID_PARAMETER
;
1952 ev
= event_context_init(frame
);
1954 status
= NT_STATUS_NO_MEMORY
;
1958 req
= cli_nt_delete_on_close_send(frame
,
1964 status
= NT_STATUS_NO_MEMORY
;
1968 if (!tevent_req_poll(req
, ev
)) {
1969 status
= map_nt_error_from_unix(errno
);
1973 status
= cli_nt_delete_on_close_recv(req
);
1977 if (!NT_STATUS_IS_OK(status
)) {
1978 cli_set_error(cli
, status
);
1983 struct cli_ntcreate_state
{
1988 static void cli_ntcreate_done(struct tevent_req
*subreq
);
1990 struct tevent_req
*cli_ntcreate_send(TALLOC_CTX
*mem_ctx
,
1991 struct event_context
*ev
,
1992 struct cli_state
*cli
,
1994 uint32_t CreatFlags
,
1995 uint32_t DesiredAccess
,
1996 uint32_t FileAttributes
,
1997 uint32_t ShareAccess
,
1998 uint32_t CreateDisposition
,
1999 uint32_t CreateOptions
,
2000 uint8_t SecurityFlags
)
2002 struct tevent_req
*req
, *subreq
;
2003 struct cli_ntcreate_state
*state
;
2006 size_t converted_len
;
2008 req
= tevent_req_create(mem_ctx
, &state
, struct cli_ntcreate_state
);
2015 SCVAL(vwv
+0, 0, 0xFF);
2020 if (cli
->use_oplocks
) {
2021 CreatFlags
|= (REQUEST_OPLOCK
|REQUEST_BATCH_OPLOCK
);
2023 SIVAL(vwv
+3, 1, CreatFlags
);
2024 SIVAL(vwv
+5, 1, 0x0); /* RootDirectoryFid */
2025 SIVAL(vwv
+7, 1, DesiredAccess
);
2026 SIVAL(vwv
+9, 1, 0x0); /* AllocationSize */
2027 SIVAL(vwv
+11, 1, 0x0); /* AllocationSize */
2028 SIVAL(vwv
+13, 1, FileAttributes
);
2029 SIVAL(vwv
+15, 1, ShareAccess
);
2030 SIVAL(vwv
+17, 1, CreateDisposition
);
2031 SIVAL(vwv
+19, 1, CreateOptions
);
2032 SIVAL(vwv
+21, 1, 0x02); /* ImpersonationLevel */
2033 SCVAL(vwv
+23, 1, SecurityFlags
);
2035 bytes
= talloc_array(state
, uint8_t, 0);
2036 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
),
2037 fname
, strlen(fname
)+1,
2040 /* sigh. this copes with broken netapp filer behaviour */
2041 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), "", 1, NULL
);
2043 if (tevent_req_nomem(bytes
, req
)) {
2044 return tevent_req_post(req
, ev
);
2047 SSVAL(vwv
+2, 1, converted_len
);
2049 subreq
= cli_smb_send(state
, ev
, cli
, SMBntcreateX
, 0, 24, vwv
,
2050 talloc_get_size(bytes
), bytes
);
2051 if (tevent_req_nomem(subreq
, req
)) {
2052 return tevent_req_post(req
, ev
);
2054 tevent_req_set_callback(subreq
, cli_ntcreate_done
, req
);
2058 static void cli_ntcreate_done(struct tevent_req
*subreq
)
2060 struct tevent_req
*req
= tevent_req_callback_data(
2061 subreq
, struct tevent_req
);
2062 struct cli_ntcreate_state
*state
= tevent_req_data(
2063 req
, struct cli_ntcreate_state
);
2070 status
= cli_smb_recv(subreq
, 3, &wct
, &vwv
, &num_bytes
, &bytes
);
2071 if (!NT_STATUS_IS_OK(status
)) {
2072 TALLOC_FREE(subreq
);
2073 tevent_req_nterror(req
, status
);
2076 state
->fnum
= SVAL(vwv
+2, 1);
2077 tevent_req_done(req
);
2080 NTSTATUS
cli_ntcreate_recv(struct tevent_req
*req
, uint16_t *pfnum
)
2082 struct cli_ntcreate_state
*state
= tevent_req_data(
2083 req
, struct cli_ntcreate_state
);
2086 if (tevent_req_is_nterror(req
, &status
)) {
2089 *pfnum
= state
->fnum
;
2090 return NT_STATUS_OK
;
2093 NTSTATUS
cli_ntcreate(struct cli_state
*cli
,
2095 uint32_t CreatFlags
,
2096 uint32_t DesiredAccess
,
2097 uint32_t FileAttributes
,
2098 uint32_t ShareAccess
,
2099 uint32_t CreateDisposition
,
2100 uint32_t CreateOptions
,
2101 uint8_t SecurityFlags
,
2104 TALLOC_CTX
*frame
= talloc_stackframe();
2105 struct event_context
*ev
;
2106 struct tevent_req
*req
;
2107 NTSTATUS status
= NT_STATUS_OK
;
2109 if (cli_has_async_calls(cli
)) {
2111 * Can't use sync call while an async call is in flight
2113 status
= NT_STATUS_INVALID_PARAMETER
;
2117 ev
= event_context_init(frame
);
2119 status
= NT_STATUS_NO_MEMORY
;
2123 req
= cli_ntcreate_send(frame
, ev
, cli
, fname
, CreatFlags
,
2124 DesiredAccess
, FileAttributes
, ShareAccess
,
2125 CreateDisposition
, CreateOptions
,
2128 status
= NT_STATUS_NO_MEMORY
;
2132 if (!tevent_req_poll(req
, ev
)) {
2133 status
= map_nt_error_from_unix(errno
);
2137 status
= cli_ntcreate_recv(req
, pfid
);
2140 if (!NT_STATUS_IS_OK(status
)) {
2141 cli_set_error(cli
, status
);
2146 /****************************************************************************
2148 WARNING: if you open with O_WRONLY then getattrE won't work!
2149 ****************************************************************************/
2151 struct cli_open_state
{
2152 struct tevent_context
*ev
;
2153 struct cli_state
*cli
;
2159 uint8_t additional_flags
;
2163 static void cli_open_done(struct tevent_req
*subreq
);
2164 static void cli_open_ntcreate_done(struct tevent_req
*subreq
);
2166 struct tevent_req
*cli_open_create(TALLOC_CTX
*mem_ctx
,
2167 struct event_context
*ev
,
2168 struct cli_state
*cli
, const char *fname
,
2169 int flags
, int share_mode
,
2170 struct tevent_req
**psmbreq
)
2172 struct tevent_req
*req
, *subreq
;
2173 struct cli_open_state
*state
;
2176 req
= tevent_req_create(mem_ctx
, &state
, struct cli_open_state
);
2182 state
->fname
= fname
;
2184 if (flags
& O_CREAT
) {
2185 state
->openfn
|= (1<<4);
2187 if (!(flags
& O_EXCL
)) {
2188 if (flags
& O_TRUNC
)
2189 state
->openfn
|= (1<<1);
2191 state
->openfn
|= (1<<0);
2194 state
->dos_deny
= (share_mode
<<4);
2196 if ((flags
& O_ACCMODE
) == O_RDWR
) {
2197 state
->dos_deny
|= 2;
2198 } else if ((flags
& O_ACCMODE
) == O_WRONLY
) {
2199 state
->dos_deny
|= 1;
2203 if ((flags
& O_SYNC
) == O_SYNC
) {
2204 state
->dos_deny
|= (1<<14);
2208 if (share_mode
== DENY_FCB
) {
2209 state
->dos_deny
= 0xFF;
2212 SCVAL(state
->vwv
+ 0, 0, 0xFF);
2213 SCVAL(state
->vwv
+ 0, 1, 0);
2214 SSVAL(state
->vwv
+ 1, 0, 0);
2215 SSVAL(state
->vwv
+ 2, 0, 0); /* no additional info */
2216 SSVAL(state
->vwv
+ 3, 0, state
->dos_deny
);
2217 SSVAL(state
->vwv
+ 4, 0, aSYSTEM
| aHIDDEN
);
2218 SSVAL(state
->vwv
+ 5, 0, 0);
2219 SIVAL(state
->vwv
+ 6, 0, 0);
2220 SSVAL(state
->vwv
+ 8, 0, state
->openfn
);
2221 SIVAL(state
->vwv
+ 9, 0, 0);
2222 SIVAL(state
->vwv
+ 11, 0, 0);
2223 SIVAL(state
->vwv
+ 13, 0, 0);
2225 if (cli
->use_oplocks
) {
2226 /* if using oplocks then ask for a batch oplock via
2227 core and extended methods */
2228 state
->additional_flags
=
2229 FLAG_REQUEST_OPLOCK
|FLAG_REQUEST_BATCH_OPLOCK
;
2230 SSVAL(state
->vwv
+2, 0, SVAL(state
->vwv
+2, 0) | 6);
2233 bytes
= talloc_array(state
, uint8_t, 0);
2234 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname
,
2235 strlen(fname
)+1, NULL
);
2237 if (tevent_req_nomem(bytes
, req
)) {
2238 return tevent_req_post(req
, ev
);
2241 state
->bytes
.iov_base
= (void *)bytes
;
2242 state
->bytes
.iov_len
= talloc_get_size(bytes
);
2244 subreq
= cli_smb_req_create(state
, ev
, cli
, SMBopenX
,
2245 state
->additional_flags
,
2246 15, state
->vwv
, 1, &state
->bytes
);
2247 if (subreq
== NULL
) {
2251 tevent_req_set_callback(subreq
, cli_open_done
, req
);
2256 struct tevent_req
*cli_open_send(TALLOC_CTX
*mem_ctx
, struct event_context
*ev
,
2257 struct cli_state
*cli
, const char *fname
,
2258 int flags
, int share_mode
)
2260 struct tevent_req
*req
, *subreq
;
2263 req
= cli_open_create(mem_ctx
, ev
, cli
, fname
, flags
, share_mode
,
2269 status
= cli_smb_req_send(subreq
);
2270 if (!NT_STATUS_IS_OK(status
)) {
2271 tevent_req_nterror(req
, status
);
2272 return tevent_req_post(req
, ev
);
2277 static void cli_open_done(struct tevent_req
*subreq
)
2279 struct tevent_req
*req
= tevent_req_callback_data(
2280 subreq
, struct tevent_req
);
2281 struct cli_open_state
*state
= tevent_req_data(
2282 req
, struct cli_open_state
);
2286 uint32_t access_mask
, share_mode
, create_disposition
, create_options
;
2288 status
= cli_smb_recv(subreq
, 3, &wct
, &vwv
, NULL
, NULL
);
2289 TALLOC_FREE(subreq
);
2291 if (NT_STATUS_IS_OK(status
)) {
2292 state
->fnum
= SVAL(vwv
+2, 0);
2293 tevent_req_done(req
);
2297 if (!NT_STATUS_EQUAL(status
, NT_STATUS_NOT_SUPPORTED
)) {
2298 tevent_req_nterror(req
, status
);
2303 * For the new shiny OS/X Lion SMB server, try a ntcreate
2307 if (!map_open_params_to_ntcreate(state
->fname
, state
->dos_deny
,
2308 state
->openfn
, &access_mask
,
2309 &share_mode
, &create_disposition
,
2311 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
2315 subreq
= cli_ntcreate_send(state
, state
->ev
, state
->cli
,
2316 state
->fname
, 0, access_mask
,
2317 0, share_mode
, create_disposition
,
2319 if (tevent_req_nomem(subreq
, req
)) {
2322 tevent_req_set_callback(subreq
, cli_open_ntcreate_done
, req
);
2325 static void cli_open_ntcreate_done(struct tevent_req
*subreq
)
2327 struct tevent_req
*req
= tevent_req_callback_data(
2328 subreq
, struct tevent_req
);
2329 struct cli_open_state
*state
= tevent_req_data(
2330 req
, struct cli_open_state
);
2333 status
= cli_ntcreate_recv(subreq
, &state
->fnum
);
2334 TALLOC_FREE(subreq
);
2336 if (!NT_STATUS_IS_OK(status
)) {
2337 tevent_req_nterror(req
, status
);
2340 tevent_req_done(req
);
2343 NTSTATUS
cli_open_recv(struct tevent_req
*req
, uint16_t *pfnum
)
2345 struct cli_open_state
*state
= tevent_req_data(
2346 req
, struct cli_open_state
);
2349 if (tevent_req_is_nterror(req
, &status
)) {
2352 *pfnum
= state
->fnum
;
2353 return NT_STATUS_OK
;
2356 NTSTATUS
cli_open(struct cli_state
*cli
, const char *fname
, int flags
,
2357 int share_mode
, uint16_t *pfnum
)
2359 TALLOC_CTX
*frame
= talloc_stackframe();
2360 struct event_context
*ev
;
2361 struct tevent_req
*req
;
2362 NTSTATUS status
= NT_STATUS_OK
;
2364 if (cli_has_async_calls(cli
)) {
2366 * Can't use sync call while an async call is in flight
2368 status
= NT_STATUS_INVALID_PARAMETER
;
2372 ev
= event_context_init(frame
);
2374 status
= NT_STATUS_NO_MEMORY
;
2378 req
= cli_open_send(frame
, ev
, cli
, fname
, flags
, share_mode
);
2380 status
= NT_STATUS_NO_MEMORY
;
2384 if (!tevent_req_poll(req
, ev
)) {
2385 status
= map_nt_error_from_unix(errno
);
2389 status
= cli_open_recv(req
, pfnum
);
2392 if (!NT_STATUS_IS_OK(status
)) {
2393 cli_set_error(cli
, status
);
2398 /****************************************************************************
2400 ****************************************************************************/
2402 struct cli_close_state
{
2406 static void cli_close_done(struct tevent_req
*subreq
);
2408 struct tevent_req
*cli_close_create(TALLOC_CTX
*mem_ctx
,
2409 struct event_context
*ev
,
2410 struct cli_state
*cli
,
2412 struct tevent_req
**psubreq
)
2414 struct tevent_req
*req
, *subreq
;
2415 struct cli_close_state
*state
;
2417 req
= tevent_req_create(mem_ctx
, &state
, struct cli_close_state
);
2422 SSVAL(state
->vwv
+0, 0, fnum
);
2423 SIVALS(state
->vwv
+1, 0, -1);
2425 subreq
= cli_smb_req_create(state
, ev
, cli
, SMBclose
, 0, 3, state
->vwv
,
2427 if (subreq
== NULL
) {
2431 tevent_req_set_callback(subreq
, cli_close_done
, req
);
2436 struct tevent_req
*cli_close_send(TALLOC_CTX
*mem_ctx
,
2437 struct event_context
*ev
,
2438 struct cli_state
*cli
,
2441 struct tevent_req
*req
, *subreq
;
2444 req
= cli_close_create(mem_ctx
, ev
, cli
, fnum
, &subreq
);
2449 status
= cli_smb_req_send(subreq
);
2450 if (!NT_STATUS_IS_OK(status
)) {
2451 tevent_req_nterror(req
, status
);
2452 return tevent_req_post(req
, ev
);
2457 static void cli_close_done(struct tevent_req
*subreq
)
2459 struct tevent_req
*req
= tevent_req_callback_data(
2460 subreq
, struct tevent_req
);
2463 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
2464 TALLOC_FREE(subreq
);
2465 if (!NT_STATUS_IS_OK(status
)) {
2466 tevent_req_nterror(req
, status
);
2469 tevent_req_done(req
);
2472 NTSTATUS
cli_close_recv(struct tevent_req
*req
)
2474 return tevent_req_simple_recv_ntstatus(req
);
2477 NTSTATUS
cli_close(struct cli_state
*cli
, uint16_t fnum
)
2479 TALLOC_CTX
*frame
= talloc_stackframe();
2480 struct event_context
*ev
;
2481 struct tevent_req
*req
;
2482 NTSTATUS status
= NT_STATUS_OK
;
2484 if (cli_has_async_calls(cli
)) {
2486 * Can't use sync call while an async call is in flight
2488 status
= NT_STATUS_INVALID_PARAMETER
;
2492 ev
= event_context_init(frame
);
2494 status
= NT_STATUS_NO_MEMORY
;
2498 req
= cli_close_send(frame
, ev
, cli
, fnum
);
2500 status
= NT_STATUS_NO_MEMORY
;
2504 if (!tevent_req_poll(req
, ev
)) {
2505 status
= map_nt_error_from_unix(errno
);
2509 status
= cli_close_recv(req
);
2512 if (!NT_STATUS_IS_OK(status
)) {
2513 cli_set_error(cli
, status
);
2518 /****************************************************************************
2519 Truncate a file to a specified size
2520 ****************************************************************************/
2522 struct ftrunc_state
{
2528 static void cli_ftruncate_done(struct tevent_req
*subreq
)
2530 struct tevent_req
*req
= tevent_req_callback_data(
2531 subreq
, struct tevent_req
);
2532 struct ftrunc_state
*state
= tevent_req_data(req
, struct ftrunc_state
);
2535 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
2536 TALLOC_FREE(subreq
);
2537 if (!NT_STATUS_IS_OK(status
)) {
2538 tevent_req_nterror(req
, status
);
2541 tevent_req_done(req
);
2544 struct tevent_req
*cli_ftruncate_send(TALLOC_CTX
*mem_ctx
,
2545 struct event_context
*ev
,
2546 struct cli_state
*cli
,
2550 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
2551 struct ftrunc_state
*state
= NULL
;
2553 req
= tevent_req_create(mem_ctx
, &state
, struct ftrunc_state
);
2558 /* Setup setup word. */
2559 SSVAL(&state
->setup
, 0, TRANSACT2_SETFILEINFO
);
2561 /* Setup param array. */
2562 SSVAL(state
->param
,0,fnum
);
2563 SSVAL(state
->param
,2,SMB_SET_FILE_END_OF_FILE_INFO
);
2564 SSVAL(state
->param
,4,0);
2566 /* Setup data array. */
2567 SBVAL(state
->data
, 0, size
);
2569 subreq
= cli_trans_send(state
, /* mem ctx. */
2570 ev
, /* event ctx. */
2571 cli
, /* cli_state. */
2572 SMBtrans2
, /* cmd. */
2573 NULL
, /* pipe name. */
2577 &state
->setup
, /* setup. */
2578 1, /* num setup uint16_t words. */
2579 0, /* max returned setup. */
2580 state
->param
, /* param. */
2582 2, /* max returned param. */
2583 state
->data
, /* data. */
2585 0); /* max returned data. */
2587 if (tevent_req_nomem(subreq
, req
)) {
2588 return tevent_req_post(req
, ev
);
2590 tevent_req_set_callback(subreq
, cli_ftruncate_done
, req
);
2594 NTSTATUS
cli_ftruncate_recv(struct tevent_req
*req
)
2598 if (tevent_req_is_nterror(req
, &status
)) {
2601 return NT_STATUS_OK
;
2604 NTSTATUS
cli_ftruncate(struct cli_state
*cli
, uint16_t fnum
, uint64_t size
)
2606 TALLOC_CTX
*frame
= talloc_stackframe();
2607 struct event_context
*ev
= NULL
;
2608 struct tevent_req
*req
= NULL
;
2609 NTSTATUS status
= NT_STATUS_OK
;
2611 if (cli_has_async_calls(cli
)) {
2613 * Can't use sync call while an async call is in flight
2615 status
= NT_STATUS_INVALID_PARAMETER
;
2619 ev
= event_context_init(frame
);
2621 status
= NT_STATUS_NO_MEMORY
;
2625 req
= cli_ftruncate_send(frame
,
2631 status
= NT_STATUS_NO_MEMORY
;
2635 if (!tevent_req_poll(req
, ev
)) {
2636 status
= map_nt_error_from_unix(errno
);
2640 status
= cli_ftruncate_recv(req
);
2644 if (!NT_STATUS_IS_OK(status
)) {
2645 cli_set_error(cli
, status
);
2650 /****************************************************************************
2651 send a lock with a specified locktype
2652 this is used for testing LOCKING_ANDX_CANCEL_LOCK
2653 ****************************************************************************/
2655 NTSTATUS
cli_locktype(struct cli_state
*cli
, uint16_t fnum
,
2656 uint32_t offset
, uint32_t len
,
2657 int timeout
, unsigned char locktype
)
2660 int saved_timeout
= cli
->timeout
;
2662 memset(cli
->outbuf
,'\0',smb_size
);
2663 memset(cli
->inbuf
,'\0', smb_size
);
2665 cli_set_message(cli
->outbuf
,8,0,True
);
2667 SCVAL(cli
->outbuf
,smb_com
,SMBlockingX
);
2668 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
2669 cli_setup_packet(cli
);
2671 SCVAL(cli
->outbuf
,smb_vwv0
,0xFF);
2672 SSVAL(cli
->outbuf
,smb_vwv2
,fnum
);
2673 SCVAL(cli
->outbuf
,smb_vwv3
,locktype
);
2674 SIVALS(cli
->outbuf
, smb_vwv4
, timeout
);
2675 SSVAL(cli
->outbuf
,smb_vwv6
,0);
2676 SSVAL(cli
->outbuf
,smb_vwv7
,1);
2678 p
= smb_buf(cli
->outbuf
);
2679 SSVAL(p
, 0, cli
->pid
);
2680 SIVAL(p
, 2, offset
);
2685 cli_setup_bcc(cli
, p
);
2690 cli
->timeout
= (timeout
== -1) ? 0x7FFFFFFF : (timeout
+ 2*1000);
2693 if (!cli_receive_smb(cli
)) {
2694 cli
->timeout
= saved_timeout
;
2695 return NT_STATUS_UNSUCCESSFUL
;
2698 cli
->timeout
= saved_timeout
;
2700 return cli_nt_error(cli
);
2703 /****************************************************************************
2705 note that timeout is in units of 2 milliseconds
2706 ****************************************************************************/
2708 bool cli_lock(struct cli_state
*cli
, uint16_t fnum
,
2709 uint32_t offset
, uint32_t len
, int timeout
, enum brl_type lock_type
)
2712 int saved_timeout
= cli
->timeout
;
2714 memset(cli
->outbuf
,'\0',smb_size
);
2715 memset(cli
->inbuf
,'\0', smb_size
);
2717 cli_set_message(cli
->outbuf
,8,0,True
);
2719 SCVAL(cli
->outbuf
,smb_com
,SMBlockingX
);
2720 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
2721 cli_setup_packet(cli
);
2723 SCVAL(cli
->outbuf
,smb_vwv0
,0xFF);
2724 SSVAL(cli
->outbuf
,smb_vwv2
,fnum
);
2725 SCVAL(cli
->outbuf
,smb_vwv3
,(lock_type
== READ_LOCK
? 1 : 0));
2726 SIVALS(cli
->outbuf
, smb_vwv4
, timeout
);
2727 SSVAL(cli
->outbuf
,smb_vwv6
,0);
2728 SSVAL(cli
->outbuf
,smb_vwv7
,1);
2730 p
= smb_buf(cli
->outbuf
);
2731 SSVAL(p
, 0, cli
->pid
);
2732 SIVAL(p
, 2, offset
);
2737 cli_setup_bcc(cli
, p
);
2742 cli
->timeout
= (timeout
== -1) ? 0x7FFFFFFF : (timeout
*2 + 5*1000);
2745 if (!cli_receive_smb(cli
)) {
2746 cli
->timeout
= saved_timeout
;
2750 cli
->timeout
= saved_timeout
;
2752 if (cli_is_error(cli
)) {
2759 /****************************************************************************
2761 ****************************************************************************/
2763 struct cli_unlock_state
{
2768 static void cli_unlock_done(struct tevent_req
*subreq
);
2770 struct tevent_req
*cli_unlock_send(TALLOC_CTX
*mem_ctx
,
2771 struct event_context
*ev
,
2772 struct cli_state
*cli
,
2778 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
2779 struct cli_unlock_state
*state
= NULL
;
2780 uint8_t additional_flags
= 0;
2782 req
= tevent_req_create(mem_ctx
, &state
, struct cli_unlock_state
);
2787 SCVAL(state
->vwv
+0, 0, 0xFF);
2788 SSVAL(state
->vwv
+2, 0, fnum
);
2789 SCVAL(state
->vwv
+3, 0, 0);
2790 SIVALS(state
->vwv
+4, 0, 0);
2791 SSVAL(state
->vwv
+6, 0, 1);
2792 SSVAL(state
->vwv
+7, 0, 0);
2794 SSVAL(state
->data
, 0, cli
->pid
);
2795 SIVAL(state
->data
, 2, offset
);
2796 SIVAL(state
->data
, 6, len
);
2798 subreq
= cli_smb_send(state
, ev
, cli
, SMBlockingX
, additional_flags
,
2799 8, state
->vwv
, 10, state
->data
);
2800 if (tevent_req_nomem(subreq
, req
)) {
2801 return tevent_req_post(req
, ev
);
2803 tevent_req_set_callback(subreq
, cli_unlock_done
, req
);
2807 static void cli_unlock_done(struct tevent_req
*subreq
)
2809 struct tevent_req
*req
= tevent_req_callback_data(
2810 subreq
, struct tevent_req
);
2813 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
2814 TALLOC_FREE(subreq
);
2815 if (!NT_STATUS_IS_OK(status
)) {
2816 tevent_req_nterror(req
, status
);
2819 tevent_req_done(req
);
2822 NTSTATUS
cli_unlock_recv(struct tevent_req
*req
)
2824 return tevent_req_simple_recv_ntstatus(req
);
2827 NTSTATUS
cli_unlock(struct cli_state
*cli
,
2832 TALLOC_CTX
*frame
= talloc_stackframe();
2833 struct event_context
*ev
;
2834 struct tevent_req
*req
;
2835 NTSTATUS status
= NT_STATUS_OK
;
2837 if (cli_has_async_calls(cli
)) {
2839 * Can't use sync call while an async call is in flight
2841 status
= NT_STATUS_INVALID_PARAMETER
;
2845 ev
= event_context_init(frame
);
2847 status
= NT_STATUS_NO_MEMORY
;
2851 req
= cli_unlock_send(frame
, ev
, cli
,
2854 status
= NT_STATUS_NO_MEMORY
;
2858 if (!tevent_req_poll(req
, ev
)) {
2859 status
= map_nt_error_from_unix(errno
);
2863 status
= cli_unlock_recv(req
);
2867 if (!NT_STATUS_IS_OK(status
)) {
2868 cli_set_error(cli
, status
);
2873 /****************************************************************************
2874 Lock a file with 64 bit offsets.
2875 ****************************************************************************/
2877 bool cli_lock64(struct cli_state
*cli
, uint16_t fnum
,
2878 uint64_t offset
, uint64_t len
, int timeout
, enum brl_type lock_type
)
2881 int saved_timeout
= cli
->timeout
;
2884 if (! (cli
->capabilities
& CAP_LARGE_FILES
)) {
2885 return cli_lock(cli
, fnum
, offset
, len
, timeout
, lock_type
);
2888 ltype
= (lock_type
== READ_LOCK
? 1 : 0);
2889 ltype
|= LOCKING_ANDX_LARGE_FILES
;
2891 memset(cli
->outbuf
,'\0',smb_size
);
2892 memset(cli
->inbuf
,'\0', smb_size
);
2894 cli_set_message(cli
->outbuf
,8,0,True
);
2896 SCVAL(cli
->outbuf
,smb_com
,SMBlockingX
);
2897 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
2898 cli_setup_packet(cli
);
2900 SCVAL(cli
->outbuf
,smb_vwv0
,0xFF);
2901 SSVAL(cli
->outbuf
,smb_vwv2
,fnum
);
2902 SCVAL(cli
->outbuf
,smb_vwv3
,ltype
);
2903 SIVALS(cli
->outbuf
, smb_vwv4
, timeout
);
2904 SSVAL(cli
->outbuf
,smb_vwv6
,0);
2905 SSVAL(cli
->outbuf
,smb_vwv7
,1);
2907 p
= smb_buf(cli
->outbuf
);
2908 SIVAL(p
, 0, cli
->pid
);
2909 SOFF_T_R(p
, 4, offset
);
2910 SOFF_T_R(p
, 12, len
);
2913 cli_setup_bcc(cli
, p
);
2917 cli
->timeout
= (timeout
== -1) ? 0x7FFFFFFF : (timeout
+ 5*1000);
2920 if (!cli_receive_smb(cli
)) {
2921 cli
->timeout
= saved_timeout
;
2925 cli
->timeout
= saved_timeout
;
2927 if (cli_is_error(cli
)) {
2934 /****************************************************************************
2935 Unlock a file with 64 bit offsets.
2936 ****************************************************************************/
2938 struct cli_unlock64_state
{
2943 static void cli_unlock64_done(struct tevent_req
*subreq
);
2945 struct tevent_req
*cli_unlock64_send(TALLOC_CTX
*mem_ctx
,
2946 struct event_context
*ev
,
2947 struct cli_state
*cli
,
2953 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
2954 struct cli_unlock64_state
*state
= NULL
;
2955 uint8_t additional_flags
= 0;
2957 req
= tevent_req_create(mem_ctx
, &state
, struct cli_unlock64_state
);
2962 SCVAL(state
->vwv
+0, 0, 0xff);
2963 SSVAL(state
->vwv
+2, 0, fnum
);
2964 SCVAL(state
->vwv
+3, 0,LOCKING_ANDX_LARGE_FILES
);
2965 SIVALS(state
->vwv
+4, 0, 0);
2966 SSVAL(state
->vwv
+6, 0, 1);
2967 SSVAL(state
->vwv
+7, 0, 0);
2969 SIVAL(state
->data
, 0, cli
->pid
);
2970 SOFF_T_R(state
->data
, 4, offset
);
2971 SOFF_T_R(state
->data
, 12, len
);
2973 subreq
= cli_smb_send(state
, ev
, cli
, SMBlockingX
, additional_flags
,
2974 8, state
->vwv
, 20, state
->data
);
2975 if (tevent_req_nomem(subreq
, req
)) {
2976 return tevent_req_post(req
, ev
);
2978 tevent_req_set_callback(subreq
, cli_unlock64_done
, req
);
2982 static void cli_unlock64_done(struct tevent_req
*subreq
)
2984 struct tevent_req
*req
= tevent_req_callback_data(
2985 subreq
, struct tevent_req
);
2988 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
2989 TALLOC_FREE(subreq
);
2990 if (!NT_STATUS_IS_OK(status
)) {
2991 tevent_req_nterror(req
, status
);
2994 tevent_req_done(req
);
2997 NTSTATUS
cli_unlock64_recv(struct tevent_req
*req
)
2999 return tevent_req_simple_recv_ntstatus(req
);
3002 NTSTATUS
cli_unlock64(struct cli_state
*cli
,
3007 TALLOC_CTX
*frame
= talloc_stackframe();
3008 struct event_context
*ev
;
3009 struct tevent_req
*req
;
3010 NTSTATUS status
= NT_STATUS_OK
;
3012 if (! (cli
->capabilities
& CAP_LARGE_FILES
)) {
3013 return cli_unlock(cli
, fnum
, offset
, len
);
3016 if (cli_has_async_calls(cli
)) {
3018 * Can't use sync call while an async call is in flight
3020 status
= NT_STATUS_INVALID_PARAMETER
;
3024 ev
= event_context_init(frame
);
3026 status
= NT_STATUS_NO_MEMORY
;
3030 req
= cli_unlock64_send(frame
, ev
, cli
,
3033 status
= NT_STATUS_NO_MEMORY
;
3037 if (!tevent_req_poll(req
, ev
)) {
3038 status
= map_nt_error_from_unix(errno
);
3042 status
= cli_unlock64_recv(req
);
3046 if (!NT_STATUS_IS_OK(status
)) {
3047 cli_set_error(cli
, status
);
3052 /****************************************************************************
3053 Get/unlock a POSIX lock on a file - internal function.
3054 ****************************************************************************/
3056 struct posix_lock_state
{
3059 uint8_t data
[POSIX_LOCK_DATA_SIZE
];
3062 static void cli_posix_unlock_internal_done(struct tevent_req
*subreq
)
3064 struct tevent_req
*req
= tevent_req_callback_data(
3065 subreq
, struct tevent_req
);
3066 struct posix_lock_state
*state
= tevent_req_data(req
, struct posix_lock_state
);
3069 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
3070 TALLOC_FREE(subreq
);
3071 if (!NT_STATUS_IS_OK(status
)) {
3072 tevent_req_nterror(req
, status
);
3075 tevent_req_done(req
);
3078 static struct tevent_req
*cli_posix_lock_internal_send(TALLOC_CTX
*mem_ctx
,
3079 struct event_context
*ev
,
3080 struct cli_state
*cli
,
3085 enum brl_type lock_type
)
3087 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
3088 struct posix_lock_state
*state
= NULL
;
3090 req
= tevent_req_create(mem_ctx
, &state
, struct posix_lock_state
);
3095 /* Setup setup word. */
3096 SSVAL(&state
->setup
, 0, TRANSACT2_SETFILEINFO
);
3098 /* Setup param array. */
3099 SSVAL(&state
->param
, 0, fnum
);
3100 SSVAL(&state
->param
, 2, SMB_SET_POSIX_LOCK
);
3102 /* Setup data array. */
3103 switch (lock_type
) {
3105 SSVAL(&state
->data
, POSIX_LOCK_TYPE_OFFSET
,
3106 POSIX_LOCK_TYPE_READ
);
3109 SSVAL(&state
->data
, POSIX_LOCK_TYPE_OFFSET
,
3110 POSIX_LOCK_TYPE_WRITE
);
3113 SSVAL(&state
->data
, POSIX_LOCK_TYPE_OFFSET
,
3114 POSIX_LOCK_TYPE_UNLOCK
);
3121 SSVAL(&state
->data
, POSIX_LOCK_FLAGS_OFFSET
,
3122 POSIX_LOCK_FLAG_WAIT
);
3124 SSVAL(state
->data
, POSIX_LOCK_FLAGS_OFFSET
,
3125 POSIX_LOCK_FLAG_NOWAIT
);
3128 SIVAL(&state
->data
, POSIX_LOCK_PID_OFFSET
, cli
->pid
);
3129 SOFF_T(&state
->data
, POSIX_LOCK_START_OFFSET
, offset
);
3130 SOFF_T(&state
->data
, POSIX_LOCK_LEN_OFFSET
, len
);
3132 subreq
= cli_trans_send(state
, /* mem ctx. */
3133 ev
, /* event ctx. */
3134 cli
, /* cli_state. */
3135 SMBtrans2
, /* cmd. */
3136 NULL
, /* pipe name. */
3140 &state
->setup
, /* setup. */
3141 1, /* num setup uint16_t words. */
3142 0, /* max returned setup. */
3143 state
->param
, /* param. */
3145 2, /* max returned param. */
3146 state
->data
, /* data. */
3147 POSIX_LOCK_DATA_SIZE
, /* num data. */
3148 0); /* max returned data. */
3150 if (tevent_req_nomem(subreq
, req
)) {
3151 return tevent_req_post(req
, ev
);
3153 tevent_req_set_callback(subreq
, cli_posix_unlock_internal_done
, req
);
3157 /****************************************************************************
3159 ****************************************************************************/
3161 struct tevent_req
*cli_posix_lock_send(TALLOC_CTX
*mem_ctx
,
3162 struct event_context
*ev
,
3163 struct cli_state
*cli
,
3168 enum brl_type lock_type
)
3170 return cli_posix_lock_internal_send(mem_ctx
, ev
, cli
, fnum
, offset
, len
,
3171 wait_lock
, lock_type
);
3174 NTSTATUS
cli_posix_lock_recv(struct tevent_req
*req
)
3178 if (tevent_req_is_nterror(req
, &status
)) {
3181 return NT_STATUS_OK
;
3184 NTSTATUS
cli_posix_lock(struct cli_state
*cli
, uint16_t fnum
,
3185 uint64_t offset
, uint64_t len
,
3186 bool wait_lock
, enum brl_type lock_type
)
3188 TALLOC_CTX
*frame
= talloc_stackframe();
3189 struct event_context
*ev
= NULL
;
3190 struct tevent_req
*req
= NULL
;
3191 NTSTATUS status
= NT_STATUS_OK
;
3193 if (cli_has_async_calls(cli
)) {
3195 * Can't use sync call while an async call is in flight
3197 status
= NT_STATUS_INVALID_PARAMETER
;
3201 if (lock_type
!= READ_LOCK
&& lock_type
!= WRITE_LOCK
) {
3202 status
= NT_STATUS_INVALID_PARAMETER
;
3206 ev
= event_context_init(frame
);
3208 status
= NT_STATUS_NO_MEMORY
;
3212 req
= cli_posix_lock_send(frame
,
3221 status
= NT_STATUS_NO_MEMORY
;
3225 if (!tevent_req_poll(req
, ev
)) {
3226 status
= map_nt_error_from_unix(errno
);
3230 status
= cli_posix_lock_recv(req
);
3234 if (!NT_STATUS_IS_OK(status
)) {
3235 cli_set_error(cli
, status
);
3240 /****************************************************************************
3241 POSIX Unlock a file.
3242 ****************************************************************************/
3244 struct tevent_req
*cli_posix_unlock_send(TALLOC_CTX
*mem_ctx
,
3245 struct event_context
*ev
,
3246 struct cli_state
*cli
,
3251 return cli_posix_lock_internal_send(mem_ctx
, ev
, cli
, fnum
, offset
, len
,
3252 false, UNLOCK_LOCK
);
3255 NTSTATUS
cli_posix_unlock_recv(struct tevent_req
*req
)
3259 if (tevent_req_is_nterror(req
, &status
)) {
3262 return NT_STATUS_OK
;
3265 NTSTATUS
cli_posix_unlock(struct cli_state
*cli
, uint16_t fnum
, uint64_t offset
, uint64_t len
)
3267 TALLOC_CTX
*frame
= talloc_stackframe();
3268 struct event_context
*ev
= NULL
;
3269 struct tevent_req
*req
= NULL
;
3270 NTSTATUS status
= NT_STATUS_OK
;
3272 if (cli_has_async_calls(cli
)) {
3274 * Can't use sync call while an async call is in flight
3276 status
= NT_STATUS_INVALID_PARAMETER
;
3280 ev
= event_context_init(frame
);
3282 status
= NT_STATUS_NO_MEMORY
;
3286 req
= cli_posix_unlock_send(frame
,
3293 status
= NT_STATUS_NO_MEMORY
;
3297 if (!tevent_req_poll(req
, ev
)) {
3298 status
= map_nt_error_from_unix(errno
);
3302 status
= cli_posix_unlock_recv(req
);
3306 if (!NT_STATUS_IS_OK(status
)) {
3307 cli_set_error(cli
, status
);
3312 /****************************************************************************
3313 Do a SMBgetattrE call.
3314 ****************************************************************************/
3316 static void cli_getattrE_done(struct tevent_req
*subreq
);
3318 struct cli_getattrE_state
{
3328 struct tevent_req
*cli_getattrE_send(TALLOC_CTX
*mem_ctx
,
3329 struct event_context
*ev
,
3330 struct cli_state
*cli
,
3333 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
3334 struct cli_getattrE_state
*state
= NULL
;
3335 uint8_t additional_flags
= 0;
3337 req
= tevent_req_create(mem_ctx
, &state
, struct cli_getattrE_state
);
3342 state
->zone_offset
= cli
->serverzone
;
3343 SSVAL(state
->vwv
+0,0,fnum
);
3345 subreq
= cli_smb_send(state
, ev
, cli
, SMBgetattrE
, additional_flags
,
3346 1, state
->vwv
, 0, NULL
);
3347 if (tevent_req_nomem(subreq
, req
)) {
3348 return tevent_req_post(req
, ev
);
3350 tevent_req_set_callback(subreq
, cli_getattrE_done
, req
);
3354 static void cli_getattrE_done(struct tevent_req
*subreq
)
3356 struct tevent_req
*req
= tevent_req_callback_data(
3357 subreq
, struct tevent_req
);
3358 struct cli_getattrE_state
*state
= tevent_req_data(
3359 req
, struct cli_getattrE_state
);
3361 uint16_t *vwv
= NULL
;
3364 status
= cli_smb_recv(subreq
, 11, &wct
, &vwv
, NULL
, NULL
);
3365 if (!NT_STATUS_IS_OK(status
)) {
3366 tevent_req_nterror(req
, status
);
3370 state
->size
= (SMB_OFF_T
)IVAL(vwv
+6,0);
3371 state
->attr
= SVAL(vwv
+10,0);
3372 state
->change_time
= make_unix_date2(vwv
+0, state
->zone_offset
);
3373 state
->access_time
= make_unix_date2(vwv
+2, state
->zone_offset
);
3374 state
->write_time
= make_unix_date2(vwv
+4, state
->zone_offset
);
3376 TALLOC_FREE(subreq
);
3377 tevent_req_done(req
);
3380 NTSTATUS
cli_getattrE_recv(struct tevent_req
*req
,
3383 time_t *change_time
,
3384 time_t *access_time
,
3387 struct cli_getattrE_state
*state
= tevent_req_data(
3388 req
, struct cli_getattrE_state
);
3391 if (tevent_req_is_nterror(req
, &status
)) {
3395 *attr
= state
->attr
;
3398 *size
= state
->size
;
3401 *change_time
= state
->change_time
;
3404 *access_time
= state
->access_time
;
3407 *write_time
= state
->write_time
;
3409 return NT_STATUS_OK
;
3412 NTSTATUS
cli_getattrE(struct cli_state
*cli
,
3416 time_t *change_time
,
3417 time_t *access_time
,
3420 TALLOC_CTX
*frame
= talloc_stackframe();
3421 struct event_context
*ev
= NULL
;
3422 struct tevent_req
*req
= NULL
;
3423 NTSTATUS status
= NT_STATUS_OK
;
3425 if (cli_has_async_calls(cli
)) {
3427 * Can't use sync call while an async call is in flight
3429 status
= NT_STATUS_INVALID_PARAMETER
;
3433 ev
= event_context_init(frame
);
3435 status
= NT_STATUS_NO_MEMORY
;
3439 req
= cli_getattrE_send(frame
, ev
, cli
, fnum
);
3441 status
= NT_STATUS_NO_MEMORY
;
3445 if (!tevent_req_poll(req
, ev
)) {
3446 status
= map_nt_error_from_unix(errno
);
3450 status
= cli_getattrE_recv(req
,
3459 if (!NT_STATUS_IS_OK(status
)) {
3460 cli_set_error(cli
, status
);
3465 /****************************************************************************
3467 ****************************************************************************/
3469 static void cli_getatr_done(struct tevent_req
*subreq
);
3471 struct cli_getatr_state
{
3478 struct tevent_req
*cli_getatr_send(TALLOC_CTX
*mem_ctx
,
3479 struct event_context
*ev
,
3480 struct cli_state
*cli
,
3483 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
3484 struct cli_getatr_state
*state
= NULL
;
3485 uint8_t additional_flags
= 0;
3486 uint8_t *bytes
= NULL
;
3488 req
= tevent_req_create(mem_ctx
, &state
, struct cli_getatr_state
);
3493 state
->zone_offset
= cli
->serverzone
;
3495 bytes
= talloc_array(state
, uint8_t, 1);
3496 if (tevent_req_nomem(bytes
, req
)) {
3497 return tevent_req_post(req
, ev
);
3500 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname
,
3501 strlen(fname
)+1, NULL
);
3503 if (tevent_req_nomem(bytes
, req
)) {
3504 return tevent_req_post(req
, ev
);
3507 subreq
= cli_smb_send(state
, ev
, cli
, SMBgetatr
, additional_flags
,
3508 0, NULL
, talloc_get_size(bytes
), bytes
);
3509 if (tevent_req_nomem(subreq
, req
)) {
3510 return tevent_req_post(req
, ev
);
3512 tevent_req_set_callback(subreq
, cli_getatr_done
, req
);
3516 static void cli_getatr_done(struct tevent_req
*subreq
)
3518 struct tevent_req
*req
= tevent_req_callback_data(
3519 subreq
, struct tevent_req
);
3520 struct cli_getatr_state
*state
= tevent_req_data(
3521 req
, struct cli_getatr_state
);
3523 uint16_t *vwv
= NULL
;
3526 status
= cli_smb_recv(subreq
, 4, &wct
, &vwv
, NULL
, NULL
);
3527 if (!NT_STATUS_IS_OK(status
)) {
3528 tevent_req_nterror(req
, status
);
3532 state
->attr
= SVAL(vwv
+0,0);
3533 state
->size
= (SMB_OFF_T
)IVAL(vwv
+3,0);
3534 state
->write_time
= make_unix_date3(vwv
+1, state
->zone_offset
);
3536 TALLOC_FREE(subreq
);
3537 tevent_req_done(req
);
3540 NTSTATUS
cli_getatr_recv(struct tevent_req
*req
,
3545 struct cli_getatr_state
*state
= tevent_req_data(
3546 req
, struct cli_getatr_state
);
3549 if (tevent_req_is_nterror(req
, &status
)) {
3553 *attr
= state
->attr
;
3556 *size
= state
->size
;
3559 *write_time
= state
->write_time
;
3561 return NT_STATUS_OK
;
3564 NTSTATUS
cli_getatr(struct cli_state
*cli
,
3570 TALLOC_CTX
*frame
= talloc_stackframe();
3571 struct event_context
*ev
= NULL
;
3572 struct tevent_req
*req
= NULL
;
3573 NTSTATUS status
= NT_STATUS_OK
;
3575 if (cli_has_async_calls(cli
)) {
3577 * Can't use sync call while an async call is in flight
3579 status
= NT_STATUS_INVALID_PARAMETER
;
3583 ev
= event_context_init(frame
);
3585 status
= NT_STATUS_NO_MEMORY
;
3589 req
= cli_getatr_send(frame
, ev
, cli
, fname
);
3591 status
= NT_STATUS_NO_MEMORY
;
3595 if (!tevent_req_poll(req
, ev
)) {
3596 status
= map_nt_error_from_unix(errno
);
3600 status
= cli_getatr_recv(req
,
3607 if (!NT_STATUS_IS_OK(status
)) {
3608 cli_set_error(cli
, status
);
3613 /****************************************************************************
3614 Do a SMBsetattrE call.
3615 ****************************************************************************/
3617 static void cli_setattrE_done(struct tevent_req
*subreq
);
3619 struct cli_setattrE_state
{
3623 struct tevent_req
*cli_setattrE_send(TALLOC_CTX
*mem_ctx
,
3624 struct event_context
*ev
,
3625 struct cli_state
*cli
,
3631 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
3632 struct cli_setattrE_state
*state
= NULL
;
3633 uint8_t additional_flags
= 0;
3635 req
= tevent_req_create(mem_ctx
, &state
, struct cli_setattrE_state
);
3640 SSVAL(state
->vwv
+0, 0, fnum
);
3641 cli_put_dos_date2(cli
, (char *)&state
->vwv
[1], 0, change_time
);
3642 cli_put_dos_date2(cli
, (char *)&state
->vwv
[3], 0, access_time
);
3643 cli_put_dos_date2(cli
, (char *)&state
->vwv
[5], 0, write_time
);
3645 subreq
= cli_smb_send(state
, ev
, cli
, SMBsetattrE
, additional_flags
,
3646 7, state
->vwv
, 0, NULL
);
3647 if (tevent_req_nomem(subreq
, req
)) {
3648 return tevent_req_post(req
, ev
);
3650 tevent_req_set_callback(subreq
, cli_setattrE_done
, req
);
3654 static void cli_setattrE_done(struct tevent_req
*subreq
)
3656 struct tevent_req
*req
= tevent_req_callback_data(
3657 subreq
, struct tevent_req
);
3660 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
3661 TALLOC_FREE(subreq
);
3662 if (!NT_STATUS_IS_OK(status
)) {
3663 tevent_req_nterror(req
, status
);
3666 tevent_req_done(req
);
3669 NTSTATUS
cli_setattrE_recv(struct tevent_req
*req
)
3671 return tevent_req_simple_recv_ntstatus(req
);
3674 NTSTATUS
cli_setattrE(struct cli_state
*cli
,
3680 TALLOC_CTX
*frame
= talloc_stackframe();
3681 struct event_context
*ev
= NULL
;
3682 struct tevent_req
*req
= NULL
;
3683 NTSTATUS status
= NT_STATUS_OK
;
3685 if (cli_has_async_calls(cli
)) {
3687 * Can't use sync call while an async call is in flight
3689 status
= NT_STATUS_INVALID_PARAMETER
;
3693 ev
= event_context_init(frame
);
3695 status
= NT_STATUS_NO_MEMORY
;
3699 req
= cli_setattrE_send(frame
, ev
,
3707 status
= NT_STATUS_NO_MEMORY
;
3711 if (!tevent_req_poll(req
, ev
)) {
3712 status
= map_nt_error_from_unix(errno
);
3716 status
= cli_setattrE_recv(req
);
3720 if (!NT_STATUS_IS_OK(status
)) {
3721 cli_set_error(cli
, status
);
3726 /****************************************************************************
3727 Do a SMBsetatr call.
3728 ****************************************************************************/
3730 static void cli_setatr_done(struct tevent_req
*subreq
);
3732 struct cli_setatr_state
{
3736 struct tevent_req
*cli_setatr_send(TALLOC_CTX
*mem_ctx
,
3737 struct event_context
*ev
,
3738 struct cli_state
*cli
,
3743 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
3744 struct cli_setatr_state
*state
= NULL
;
3745 uint8_t additional_flags
= 0;
3746 uint8_t *bytes
= NULL
;
3748 req
= tevent_req_create(mem_ctx
, &state
, struct cli_setatr_state
);
3753 SSVAL(state
->vwv
+0, 0, attr
);
3754 cli_put_dos_date3(cli
, (char *)&state
->vwv
[1], 0, mtime
);
3756 bytes
= talloc_array(state
, uint8_t, 1);
3757 if (tevent_req_nomem(bytes
, req
)) {
3758 return tevent_req_post(req
, ev
);
3761 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname
,
3762 strlen(fname
)+1, NULL
);
3763 if (tevent_req_nomem(bytes
, req
)) {
3764 return tevent_req_post(req
, ev
);
3766 bytes
= TALLOC_REALLOC_ARRAY(state
, bytes
, uint8_t,
3767 talloc_get_size(bytes
)+1);
3768 if (tevent_req_nomem(bytes
, req
)) {
3769 return tevent_req_post(req
, ev
);
3772 bytes
[talloc_get_size(bytes
)-1] = 4;
3773 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), "",
3775 if (tevent_req_nomem(bytes
, req
)) {
3776 return tevent_req_post(req
, ev
);
3779 subreq
= cli_smb_send(state
, ev
, cli
, SMBsetatr
, additional_flags
,
3780 8, state
->vwv
, talloc_get_size(bytes
), bytes
);
3781 if (tevent_req_nomem(subreq
, req
)) {
3782 return tevent_req_post(req
, ev
);
3784 tevent_req_set_callback(subreq
, cli_setatr_done
, req
);
3788 static void cli_setatr_done(struct tevent_req
*subreq
)
3790 struct tevent_req
*req
= tevent_req_callback_data(
3791 subreq
, struct tevent_req
);
3794 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
3795 TALLOC_FREE(subreq
);
3796 if (!NT_STATUS_IS_OK(status
)) {
3797 tevent_req_nterror(req
, status
);
3800 tevent_req_done(req
);
3803 NTSTATUS
cli_setatr_recv(struct tevent_req
*req
)
3805 return tevent_req_simple_recv_ntstatus(req
);
3808 NTSTATUS
cli_setatr(struct cli_state
*cli
,
3813 TALLOC_CTX
*frame
= talloc_stackframe();
3814 struct event_context
*ev
= NULL
;
3815 struct tevent_req
*req
= NULL
;
3816 NTSTATUS status
= NT_STATUS_OK
;
3818 if (cli_has_async_calls(cli
)) {
3820 * Can't use sync call while an async call is in flight
3822 status
= NT_STATUS_INVALID_PARAMETER
;
3826 ev
= event_context_init(frame
);
3828 status
= NT_STATUS_NO_MEMORY
;
3832 req
= cli_setatr_send(frame
, ev
, cli
, fname
, attr
, mtime
);
3834 status
= NT_STATUS_NO_MEMORY
;
3838 if (!tevent_req_poll(req
, ev
)) {
3839 status
= map_nt_error_from_unix(errno
);
3843 status
= cli_setatr_recv(req
);
3847 if (!NT_STATUS_IS_OK(status
)) {
3848 cli_set_error(cli
, status
);
3853 /****************************************************************************
3854 Check for existance of a dir.
3855 ****************************************************************************/
3857 static void cli_chkpath_done(struct tevent_req
*subreq
);
3859 struct cli_chkpath_state
{
3863 struct tevent_req
*cli_chkpath_send(TALLOC_CTX
*mem_ctx
,
3864 struct event_context
*ev
,
3865 struct cli_state
*cli
,
3868 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
3869 struct cli_chkpath_state
*state
= NULL
;
3870 uint8_t additional_flags
= 0;
3871 uint8_t *bytes
= NULL
;
3873 req
= tevent_req_create(mem_ctx
, &state
, struct cli_chkpath_state
);
3878 bytes
= talloc_array(state
, uint8_t, 1);
3879 if (tevent_req_nomem(bytes
, req
)) {
3880 return tevent_req_post(req
, ev
);
3883 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), fname
,
3884 strlen(fname
)+1, NULL
);
3886 if (tevent_req_nomem(bytes
, req
)) {
3887 return tevent_req_post(req
, ev
);
3890 subreq
= cli_smb_send(state
, ev
, cli
, SMBcheckpath
, additional_flags
,
3891 0, NULL
, talloc_get_size(bytes
), bytes
);
3892 if (tevent_req_nomem(subreq
, req
)) {
3893 return tevent_req_post(req
, ev
);
3895 tevent_req_set_callback(subreq
, cli_chkpath_done
, req
);
3899 static void cli_chkpath_done(struct tevent_req
*subreq
)
3901 struct tevent_req
*req
= tevent_req_callback_data(
3902 subreq
, struct tevent_req
);
3905 status
= cli_smb_recv(subreq
, 0, NULL
, NULL
, NULL
, NULL
);
3906 TALLOC_FREE(subreq
);
3907 if (!NT_STATUS_IS_OK(status
)) {
3908 tevent_req_nterror(req
, status
);
3911 tevent_req_done(req
);
3914 NTSTATUS
cli_chkpath_recv(struct tevent_req
*req
)
3916 return tevent_req_simple_recv_ntstatus(req
);
3919 NTSTATUS
cli_chkpath(struct cli_state
*cli
, const char *path
)
3921 TALLOC_CTX
*frame
= talloc_stackframe();
3922 struct event_context
*ev
= NULL
;
3923 struct tevent_req
*req
= NULL
;
3925 NTSTATUS status
= NT_STATUS_OK
;
3927 if (cli_has_async_calls(cli
)) {
3929 * Can't use sync call while an async call is in flight
3931 status
= NT_STATUS_INVALID_PARAMETER
;
3935 path2
= talloc_strdup(frame
, path
);
3937 status
= NT_STATUS_NO_MEMORY
;
3940 trim_char(path2
,'\0','\\');
3942 path2
= talloc_strdup(frame
, "\\");
3944 status
= NT_STATUS_NO_MEMORY
;
3949 ev
= event_context_init(frame
);
3951 status
= NT_STATUS_NO_MEMORY
;
3955 req
= cli_chkpath_send(frame
, ev
, cli
, path2
);
3957 status
= NT_STATUS_NO_MEMORY
;
3961 if (!tevent_req_poll(req
, ev
)) {
3962 status
= map_nt_error_from_unix(errno
);
3966 status
= cli_chkpath_recv(req
);
3970 if (!NT_STATUS_IS_OK(status
)) {
3971 cli_set_error(cli
, status
);
3976 /****************************************************************************
3978 ****************************************************************************/
3980 static void cli_dskattr_done(struct tevent_req
*subreq
);
3982 struct cli_dskattr_state
{
3988 struct tevent_req
*cli_dskattr_send(TALLOC_CTX
*mem_ctx
,
3989 struct event_context
*ev
,
3990 struct cli_state
*cli
)
3992 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
3993 struct cli_dskattr_state
*state
= NULL
;
3994 uint8_t additional_flags
= 0;
3996 req
= tevent_req_create(mem_ctx
, &state
, struct cli_dskattr_state
);
4001 subreq
= cli_smb_send(state
, ev
, cli
, SMBdskattr
, additional_flags
,
4003 if (tevent_req_nomem(subreq
, req
)) {
4004 return tevent_req_post(req
, ev
);
4006 tevent_req_set_callback(subreq
, cli_dskattr_done
, req
);
4010 static void cli_dskattr_done(struct tevent_req
*subreq
)
4012 struct tevent_req
*req
= tevent_req_callback_data(
4013 subreq
, struct tevent_req
);
4014 struct cli_dskattr_state
*state
= tevent_req_data(
4015 req
, struct cli_dskattr_state
);
4017 uint16_t *vwv
= NULL
;
4020 status
= cli_smb_recv(subreq
, 4, &wct
, &vwv
, NULL
, NULL
);
4021 if (!NT_STATUS_IS_OK(status
)) {
4022 tevent_req_nterror(req
, status
);
4025 state
->bsize
= SVAL(vwv
+1, 0)*SVAL(vwv
+2,0);
4026 state
->total
= SVAL(vwv
+0, 0);
4027 state
->avail
= SVAL(vwv
+3, 0);
4028 TALLOC_FREE(subreq
);
4029 tevent_req_done(req
);
4032 NTSTATUS
cli_dskattr_recv(struct tevent_req
*req
, int *bsize
, int *total
, int *avail
)
4034 struct cli_dskattr_state
*state
= tevent_req_data(
4035 req
, struct cli_dskattr_state
);
4038 if (tevent_req_is_nterror(req
, &status
)) {
4041 *bsize
= state
->bsize
;
4042 *total
= state
->total
;
4043 *avail
= state
->avail
;
4044 return NT_STATUS_OK
;
4047 NTSTATUS
cli_dskattr(struct cli_state
*cli
, int *bsize
, int *total
, int *avail
)
4049 TALLOC_CTX
*frame
= talloc_stackframe();
4050 struct event_context
*ev
= NULL
;
4051 struct tevent_req
*req
= NULL
;
4052 NTSTATUS status
= NT_STATUS_OK
;
4054 if (cli_has_async_calls(cli
)) {
4056 * Can't use sync call while an async call is in flight
4058 status
= NT_STATUS_INVALID_PARAMETER
;
4062 ev
= event_context_init(frame
);
4064 status
= NT_STATUS_NO_MEMORY
;
4068 req
= cli_dskattr_send(frame
, ev
, cli
);
4070 status
= NT_STATUS_NO_MEMORY
;
4074 if (!tevent_req_poll(req
, ev
)) {
4075 status
= map_nt_error_from_unix(errno
);
4079 status
= cli_dskattr_recv(req
, bsize
, total
, avail
);
4083 if (!NT_STATUS_IS_OK(status
)) {
4084 cli_set_error(cli
, status
);
4089 /****************************************************************************
4090 Create and open a temporary file.
4091 ****************************************************************************/
4093 static void cli_ctemp_done(struct tevent_req
*subreq
);
4095 struct ctemp_state
{
4101 struct tevent_req
*cli_ctemp_send(TALLOC_CTX
*mem_ctx
,
4102 struct event_context
*ev
,
4103 struct cli_state
*cli
,
4106 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
4107 struct ctemp_state
*state
= NULL
;
4108 uint8_t additional_flags
= 0;
4109 uint8_t *bytes
= NULL
;
4111 req
= tevent_req_create(mem_ctx
, &state
, struct ctemp_state
);
4116 SSVAL(state
->vwv
,0,0);
4117 SIVALS(state
->vwv
+1,0,-1);
4119 bytes
= talloc_array(state
, uint8_t, 1);
4120 if (tevent_req_nomem(bytes
, req
)) {
4121 return tevent_req_post(req
, ev
);
4124 bytes
= smb_bytes_push_str(bytes
, cli_ucs2(cli
), path
,
4125 strlen(path
)+1, NULL
);
4126 if (tevent_req_nomem(bytes
, req
)) {
4127 return tevent_req_post(req
, ev
);
4130 subreq
= cli_smb_send(state
, ev
, cli
, SMBctemp
, additional_flags
,
4131 3, state
->vwv
, talloc_get_size(bytes
), bytes
);
4132 if (tevent_req_nomem(subreq
, req
)) {
4133 return tevent_req_post(req
, ev
);
4135 tevent_req_set_callback(subreq
, cli_ctemp_done
, req
);
4139 static void cli_ctemp_done(struct tevent_req
*subreq
)
4141 struct tevent_req
*req
= tevent_req_callback_data(
4142 subreq
, struct tevent_req
);
4143 struct ctemp_state
*state
= tevent_req_data(
4144 req
, struct ctemp_state
);
4148 uint32_t num_bytes
= 0;
4149 uint8_t *bytes
= NULL
;
4151 status
= cli_smb_recv(subreq
, 1, &wcnt
, &vwv
, &num_bytes
, &bytes
);
4152 if (!NT_STATUS_IS_OK(status
)) {
4153 TALLOC_FREE(subreq
);
4154 tevent_req_nterror(req
, status
);
4158 state
->fnum
= SVAL(vwv
+0, 0);
4160 TALLOC_FREE(subreq
);
4162 /* From W2K3, the result is just the ASCII name */
4163 if (num_bytes
< 2) {
4164 tevent_req_nterror(req
, NT_STATUS_DATA_ERROR
);
4168 if (pull_string_talloc(state
,
4175 tevent_req_nterror(req
, NT_STATUS_NO_MEMORY
);
4178 tevent_req_done(req
);
4181 NTSTATUS
cli_ctemp_recv(struct tevent_req
*req
,
4186 struct ctemp_state
*state
= tevent_req_data(req
,
4187 struct ctemp_state
);
4190 if (tevent_req_is_nterror(req
, &status
)) {
4193 *pfnum
= state
->fnum
;
4194 *outfile
= talloc_strdup(ctx
, state
->ret_path
);
4196 return NT_STATUS_NO_MEMORY
;
4198 return NT_STATUS_OK
;
4201 NTSTATUS
cli_ctemp(struct cli_state
*cli
,
4207 TALLOC_CTX
*frame
= talloc_stackframe();
4208 struct event_context
*ev
;
4209 struct tevent_req
*req
;
4210 NTSTATUS status
= NT_STATUS_OK
;
4212 if (cli_has_async_calls(cli
)) {
4214 * Can't use sync call while an async call is in flight
4216 status
= NT_STATUS_INVALID_PARAMETER
;
4220 ev
= event_context_init(frame
);
4222 status
= NT_STATUS_NO_MEMORY
;
4226 req
= cli_ctemp_send(frame
, ev
, cli
, path
);
4228 status
= NT_STATUS_NO_MEMORY
;
4232 if (!tevent_req_poll(req
, ev
)) {
4233 status
= map_nt_error_from_unix(errno
);
4237 status
= cli_ctemp_recv(req
, ctx
, pfnum
, out_path
);
4241 if (!NT_STATUS_IS_OK(status
)) {
4242 cli_set_error(cli
, status
);
4248 send a raw ioctl - used by the torture code
4250 NTSTATUS
cli_raw_ioctl(struct cli_state
*cli
, uint16_t fnum
, uint32_t code
, DATA_BLOB
*blob
)
4252 memset(cli
->outbuf
,'\0',smb_size
);
4253 memset(cli
->inbuf
,'\0',smb_size
);
4255 cli_set_message(cli
->outbuf
, 3, 0, True
);
4256 SCVAL(cli
->outbuf
,smb_com
,SMBioctl
);
4257 cli_setup_packet(cli
);
4259 SSVAL(cli
->outbuf
, smb_vwv0
, fnum
);
4260 SSVAL(cli
->outbuf
, smb_vwv1
, code
>>16);
4261 SSVAL(cli
->outbuf
, smb_vwv2
, (code
&0xFFFF));
4264 if (!cli_receive_smb(cli
)) {
4265 return NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
4268 if (cli_is_error(cli
)) {
4269 return cli_nt_error(cli
);
4272 *blob
= data_blob_null
;
4274 return NT_STATUS_OK
;
4277 /*********************************************************
4278 Set an extended attribute utility fn.
4279 *********************************************************/
4281 static bool cli_set_ea(struct cli_state
*cli
, uint16_t setup
, char *param
, unsigned int param_len
,
4282 const char *ea_name
, const char *ea_val
, size_t ea_len
)
4284 unsigned int data_len
= 0;
4286 char *rparam
=NULL
, *rdata
=NULL
;
4288 size_t ea_namelen
= strlen(ea_name
);
4290 if (ea_namelen
== 0 && ea_len
== 0) {
4292 data
= (char *)SMB_MALLOC(data_len
);
4297 SIVAL(p
,0,data_len
);
4299 data_len
= 4 + 4 + ea_namelen
+ 1 + ea_len
;
4300 data
= (char *)SMB_MALLOC(data_len
);
4305 SIVAL(p
,0,data_len
);
4307 SCVAL(p
, 0, 0); /* EA flags. */
4308 SCVAL(p
, 1, ea_namelen
);
4309 SSVAL(p
, 2, ea_len
);
4310 memcpy(p
+4, ea_name
, ea_namelen
+1); /* Copy in the name. */
4311 memcpy(p
+4+ea_namelen
+1, ea_val
, ea_len
);
4314 if (!cli_send_trans(cli
, SMBtrans2
,
4316 -1, 0, /* fid, flags */
4317 &setup
, 1, 0, /* setup, length, max */
4318 param
, param_len
, 2, /* param, length, max */
4319 data
, data_len
, cli
->max_xmit
/* data, length, max */
4325 if (!cli_receive_trans(cli
, SMBtrans2
,
4326 &rparam
, ¶m_len
,
4327 &rdata
, &data_len
)) {
4339 /*********************************************************
4340 Set an extended attribute on a pathname.
4341 *********************************************************/
4343 bool cli_set_ea_path(struct cli_state
*cli
, const char *path
, const char *ea_name
, const char *ea_val
, size_t ea_len
)
4345 uint16_t setup
= TRANSACT2_SETPATHINFO
;
4346 unsigned int param_len
= 0;
4348 size_t srclen
= 2*(strlen(path
)+1);
4352 param
= SMB_MALLOC_ARRAY(char, 6+srclen
+2);
4356 memset(param
, '\0', 6);
4357 SSVAL(param
,0,SMB_INFO_SET_EA
);
4360 p
+= clistr_push(cli
, p
, path
, srclen
, STR_TERMINATE
);
4361 param_len
= PTR_DIFF(p
, param
);
4363 ret
= cli_set_ea(cli
, setup
, param
, param_len
, ea_name
, ea_val
, ea_len
);
4368 /*********************************************************
4369 Set an extended attribute on an fnum.
4370 *********************************************************/
4372 bool cli_set_ea_fnum(struct cli_state
*cli
, uint16_t fnum
, const char *ea_name
, const char *ea_val
, size_t ea_len
)
4375 uint16_t setup
= TRANSACT2_SETFILEINFO
;
4377 memset(param
, 0, 6);
4378 SSVAL(param
,0,fnum
);
4379 SSVAL(param
,2,SMB_INFO_SET_EA
);
4381 return cli_set_ea(cli
, setup
, param
, 6, ea_name
, ea_val
, ea_len
);
4384 /*********************************************************
4385 Get an extended attribute list utility fn.
4386 *********************************************************/
4388 static bool cli_get_ea_list(struct cli_state
*cli
,
4389 uint16_t setup
, char *param
, unsigned int param_len
,
4392 struct ea_struct
**pea_list
)
4394 unsigned int data_len
= 0;
4395 unsigned int rparam_len
, rdata_len
;
4396 char *rparam
=NULL
, *rdata
=NULL
;
4401 struct ea_struct
*ea_list
;
4408 if (!cli_send_trans(cli
, SMBtrans2
,
4410 -1, 0, /* fid, flags */
4411 &setup
, 1, 0, /* setup, length, max */
4412 param
, param_len
, 10, /* param, length, max */
4413 NULL
, data_len
, cli
->max_xmit
/* data, length, max */
4418 if (!cli_receive_trans(cli
, SMBtrans2
,
4419 &rparam
, &rparam_len
,
4420 &rdata
, &rdata_len
)) {
4424 if (!rdata
|| rdata_len
< 4) {
4428 ea_size
= (size_t)IVAL(rdata
,0);
4429 if (ea_size
> rdata_len
) {
4434 /* No EA's present. */
4442 /* Validate the EA list and count it. */
4443 for (num_eas
= 0; ea_size
>= 4; num_eas
++) {
4444 unsigned int ea_namelen
= CVAL(p
,1);
4445 unsigned int ea_valuelen
= SVAL(p
,2);
4446 if (ea_namelen
== 0) {
4449 if (4 + ea_namelen
+ 1 + ea_valuelen
> ea_size
) {
4452 ea_size
-= 4 + ea_namelen
+ 1 + ea_valuelen
;
4453 p
+= 4 + ea_namelen
+ 1 + ea_valuelen
;
4461 *pnum_eas
= num_eas
;
4463 /* Caller only wants number of EA's. */
4468 ea_list
= TALLOC_ARRAY(ctx
, struct ea_struct
, num_eas
);
4473 ea_size
= (size_t)IVAL(rdata
,0);
4476 for (num_eas
= 0; num_eas
< *pnum_eas
; num_eas
++ ) {
4477 struct ea_struct
*ea
= &ea_list
[num_eas
];
4478 fstring unix_ea_name
;
4479 unsigned int ea_namelen
= CVAL(p
,1);
4480 unsigned int ea_valuelen
= SVAL(p
,2);
4482 ea
->flags
= CVAL(p
,0);
4483 unix_ea_name
[0] = '\0';
4484 pull_ascii_fstring(unix_ea_name
, p
+ 4);
4485 ea
->name
= talloc_strdup(ctx
, unix_ea_name
);
4486 /* Ensure the value is null terminated (in case it's a string). */
4487 ea
->value
= data_blob_talloc(ctx
, NULL
, ea_valuelen
+ 1);
4488 if (!ea
->value
.data
) {
4492 memcpy(ea
->value
.data
, p
+4+ea_namelen
+1, ea_valuelen
);
4494 ea
->value
.data
[ea_valuelen
] = 0;
4496 p
+= 4 + ea_namelen
+ 1 + ea_valuelen
;
4499 *pea_list
= ea_list
;
4509 /*********************************************************
4510 Get an extended attribute list from a pathname.
4511 *********************************************************/
4513 bool cli_get_ea_list_path(struct cli_state
*cli
, const char *path
,
4516 struct ea_struct
**pea_list
)
4518 uint16_t setup
= TRANSACT2_QPATHINFO
;
4519 unsigned int param_len
= 0;
4522 size_t srclen
= 2*(strlen(path
)+1);
4525 param
= SMB_MALLOC_ARRAY(char, 6+srclen
+2);
4531 SSVAL(p
, 0, SMB_INFO_QUERY_ALL_EAS
);
4533 p
+= clistr_push(cli
, p
, path
, srclen
, STR_TERMINATE
);
4534 param_len
= PTR_DIFF(p
, param
);
4536 ret
= cli_get_ea_list(cli
, setup
, param
, param_len
, ctx
, pnum_eas
, pea_list
);
4541 /*********************************************************
4542 Get an extended attribute list from an fnum.
4543 *********************************************************/
4545 bool cli_get_ea_list_fnum(struct cli_state
*cli
, uint16_t fnum
,
4548 struct ea_struct
**pea_list
)
4550 uint16_t setup
= TRANSACT2_QFILEINFO
;
4553 memset(param
, 0, 6);
4554 SSVAL(param
,0,fnum
);
4555 SSVAL(param
,2,SMB_INFO_SET_EA
);
4557 return cli_get_ea_list(cli
, setup
, param
, 6, ctx
, pnum_eas
, pea_list
);
4560 /****************************************************************************
4561 Convert open "flags" arg to uint32_t on wire.
4562 ****************************************************************************/
4564 static uint32_t open_flags_to_wire(int flags
)
4566 int open_mode
= flags
& O_ACCMODE
;
4569 switch (open_mode
) {
4571 ret
|= SMB_O_WRONLY
;
4578 ret
|= SMB_O_RDONLY
;
4582 if (flags
& O_CREAT
) {
4585 if (flags
& O_EXCL
) {
4588 if (flags
& O_TRUNC
) {
4592 if (flags
& O_SYNC
) {
4596 if (flags
& O_APPEND
) {
4597 ret
|= SMB_O_APPEND
;
4599 #if defined(O_DIRECT)
4600 if (flags
& O_DIRECT
) {
4601 ret
|= SMB_O_DIRECT
;
4604 #if defined(O_DIRECTORY)
4605 if (flags
& O_DIRECTORY
) {
4606 ret
&= ~(SMB_O_RDONLY
|SMB_O_RDWR
|SMB_O_WRONLY
);
4607 ret
|= SMB_O_DIRECTORY
;
4613 /****************************************************************************
4614 Open a file - POSIX semantics. Returns fnum. Doesn't request oplock.
4615 ****************************************************************************/
4617 struct posix_open_state
{
4621 uint16_t fnum
; /* Out */
4624 static void cli_posix_open_internal_done(struct tevent_req
*subreq
)
4626 struct tevent_req
*req
= tevent_req_callback_data(
4627 subreq
, struct tevent_req
);
4628 struct posix_open_state
*state
= tevent_req_data(req
, struct posix_open_state
);
4633 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
, &data
, &num_data
);
4634 TALLOC_FREE(subreq
);
4635 if (!NT_STATUS_IS_OK(status
)) {
4636 tevent_req_nterror(req
, status
);
4639 if (num_data
< 12) {
4640 tevent_req_nterror(req
, status
);
4643 state
->fnum
= SVAL(data
,2);
4644 tevent_req_done(req
);
4647 static struct tevent_req
*cli_posix_open_internal_send(TALLOC_CTX
*mem_ctx
,
4648 struct event_context
*ev
,
4649 struct cli_state
*cli
,
4655 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
4656 struct posix_open_state
*state
= NULL
;
4657 uint32_t wire_flags
= open_flags_to_wire(flags
);
4659 req
= tevent_req_create(mem_ctx
, &state
, struct posix_open_state
);
4664 /* Setup setup word. */
4665 SSVAL(&state
->setup
, 0, TRANSACT2_SETPATHINFO
);
4667 /* Setup param array. */
4668 state
->param
= talloc_array(state
, uint8_t, 6);
4669 if (tevent_req_nomem(state
->param
, req
)) {
4670 return tevent_req_post(req
, ev
);
4672 memset(state
->param
, '\0', 6);
4673 SSVAL(state
->param
, 0, SMB_POSIX_PATH_OPEN
);
4675 state
->param
= trans2_bytes_push_str(state
->param
, cli_ucs2(cli
), fname
,
4676 strlen(fname
)+1, NULL
);
4678 if (tevent_req_nomem(state
->param
, req
)) {
4679 return tevent_req_post(req
, ev
);
4682 /* Setup data words. */
4684 wire_flags
&= ~(SMB_O_RDONLY
|SMB_O_RDWR
|SMB_O_WRONLY
);
4685 wire_flags
|= SMB_O_DIRECTORY
;
4688 SIVAL(state
->data
,0,0); /* No oplock. */
4689 SIVAL(state
->data
,4,wire_flags
);
4690 SIVAL(state
->data
,8,unix_perms_to_wire(mode
));
4691 SIVAL(state
->data
,12,0); /* Top bits of perms currently undefined. */
4692 SSVAL(state
->data
,16,SMB_NO_INFO_LEVEL_RETURNED
); /* No info level returned. */
4694 subreq
= cli_trans_send(state
, /* mem ctx. */
4695 ev
, /* event ctx. */
4696 cli
, /* cli_state. */
4697 SMBtrans2
, /* cmd. */
4698 NULL
, /* pipe name. */
4702 &state
->setup
, /* setup. */
4703 1, /* num setup uint16_t words. */
4704 0, /* max returned setup. */
4705 state
->param
, /* param. */
4706 talloc_get_size(state
->param
),/* num param. */
4707 2, /* max returned param. */
4708 state
->data
, /* data. */
4710 12); /* max returned data. */
4712 if (tevent_req_nomem(subreq
, req
)) {
4713 return tevent_req_post(req
, ev
);
4715 tevent_req_set_callback(subreq
, cli_posix_open_internal_done
, req
);
4719 struct tevent_req
*cli_posix_open_send(TALLOC_CTX
*mem_ctx
,
4720 struct event_context
*ev
,
4721 struct cli_state
*cli
,
4726 return cli_posix_open_internal_send(mem_ctx
, ev
,
4727 cli
, fname
, flags
, mode
, false);
4730 NTSTATUS
cli_posix_open_recv(struct tevent_req
*req
, uint16_t *pfnum
)
4732 struct posix_open_state
*state
= tevent_req_data(req
, struct posix_open_state
);
4735 if (tevent_req_is_nterror(req
, &status
)) {
4738 *pfnum
= state
->fnum
;
4739 return NT_STATUS_OK
;
4742 /****************************************************************************
4743 Open - POSIX semantics. Doesn't request oplock.
4744 ****************************************************************************/
4746 NTSTATUS
cli_posix_open(struct cli_state
*cli
, const char *fname
,
4747 int flags
, mode_t mode
, uint16_t *pfnum
)
4750 TALLOC_CTX
*frame
= talloc_stackframe();
4751 struct event_context
*ev
= NULL
;
4752 struct tevent_req
*req
= NULL
;
4753 NTSTATUS status
= NT_STATUS_OK
;
4755 if (cli_has_async_calls(cli
)) {
4757 * Can't use sync call while an async call is in flight
4759 status
= NT_STATUS_INVALID_PARAMETER
;
4763 ev
= event_context_init(frame
);
4765 status
= NT_STATUS_NO_MEMORY
;
4769 req
= cli_posix_open_send(frame
,
4776 status
= NT_STATUS_NO_MEMORY
;
4780 if (!tevent_req_poll(req
, ev
)) {
4781 status
= map_nt_error_from_unix(errno
);
4785 status
= cli_posix_open_recv(req
, pfnum
);
4789 if (!NT_STATUS_IS_OK(status
)) {
4790 cli_set_error(cli
, status
);
4795 struct tevent_req
*cli_posix_mkdir_send(TALLOC_CTX
*mem_ctx
,
4796 struct event_context
*ev
,
4797 struct cli_state
*cli
,
4801 return cli_posix_open_internal_send(mem_ctx
, ev
,
4802 cli
, fname
, O_CREAT
, mode
, true);
4805 NTSTATUS
cli_posix_mkdir_recv(struct tevent_req
*req
)
4809 if (tevent_req_is_nterror(req
, &status
)) {
4812 return NT_STATUS_OK
;
4815 NTSTATUS
cli_posix_mkdir(struct cli_state
*cli
, const char *fname
, mode_t mode
)
4817 TALLOC_CTX
*frame
= talloc_stackframe();
4818 struct event_context
*ev
= NULL
;
4819 struct tevent_req
*req
= NULL
;
4820 NTSTATUS status
= NT_STATUS_OK
;
4822 if (cli_has_async_calls(cli
)) {
4824 * Can't use sync call while an async call is in flight
4826 status
= NT_STATUS_INVALID_PARAMETER
;
4830 ev
= event_context_init(frame
);
4832 status
= NT_STATUS_NO_MEMORY
;
4836 req
= cli_posix_mkdir_send(frame
,
4842 status
= NT_STATUS_NO_MEMORY
;
4846 if (!tevent_req_poll(req
, ev
)) {
4847 status
= map_nt_error_from_unix(errno
);
4851 status
= cli_posix_mkdir_recv(req
);
4855 if (!NT_STATUS_IS_OK(status
)) {
4856 cli_set_error(cli
, status
);
4861 /****************************************************************************
4862 unlink or rmdir - POSIX semantics.
4863 ****************************************************************************/
4865 struct unlink_state
{
4870 static void cli_posix_unlink_internal_done(struct tevent_req
*subreq
)
4872 struct tevent_req
*req
= tevent_req_callback_data(
4873 subreq
, struct tevent_req
);
4874 struct unlink_state
*state
= tevent_req_data(req
, struct unlink_state
);
4877 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
4878 TALLOC_FREE(subreq
);
4879 if (!NT_STATUS_IS_OK(status
)) {
4880 tevent_req_nterror(req
, status
);
4883 tevent_req_done(req
);
4886 static struct tevent_req
*cli_posix_unlink_internal_send(TALLOC_CTX
*mem_ctx
,
4887 struct event_context
*ev
,
4888 struct cli_state
*cli
,
4892 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
4893 struct unlink_state
*state
= NULL
;
4894 uint8_t *param
= NULL
;
4896 req
= tevent_req_create(mem_ctx
, &state
, struct unlink_state
);
4901 /* Setup setup word. */
4902 SSVAL(&state
->setup
, 0, TRANSACT2_SETPATHINFO
);
4904 /* Setup param array. */
4905 param
= talloc_array(state
, uint8_t, 6);
4906 if (tevent_req_nomem(param
, req
)) {
4907 return tevent_req_post(req
, ev
);
4909 memset(param
, '\0', 6);
4910 SSVAL(param
, 0, SMB_POSIX_PATH_UNLINK
);
4912 param
= trans2_bytes_push_str(param
, cli_ucs2(cli
), fname
,
4913 strlen(fname
)+1, NULL
);
4915 if (tevent_req_nomem(param
, req
)) {
4916 return tevent_req_post(req
, ev
);
4919 /* Setup data word. */
4920 SSVAL(state
->data
, 0, is_dir
? SMB_POSIX_UNLINK_DIRECTORY_TARGET
:
4921 SMB_POSIX_UNLINK_FILE_TARGET
);
4923 subreq
= cli_trans_send(state
, /* mem ctx. */
4924 ev
, /* event ctx. */
4925 cli
, /* cli_state. */
4926 SMBtrans2
, /* cmd. */
4927 NULL
, /* pipe name. */
4931 &state
->setup
, /* setup. */
4932 1, /* num setup uint16_t words. */
4933 0, /* max returned setup. */
4935 talloc_get_size(param
), /* num param. */
4936 2, /* max returned param. */
4937 state
->data
, /* data. */
4939 0); /* max returned data. */
4941 if (tevent_req_nomem(subreq
, req
)) {
4942 return tevent_req_post(req
, ev
);
4944 tevent_req_set_callback(subreq
, cli_posix_unlink_internal_done
, req
);
4948 struct tevent_req
*cli_posix_unlink_send(TALLOC_CTX
*mem_ctx
,
4949 struct event_context
*ev
,
4950 struct cli_state
*cli
,
4953 return cli_posix_unlink_internal_send(mem_ctx
, ev
, cli
, fname
, false);
4956 NTSTATUS
cli_posix_unlink_recv(struct tevent_req
*req
)
4960 if (tevent_req_is_nterror(req
, &status
)) {
4963 return NT_STATUS_OK
;
4966 /****************************************************************************
4967 unlink - POSIX semantics.
4968 ****************************************************************************/
4970 NTSTATUS
cli_posix_unlink(struct cli_state
*cli
, const char *fname
)
4972 TALLOC_CTX
*frame
= talloc_stackframe();
4973 struct event_context
*ev
= NULL
;
4974 struct tevent_req
*req
= NULL
;
4975 NTSTATUS status
= NT_STATUS_OK
;
4977 if (cli_has_async_calls(cli
)) {
4979 * Can't use sync call while an async call is in flight
4981 status
= NT_STATUS_INVALID_PARAMETER
;
4985 ev
= event_context_init(frame
);
4987 status
= NT_STATUS_NO_MEMORY
;
4991 req
= cli_posix_unlink_send(frame
,
4996 status
= NT_STATUS_NO_MEMORY
;
5000 if (!tevent_req_poll(req
, ev
)) {
5001 status
= map_nt_error_from_unix(errno
);
5005 status
= cli_posix_unlink_recv(req
);
5009 if (!NT_STATUS_IS_OK(status
)) {
5010 cli_set_error(cli
, status
);
5015 /****************************************************************************
5016 rmdir - POSIX semantics.
5017 ****************************************************************************/
5019 struct tevent_req
*cli_posix_rmdir_send(TALLOC_CTX
*mem_ctx
,
5020 struct event_context
*ev
,
5021 struct cli_state
*cli
,
5024 return cli_posix_unlink_internal_send(mem_ctx
, ev
, cli
, fname
, true);
5027 NTSTATUS
cli_posix_rmdir_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
)
5031 if (tevent_req_is_nterror(req
, &status
)) {
5034 return NT_STATUS_OK
;
5037 NTSTATUS
cli_posix_rmdir(struct cli_state
*cli
, const char *fname
)
5039 TALLOC_CTX
*frame
= talloc_stackframe();
5040 struct event_context
*ev
= NULL
;
5041 struct tevent_req
*req
= NULL
;
5042 NTSTATUS status
= NT_STATUS_OK
;
5044 if (cli_has_async_calls(cli
)) {
5046 * Can't use sync call while an async call is in flight
5048 status
= NT_STATUS_INVALID_PARAMETER
;
5052 ev
= event_context_init(frame
);
5054 status
= NT_STATUS_NO_MEMORY
;
5058 req
= cli_posix_rmdir_send(frame
,
5063 status
= NT_STATUS_NO_MEMORY
;
5067 if (!tevent_req_poll(req
, ev
)) {
5068 status
= map_nt_error_from_unix(errno
);
5072 status
= cli_posix_rmdir_recv(req
, frame
);
5076 if (!NT_STATUS_IS_OK(status
)) {
5077 cli_set_error(cli
, status
);
5082 /****************************************************************************
5084 ****************************************************************************/
5086 struct cli_notify_state
{
5088 uint32_t num_changes
;
5089 struct notify_change
*changes
;
5092 static void cli_notify_done(struct tevent_req
*subreq
);
5094 struct tevent_req
*cli_notify_send(TALLOC_CTX
*mem_ctx
,
5095 struct tevent_context
*ev
,
5096 struct cli_state
*cli
, uint16_t fnum
,
5097 uint32_t buffer_size
,
5098 uint32_t completion_filter
, bool recursive
)
5100 struct tevent_req
*req
, *subreq
;
5101 struct cli_notify_state
*state
;
5103 req
= tevent_req_create(mem_ctx
, &state
, struct cli_notify_state
);
5108 SIVAL(state
->setup
, 0, completion_filter
);
5109 SSVAL(state
->setup
, 4, fnum
);
5110 SSVAL(state
->setup
, 6, recursive
);
5112 subreq
= cli_trans_send(
5113 state
, /* mem ctx. */
5114 ev
, /* event ctx. */
5115 cli
, /* cli_state. */
5116 SMBnttrans
, /* cmd. */
5117 NULL
, /* pipe name. */
5119 NT_TRANSACT_NOTIFY_CHANGE
, /* function. */
5121 (uint16_t *)state
->setup
, /* setup. */
5122 4, /* num setup uint16_t words. */
5123 0, /* max returned setup. */
5126 buffer_size
, /* max returned param. */
5129 0); /* max returned data. */
5131 if (tevent_req_nomem(subreq
, req
)) {
5132 return tevent_req_post(req
, ev
);
5134 tevent_req_set_callback(subreq
, cli_notify_done
, req
);
5138 static void cli_notify_done(struct tevent_req
*subreq
)
5140 struct tevent_req
*req
= tevent_req_callback_data(
5141 subreq
, struct tevent_req
);
5142 struct cli_notify_state
*state
= tevent_req_data(
5143 req
, struct cli_notify_state
);
5146 uint32_t i
, ofs
, num_params
;
5148 status
= cli_trans_recv(subreq
, talloc_tos(), NULL
, NULL
,
5149 ¶ms
, &num_params
, NULL
, NULL
);
5150 TALLOC_FREE(subreq
);
5151 if (!NT_STATUS_IS_OK(status
)) {
5152 DEBUG(10, ("cli_trans_recv returned %s\n", nt_errstr(status
)));
5153 tevent_req_nterror(req
, status
);
5157 state
->num_changes
= 0;
5160 while (num_params
- ofs
> 12) {
5161 uint32_t len
= IVAL(params
, ofs
);
5162 state
->num_changes
+= 1;
5164 if ((len
== 0) || (ofs
+len
>= num_params
)) {
5170 state
->changes
= talloc_array(state
, struct notify_change
,
5171 state
->num_changes
);
5172 if (tevent_req_nomem(state
->changes
, req
)) {
5173 TALLOC_FREE(params
);
5179 for (i
=0; i
<state
->num_changes
; i
++) {
5180 uint32_t next
= IVAL(params
, ofs
);
5181 uint32_t len
= IVAL(params
, ofs
+8);
5185 if ((next
!= 0) && (len
+12 != next
)) {
5186 TALLOC_FREE(params
);
5188 req
, NT_STATUS_INVALID_NETWORK_RESPONSE
);
5192 state
->changes
[i
].action
= IVAL(params
, ofs
+4);
5193 ret
= clistr_pull_talloc(params
, (char *)params
, &name
,
5195 STR_TERMINATE
|STR_UNICODE
);
5197 TALLOC_FREE(params
);
5198 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
5201 state
->changes
[i
].name
= name
;
5205 TALLOC_FREE(params
);
5206 tevent_req_done(req
);
5209 NTSTATUS
cli_notify_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
5210 uint32_t *pnum_changes
,
5211 struct notify_change
**pchanges
)
5213 struct cli_notify_state
*state
= tevent_req_data(
5214 req
, struct cli_notify_state
);
5217 if (tevent_req_is_nterror(req
, &status
)) {
5221 *pnum_changes
= state
->num_changes
;
5222 *pchanges
= talloc_move(mem_ctx
, &state
->changes
);
5223 return NT_STATUS_OK
;