2 Unix SMB/CIFS implementation.
3 client file read/write routines
4 Copyright (C) Andrew Tridgell 1994-1998
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 /****************************************************************************
23 Calculate the recommended read buffer size
24 ****************************************************************************/
25 static size_t cli_read_max_bufsize(struct cli_state
*cli
)
27 if (!client_is_signing_on(cli
) && !cli_encryption_on(cli
)
28 && (cli
->server_posix_capabilities
& CIFS_UNIX_LARGE_READ_CAP
)) {
29 return CLI_SAMBA_MAX_POSIX_LARGE_READX_SIZE
;
31 if (cli
->capabilities
& CAP_LARGE_READX
) {
33 ? CLI_SAMBA_MAX_LARGE_READX_SIZE
34 : CLI_WINDOWS_MAX_LARGE_READX_SIZE
;
36 return (cli
->max_xmit
- (smb_size
+32)) & ~1023;
39 /****************************************************************************
40 Calculate the recommended write buffer size
41 ****************************************************************************/
42 static size_t cli_write_max_bufsize(struct cli_state
*cli
, uint16_t write_mode
)
44 if (write_mode
== 0 &&
45 !client_is_signing_on(cli
) &&
46 !cli_encryption_on(cli
) &&
47 (cli
->server_posix_capabilities
& CIFS_UNIX_LARGE_WRITE_CAP
) &&
48 (cli
->capabilities
& CAP_LARGE_FILES
)) {
49 /* Only do massive writes if we can do them direct
50 * with no signing or encrypting - not on a pipe. */
51 return CLI_SAMBA_MAX_POSIX_LARGE_WRITEX_SIZE
;
55 return CLI_SAMBA_MAX_LARGE_WRITEX_SIZE
;
58 if (((cli
->capabilities
& CAP_LARGE_WRITEX
) == 0)
59 || client_is_signing_on(cli
)
60 || strequal(cli
->dev
, "LPT1:")) {
63 * Printer devices are restricted to max_xmit writesize in
64 * Vista and XPSP3 as are signing connections.
67 return (cli
->max_xmit
- (smb_size
+32)) & ~1023;
70 return CLI_WINDOWS_MAX_LARGE_WRITEX_SIZE
;
73 struct cli_read_andx_state
{
81 static void cli_read_andx_done(struct tevent_req
*subreq
);
83 struct tevent_req
*cli_read_andx_create(TALLOC_CTX
*mem_ctx
,
84 struct event_context
*ev
,
85 struct cli_state
*cli
, uint16_t fnum
,
86 off_t offset
, size_t size
,
87 struct tevent_req
**psmbreq
)
89 struct tevent_req
*req
, *subreq
;
90 struct cli_read_andx_state
*state
;
93 if (size
> cli_read_max_bufsize(cli
)) {
94 DEBUG(0, ("cli_read_andx_send got size=%d, can only handle "
95 "size=%d\n", (int)size
,
96 (int)cli_read_max_bufsize(cli
)));
100 req
= tevent_req_create(mem_ctx
, &state
, struct cli_read_andx_state
);
106 SCVAL(state
->vwv
+ 0, 0, 0xFF);
107 SCVAL(state
->vwv
+ 0, 1, 0);
108 SSVAL(state
->vwv
+ 1, 0, 0);
109 SSVAL(state
->vwv
+ 2, 0, fnum
);
110 SIVAL(state
->vwv
+ 3, 0, offset
);
111 SSVAL(state
->vwv
+ 5, 0, size
);
112 SSVAL(state
->vwv
+ 6, 0, size
);
113 SSVAL(state
->vwv
+ 7, 0, (size
>> 16));
114 SSVAL(state
->vwv
+ 8, 0, 0);
115 SSVAL(state
->vwv
+ 9, 0, 0);
117 if ((uint64_t)offset
>> 32) {
118 SIVAL(state
->vwv
+ 10, 0,
119 (((uint64_t)offset
)>>32) & 0xffffffff);
123 subreq
= cli_smb_req_create(state
, ev
, cli
, SMBreadX
, 0, wct
,
124 state
->vwv
, 0, NULL
);
125 if (subreq
== NULL
) {
129 tevent_req_set_callback(subreq
, cli_read_andx_done
, req
);
134 struct tevent_req
*cli_read_andx_send(TALLOC_CTX
*mem_ctx
,
135 struct event_context
*ev
,
136 struct cli_state
*cli
, uint16_t fnum
,
137 off_t offset
, size_t size
)
139 struct tevent_req
*req
, *subreq
;
142 req
= cli_read_andx_create(mem_ctx
, ev
, cli
, fnum
, offset
, size
,
148 status
= cli_smb_req_send(subreq
);
149 if (!NT_STATUS_IS_OK(status
)) {
150 tevent_req_nterror(req
, status
);
151 return tevent_req_post(req
, ev
);
156 static void cli_read_andx_done(struct tevent_req
*subreq
)
158 struct tevent_req
*req
= tevent_req_callback_data(
159 subreq
, struct tevent_req
);
160 struct cli_read_andx_state
*state
= tevent_req_data(
161 req
, struct cli_read_andx_state
);
168 state
->status
= cli_smb_recv(subreq
, state
, &inbuf
, 12, &wct
, &vwv
,
171 if (NT_STATUS_IS_ERR(state
->status
)) {
172 tevent_req_nterror(req
, state
->status
);
176 /* size is the number of bytes the server returned.
178 state
->received
= SVAL(vwv
+ 5, 0);
179 state
->received
|= (((unsigned int)SVAL(vwv
+ 7, 0)) << 16);
181 if (state
->received
> state
->size
) {
182 DEBUG(5,("server returned more than we wanted!\n"));
183 tevent_req_nterror(req
, NT_STATUS_UNEXPECTED_IO_ERROR
);
188 * bcc field must be valid for small reads, for large reads the 16-bit
189 * bcc field can't be correct.
192 if ((state
->received
< 0xffff) && (state
->received
> num_bytes
)) {
193 DEBUG(5, ("server announced more bytes than sent\n"));
194 tevent_req_nterror(req
, NT_STATUS_INVALID_NETWORK_RESPONSE
);
198 state
->buf
= (uint8_t *)smb_base(inbuf
) + SVAL(vwv
+6, 0);
200 if (trans_oob(smb_len(inbuf
), SVAL(vwv
+6, 0), state
->received
)
201 || ((state
->received
!= 0) && (state
->buf
< bytes
))) {
202 DEBUG(5, ("server returned invalid read&x data offset\n"));
203 tevent_req_nterror(req
, NT_STATUS_INVALID_NETWORK_RESPONSE
);
206 tevent_req_done(req
);
210 * Pull the data out of a finished async read_and_x request. rcvbuf is
211 * talloced from the request, so better make sure that you copy it away before
212 * you talloc_free(req). "rcvbuf" is NOT a talloc_ctx of its own, so do not
216 NTSTATUS
cli_read_andx_recv(struct tevent_req
*req
, ssize_t
*received
,
219 struct cli_read_andx_state
*state
= tevent_req_data(
220 req
, struct cli_read_andx_state
);
223 if (tevent_req_is_nterror(req
, &status
)) {
226 *received
= state
->received
;
227 *rcvbuf
= state
->buf
;
231 struct cli_readall_state
{
232 struct tevent_context
*ev
;
233 struct cli_state
*cli
;
241 static void cli_readall_done(struct tevent_req
*subreq
);
243 static struct tevent_req
*cli_readall_send(TALLOC_CTX
*mem_ctx
,
244 struct event_context
*ev
,
245 struct cli_state
*cli
,
247 off_t offset
, size_t size
)
249 struct tevent_req
*req
, *subreq
;
250 struct cli_readall_state
*state
;
252 req
= tevent_req_create(mem_ctx
, &state
, struct cli_readall_state
);
259 state
->start_offset
= offset
;
264 subreq
= cli_read_andx_send(state
, ev
, cli
, fnum
, offset
, size
);
265 if (tevent_req_nomem(subreq
, req
)) {
266 return tevent_req_post(req
, ev
);
268 tevent_req_set_callback(subreq
, cli_readall_done
, req
);
272 static void cli_readall_done(struct tevent_req
*subreq
)
274 struct tevent_req
*req
= tevent_req_callback_data(
275 subreq
, struct tevent_req
);
276 struct cli_readall_state
*state
= tevent_req_data(
277 req
, struct cli_readall_state
);
282 status
= cli_read_andx_recv(subreq
, &received
, &buf
);
283 if (!NT_STATUS_IS_OK(status
)) {
284 tevent_req_nterror(req
, status
);
290 tevent_req_done(req
);
294 if ((state
->received
== 0) && (received
== state
->size
)) {
295 /* Ideal case: Got it all in one run */
297 state
->received
+= received
;
298 tevent_req_done(req
);
303 * We got a short read, issue a read for the
304 * rest. Unfortunately we have to allocate the buffer
305 * ourselves now, as our caller expects to receive a single
306 * buffer. cli_read_andx does it from the buffer received from
307 * the net, but with a short read we have to put it together
308 * from several reads.
311 if (state
->buf
== NULL
) {
312 state
->buf
= talloc_array(state
, uint8_t, state
->size
);
313 if (tevent_req_nomem(state
->buf
, req
)) {
317 memcpy(state
->buf
+ state
->received
, buf
, received
);
318 state
->received
+= received
;
322 if (state
->received
>= state
->size
) {
323 tevent_req_done(req
);
327 subreq
= cli_read_andx_send(state
, state
->ev
, state
->cli
, state
->fnum
,
328 state
->start_offset
+ state
->received
,
329 state
->size
- state
->received
);
330 if (tevent_req_nomem(subreq
, req
)) {
333 tevent_req_set_callback(subreq
, cli_readall_done
, req
);
336 static NTSTATUS
cli_readall_recv(struct tevent_req
*req
, ssize_t
*received
,
339 struct cli_readall_state
*state
= tevent_req_data(
340 req
, struct cli_readall_state
);
343 if (tevent_req_is_nterror(req
, &status
)) {
346 *received
= state
->received
;
347 *rcvbuf
= state
->buf
;
351 struct cli_pull_subreq
{
352 struct tevent_req
*req
;
358 * Parallel read support.
360 * cli_pull sends as many read&x requests as the server would allow via
361 * max_mux at a time. When replies flow back in, the data is written into
362 * the callback function "sink" in the right order.
365 struct cli_pull_state
{
366 struct tevent_req
*req
;
368 struct event_context
*ev
;
369 struct cli_state
*cli
;
374 NTSTATUS (*sink
)(char *buf
, size_t n
, void *priv
);
380 * Outstanding requests
383 struct cli_pull_subreq
*reqs
;
386 * For how many bytes did we send requests already?
391 * Next request index to push into "sink". This walks around the "req"
392 * array, taking care that the requests are pushed to "sink" in the
393 * right order. If necessary (i.e. replies don't come in in the right
394 * order), replies are held back in "reqs".
399 * How many bytes did we push into "sink"?
405 static char *cli_pull_print(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
)
407 struct cli_pull_state
*state
= tevent_req_data(
408 req
, struct cli_pull_state
);
411 result
= tevent_req_default_print(req
, mem_ctx
);
412 if (result
== NULL
) {
416 return talloc_asprintf_append_buffer(
417 result
, "num_reqs=%d, top_req=%d",
418 state
->num_reqs
, state
->top_req
);
421 static void cli_pull_read_done(struct tevent_req
*read_req
);
424 * Prepare an async pull request
427 struct tevent_req
*cli_pull_send(TALLOC_CTX
*mem_ctx
,
428 struct event_context
*ev
,
429 struct cli_state
*cli
,
430 uint16_t fnum
, off_t start_offset
,
431 SMB_OFF_T size
, size_t window_size
,
432 NTSTATUS (*sink
)(char *buf
, size_t n
,
436 struct tevent_req
*req
;
437 struct cli_pull_state
*state
;
440 req
= tevent_req_create(mem_ctx
, &state
, struct cli_pull_state
);
444 tevent_req_set_print_fn(req
, cli_pull_print
);
450 state
->start_offset
= start_offset
;
459 tevent_req_done(req
);
460 return tevent_req_post(req
, ev
);
463 state
->chunk_size
= cli_read_max_bufsize(cli
);
465 state
->num_reqs
= MAX(window_size
/state
->chunk_size
, 1);
466 state
->num_reqs
= MIN(state
->num_reqs
, cli
->max_mux
);
468 state
->reqs
= TALLOC_ZERO_ARRAY(state
, struct cli_pull_subreq
,
470 if (state
->reqs
== NULL
) {
474 state
->requested
= 0;
476 for (i
=0; i
<state
->num_reqs
; i
++) {
477 struct cli_pull_subreq
*subreq
= &state
->reqs
[i
];
479 size_t request_thistime
;
481 if (state
->requested
>= size
) {
486 size_left
= size
- state
->requested
;
487 request_thistime
= MIN(size_left
, state
->chunk_size
);
489 subreq
->req
= cli_readall_send(
490 state
->reqs
, ev
, cli
, fnum
,
491 state
->start_offset
+ state
->requested
,
494 if (subreq
->req
== NULL
) {
497 tevent_req_set_callback(subreq
->req
, cli_pull_read_done
, req
);
498 state
->requested
+= request_thistime
;
508 * Handle incoming read replies, push the data into sink and send out new
509 * requests if necessary.
512 static void cli_pull_read_done(struct tevent_req
*subreq
)
514 struct tevent_req
*req
= tevent_req_callback_data(
515 subreq
, struct tevent_req
);
516 struct cli_pull_state
*state
= tevent_req_data(
517 req
, struct cli_pull_state
);
518 struct cli_pull_subreq
*pull_subreq
= NULL
;
522 for (i
= 0; i
< state
->num_reqs
; i
++) {
523 pull_subreq
= &state
->reqs
[i
];
524 if (subreq
== pull_subreq
->req
) {
528 if (i
== state
->num_reqs
) {
529 /* Huh -- received something we did not send?? */
530 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
534 status
= cli_readall_recv(subreq
, &pull_subreq
->received
,
536 if (!NT_STATUS_IS_OK(status
)) {
537 tevent_req_nterror(state
->req
, status
);
542 * This loop is the one to take care of out-of-order replies. All
543 * pending requests are in state->reqs, state->reqs[top_req] is the
544 * one that is to be pushed next. If however a request later than
545 * top_req is replied to, then we can't push yet. If top_req is
546 * replied to at a later point then, we need to push all the finished
550 while (state
->reqs
[state
->top_req
].req
!= NULL
) {
551 struct cli_pull_subreq
*top_subreq
;
553 DEBUG(11, ("cli_pull_read_done: top_req = %d\n",
556 top_subreq
= &state
->reqs
[state
->top_req
];
558 if (tevent_req_is_in_progress(top_subreq
->req
)) {
559 DEBUG(11, ("cli_pull_read_done: top request not yet "
564 DEBUG(10, ("cli_pull_read_done: Pushing %d bytes, %d already "
565 "pushed\n", (int)top_subreq
->received
,
566 (int)state
->pushed
));
568 status
= state
->sink((char *)top_subreq
->buf
,
569 top_subreq
->received
, state
->priv
);
570 if (!NT_STATUS_IS_OK(status
)) {
571 tevent_req_nterror(state
->req
, status
);
574 state
->pushed
+= top_subreq
->received
;
576 TALLOC_FREE(state
->reqs
[state
->top_req
].req
);
578 if (state
->requested
< state
->size
) {
579 struct tevent_req
*new_req
;
581 size_t request_thistime
;
583 size_left
= state
->size
- state
->requested
;
584 request_thistime
= MIN(size_left
, state
->chunk_size
);
586 DEBUG(10, ("cli_pull_read_done: Requesting %d bytes "
587 "at %d, position %d\n",
588 (int)request_thistime
,
589 (int)(state
->start_offset
593 new_req
= cli_readall_send(
594 state
->reqs
, state
->ev
, state
->cli
,
596 state
->start_offset
+ state
->requested
,
599 if (tevent_req_nomem(new_req
, state
->req
)) {
602 tevent_req_set_callback(new_req
, cli_pull_read_done
,
605 state
->reqs
[state
->top_req
].req
= new_req
;
606 state
->requested
+= request_thistime
;
609 state
->top_req
= (state
->top_req
+1) % state
->num_reqs
;
612 tevent_req_done(req
);
615 NTSTATUS
cli_pull_recv(struct tevent_req
*req
, SMB_OFF_T
*received
)
617 struct cli_pull_state
*state
= tevent_req_data(
618 req
, struct cli_pull_state
);
621 if (tevent_req_is_nterror(req
, &status
)) {
624 *received
= state
->pushed
;
628 NTSTATUS
cli_pull(struct cli_state
*cli
, uint16_t fnum
,
629 off_t start_offset
, SMB_OFF_T size
, size_t window_size
,
630 NTSTATUS (*sink
)(char *buf
, size_t n
, void *priv
),
631 void *priv
, SMB_OFF_T
*received
)
633 TALLOC_CTX
*frame
= talloc_stackframe();
634 struct event_context
*ev
;
635 struct tevent_req
*req
;
636 NTSTATUS status
= NT_STATUS_OK
;
638 if (cli_has_async_calls(cli
)) {
640 * Can't use sync call while an async call is in flight
642 status
= NT_STATUS_INVALID_PARAMETER
;
646 ev
= event_context_init(frame
);
648 status
= NT_STATUS_NO_MEMORY
;
652 req
= cli_pull_send(frame
, ev
, cli
, fnum
, start_offset
, size
,
653 window_size
, sink
, priv
);
655 status
= NT_STATUS_NO_MEMORY
;
659 if (!tevent_req_poll(req
, ev
)) {
660 status
= map_nt_error_from_unix(errno
);
664 status
= cli_pull_recv(req
, received
);
667 if (!NT_STATUS_IS_OK(status
)) {
668 cli_set_error(cli
, status
);
673 static NTSTATUS
cli_read_sink(char *buf
, size_t n
, void *priv
)
675 char **pbuf
= (char **)priv
;
676 memcpy(*pbuf
, buf
, n
);
681 ssize_t
cli_read(struct cli_state
*cli
, uint16_t fnum
, char *buf
,
682 off_t offset
, size_t size
)
687 status
= cli_pull(cli
, fnum
, offset
, size
, size
,
688 cli_read_sink
, &buf
, &ret
);
689 if (!NT_STATUS_IS_OK(status
)) {
690 cli_set_error(cli
, status
);
696 /****************************************************************************
697 Issue a single SMBwrite and don't wait for a reply.
698 ****************************************************************************/
700 static bool cli_issue_write(struct cli_state
*cli
,
709 bool large_writex
= false;
710 /* We can only do direct writes if not signing and not encrypting. */
711 bool direct_writes
= !client_is_signing_on(cli
) && !cli_encryption_on(cli
);
713 if (!direct_writes
&& size
+ 1 > cli
->bufsize
) {
714 cli
->outbuf
= (char *)SMB_REALLOC(cli
->outbuf
, size
+ 1024);
718 cli
->inbuf
= (char *)SMB_REALLOC(cli
->inbuf
, size
+ 1024);
719 if (cli
->inbuf
== NULL
) {
720 SAFE_FREE(cli
->outbuf
);
723 cli
->bufsize
= size
+ 1024;
726 memset(cli
->outbuf
,'\0',smb_size
);
727 memset(cli
->inbuf
,'\0',smb_size
);
729 if (cli
->capabilities
& CAP_LARGE_FILES
) {
734 cli_set_message(cli
->outbuf
,14,0,True
);
736 cli_set_message(cli
->outbuf
,12,0,True
);
739 SCVAL(cli
->outbuf
,smb_com
,SMBwriteX
);
740 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
741 cli_setup_packet(cli
);
743 SCVAL(cli
->outbuf
,smb_vwv0
,0xFF);
744 SSVAL(cli
->outbuf
,smb_vwv2
,fnum
);
746 SIVAL(cli
->outbuf
,smb_vwv3
,offset
);
747 SIVAL(cli
->outbuf
,smb_vwv5
,0);
748 SSVAL(cli
->outbuf
,smb_vwv7
,mode
);
750 SSVAL(cli
->outbuf
,smb_vwv8
,(mode
& 0x0008) ? size
: 0);
752 * According to CIFS-TR-1p00, this following field should only
753 * be set if CAP_LARGE_WRITEX is set. We should check this
754 * locally. However, this check might already have been
755 * done by our callers.
757 SSVAL(cli
->outbuf
,smb_vwv9
,(size
>>16));
758 SSVAL(cli
->outbuf
,smb_vwv10
,size
);
759 /* +1 is pad byte. */
760 SSVAL(cli
->outbuf
,smb_vwv11
,
761 smb_buf(cli
->outbuf
) - smb_base(cli
->outbuf
) + 1);
764 SIVAL(cli
->outbuf
,smb_vwv12
,(((uint64_t)offset
)>>32) & 0xffffffff);
767 p
= smb_base(cli
->outbuf
) + SVAL(cli
->outbuf
,smb_vwv11
) -1;
768 *p
++ = '\0'; /* pad byte. */
769 if (!direct_writes
) {
770 memcpy(p
, buf
, size
);
772 if (size
> 0x1FFFF) {
773 /* This is a POSIX 14 word large write. */
774 set_message_bcc(cli
->outbuf
, 0); /* Set bcc to zero. */
775 _smb_setlen_large(cli
->outbuf
,smb_size
+ 28 + 1 /* pad */ + size
- 4);
777 cli_setup_bcc(cli
, p
+size
);
780 SSVAL(cli
->outbuf
,smb_mid
,cli
->mid
+ i
);
782 show_msg(cli
->outbuf
);
784 /* For direct writes we now need to write the data
785 * directly out of buf. */
786 return cli_send_smb_direct_writeX(cli
, buf
, size
);
788 return cli_send_smb(cli
);
792 /****************************************************************************
794 write_mode: 0x0001 disallow write cacheing
795 0x0002 return bytes remaining
796 0x0004 use raw named pipe protocol
797 0x0008 start of message mode named pipe protocol
798 ****************************************************************************/
800 ssize_t
cli_write(struct cli_state
*cli
,
801 uint16_t fnum
, uint16 write_mode
,
802 const char *buf
, off_t offset
, size_t size
)
804 ssize_t bwritten
= 0;
805 unsigned int issued
= 0;
806 unsigned int received
= 0;
811 if(cli
->max_mux
> 1) {
812 mpx
= cli
->max_mux
-1;
817 writesize
= cli_write_max_bufsize(cli
, write_mode
);
819 blocks
= (size
+ (writesize
-1)) / writesize
;
821 while (received
< blocks
) {
823 while ((issued
- received
< mpx
) && (issued
< blocks
)) {
824 ssize_t bsent
= issued
* writesize
;
825 ssize_t size1
= MIN(writesize
, size
- bsent
);
827 if (!cli_issue_write(cli
, fnum
, offset
+ bsent
,
835 if (!cli_receive_smb(cli
)) {
841 if (cli_is_error(cli
))
844 bwritten
+= SVAL(cli
->inbuf
, smb_vwv2
);
845 if (writesize
> 0xFFFF) {
846 bwritten
+= (((int)(SVAL(cli
->inbuf
, smb_vwv4
)))<<16);
850 while (received
< issued
&& cli_receive_smb(cli
)) {
857 /****************************************************************************
858 write to a file using a SMBwrite and not bypassing 0 byte writes
859 ****************************************************************************/
861 ssize_t
cli_smbwrite(struct cli_state
*cli
,
862 uint16_t fnum
, char *buf
, off_t offset
, size_t size1
)
868 size_t size
= MIN(size1
, cli
->max_xmit
- 48);
870 memset(cli
->outbuf
,'\0',smb_size
);
871 memset(cli
->inbuf
,'\0',smb_size
);
873 cli_set_message(cli
->outbuf
,5, 0,True
);
875 SCVAL(cli
->outbuf
,smb_com
,SMBwrite
);
876 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
877 cli_setup_packet(cli
);
879 SSVAL(cli
->outbuf
,smb_vwv0
,fnum
);
880 SSVAL(cli
->outbuf
,smb_vwv1
,size
);
881 SIVAL(cli
->outbuf
,smb_vwv2
,offset
);
882 SSVAL(cli
->outbuf
,smb_vwv4
,0);
884 p
= smb_buf(cli
->outbuf
);
886 SSVAL(p
, 0, size
); p
+= 2;
887 memcpy(p
, buf
+ total
, size
); p
+= size
;
889 cli_setup_bcc(cli
, p
);
891 if (!cli_send_smb(cli
))
894 if (!cli_receive_smb(cli
))
897 if (cli_is_error(cli
))
900 size
= SVAL(cli
->inbuf
,smb_vwv0
);
914 * Send a write&x request
917 struct cli_write_andx_state
{
925 static void cli_write_andx_done(struct tevent_req
*subreq
);
927 struct tevent_req
*cli_write_andx_create(TALLOC_CTX
*mem_ctx
,
928 struct event_context
*ev
,
929 struct cli_state
*cli
, uint16_t fnum
,
930 uint16_t mode
, const uint8_t *buf
,
931 off_t offset
, size_t size
,
932 struct tevent_req
**reqs_before
,
934 struct tevent_req
**psmbreq
)
936 struct tevent_req
*req
, *subreq
;
937 struct cli_write_andx_state
*state
;
938 bool bigoffset
= ((cli
->capabilities
& CAP_LARGE_FILES
) != 0);
939 uint8_t wct
= bigoffset
? 14 : 12;
940 size_t max_write
= cli_write_max_bufsize(cli
, mode
);
943 req
= tevent_req_create(mem_ctx
, &state
, struct cli_write_andx_state
);
948 size
= MIN(size
, max_write
);
952 SCVAL(vwv
+0, 0, 0xFF);
955 SSVAL(vwv
+2, 0, fnum
);
956 SIVAL(vwv
+3, 0, offset
);
958 SSVAL(vwv
+7, 0, mode
);
960 SSVAL(vwv
+9, 0, (size
>>16));
961 SSVAL(vwv
+10, 0, size
);
964 cli_smb_wct_ofs(reqs_before
, num_reqs_before
)
965 + 1 /* the wct field */
967 + 2 /* num_bytes field */
971 SIVAL(vwv
+12, 0, (((uint64_t)offset
)>>32) & 0xffffffff);
975 state
->iov
[0].iov_base
= (void *)&state
->pad
;
976 state
->iov
[0].iov_len
= 1;
977 state
->iov
[1].iov_base
= CONST_DISCARD(void *, buf
);
978 state
->iov
[1].iov_len
= size
;
980 subreq
= cli_smb_req_create(state
, ev
, cli
, SMBwriteX
, 0, wct
, vwv
,
982 if (tevent_req_nomem(subreq
, req
)) {
983 return tevent_req_post(req
, ev
);
985 tevent_req_set_callback(subreq
, cli_write_andx_done
, req
);
990 struct tevent_req
*cli_write_andx_send(TALLOC_CTX
*mem_ctx
,
991 struct event_context
*ev
,
992 struct cli_state
*cli
, uint16_t fnum
,
993 uint16_t mode
, const uint8_t *buf
,
994 off_t offset
, size_t size
)
996 struct tevent_req
*req
, *subreq
;
999 req
= cli_write_andx_create(mem_ctx
, ev
, cli
, fnum
, mode
, buf
, offset
,
1000 size
, NULL
, 0, &subreq
);
1005 status
= cli_smb_req_send(subreq
);
1006 if (!NT_STATUS_IS_OK(status
)) {
1007 tevent_req_nterror(req
, status
);
1008 return tevent_req_post(req
, ev
);
1013 static void cli_write_andx_done(struct tevent_req
*subreq
)
1015 struct tevent_req
*req
= tevent_req_callback_data(
1016 subreq
, struct tevent_req
);
1017 struct cli_write_andx_state
*state
= tevent_req_data(
1018 req
, struct cli_write_andx_state
);
1024 status
= cli_smb_recv(subreq
, state
, &inbuf
, 6, &wct
, &vwv
,
1026 TALLOC_FREE(subreq
);
1027 if (NT_STATUS_IS_ERR(status
)) {
1028 tevent_req_nterror(req
, status
);
1031 state
->written
= SVAL(vwv
+2, 0);
1032 state
->written
|= SVAL(vwv
+4, 0)<<16;
1033 tevent_req_done(req
);
1036 NTSTATUS
cli_write_andx_recv(struct tevent_req
*req
, size_t *pwritten
)
1038 struct cli_write_andx_state
*state
= tevent_req_data(
1039 req
, struct cli_write_andx_state
);
1042 if (tevent_req_is_nterror(req
, &status
)) {
1045 *pwritten
= state
->written
;
1046 return NT_STATUS_OK
;
1049 struct cli_writeall_state
{
1050 struct event_context
*ev
;
1051 struct cli_state
*cli
;
1060 static void cli_writeall_written(struct tevent_req
*req
);
1062 static struct tevent_req
*cli_writeall_send(TALLOC_CTX
*mem_ctx
,
1063 struct event_context
*ev
,
1064 struct cli_state
*cli
,
1068 off_t offset
, size_t size
)
1070 struct tevent_req
*req
, *subreq
;
1071 struct cli_writeall_state
*state
;
1073 req
= tevent_req_create(mem_ctx
, &state
, struct cli_writeall_state
);
1082 state
->offset
= offset
;
1086 subreq
= cli_write_andx_send(state
, state
->ev
, state
->cli
, state
->fnum
,
1087 state
->mode
, state
->buf
, state
->offset
,
1089 if (tevent_req_nomem(subreq
, req
)) {
1090 return tevent_req_post(req
, ev
);
1092 tevent_req_set_callback(subreq
, cli_writeall_written
, req
);
1096 static void cli_writeall_written(struct tevent_req
*subreq
)
1098 struct tevent_req
*req
= tevent_req_callback_data(
1099 subreq
, struct tevent_req
);
1100 struct cli_writeall_state
*state
= tevent_req_data(
1101 req
, struct cli_writeall_state
);
1103 size_t written
, to_write
;
1105 status
= cli_write_andx_recv(subreq
, &written
);
1106 TALLOC_FREE(subreq
);
1107 if (!NT_STATUS_IS_OK(status
)) {
1108 tevent_req_nterror(req
, status
);
1112 state
->written
+= written
;
1114 if (state
->written
> state
->size
) {
1115 tevent_req_nterror(req
, NT_STATUS_INVALID_NETWORK_RESPONSE
);
1119 to_write
= state
->size
- state
->written
;
1121 if (to_write
== 0) {
1122 tevent_req_done(req
);
1126 subreq
= cli_write_andx_send(state
, state
->ev
, state
->cli
, state
->fnum
,
1128 state
->buf
+ state
->written
,
1129 state
->offset
+ state
->written
, to_write
);
1130 if (tevent_req_nomem(subreq
, req
)) {
1133 tevent_req_set_callback(subreq
, cli_writeall_written
, req
);
1136 static NTSTATUS
cli_writeall_recv(struct tevent_req
*req
)
1138 return tevent_req_simple_recv_ntstatus(req
);
1141 struct cli_push_write_state
{
1142 struct tevent_req
*req
;/* This is the main request! Not the subreq */
1149 struct cli_push_state
{
1150 struct event_context
*ev
;
1151 struct cli_state
*cli
;
1157 size_t (*source
)(uint8_t *buf
, size_t n
, void *priv
);
1166 * Outstanding requests
1170 struct cli_push_write_state
**reqs
;
1173 static void cli_push_written(struct tevent_req
*req
);
1175 static bool cli_push_write_setup(struct tevent_req
*req
,
1176 struct cli_push_state
*state
,
1179 struct cli_push_write_state
*substate
;
1180 struct tevent_req
*subreq
;
1182 substate
= talloc(state
->reqs
, struct cli_push_write_state
);
1186 substate
->req
= req
;
1187 substate
->idx
= idx
;
1188 substate
->ofs
= state
->next_offset
;
1189 substate
->buf
= talloc_array(substate
, uint8_t, state
->chunk_size
);
1190 if (!substate
->buf
) {
1191 talloc_free(substate
);
1194 substate
->size
= state
->source(substate
->buf
,
1197 if (substate
->size
== 0) {
1199 /* nothing to send */
1200 talloc_free(substate
);
1204 subreq
= cli_writeall_send(substate
,
1205 state
->ev
, state
->cli
,
1206 state
->fnum
, state
->mode
,
1211 talloc_free(substate
);
1214 tevent_req_set_callback(subreq
, cli_push_written
, substate
);
1216 state
->reqs
[idx
] = substate
;
1217 state
->pending
+= 1;
1218 state
->next_offset
+= substate
->size
;
1223 struct tevent_req
*cli_push_send(TALLOC_CTX
*mem_ctx
, struct event_context
*ev
,
1224 struct cli_state
*cli
,
1225 uint16_t fnum
, uint16_t mode
,
1226 off_t start_offset
, size_t window_size
,
1227 size_t (*source
)(uint8_t *buf
, size_t n
,
1231 struct tevent_req
*req
;
1232 struct cli_push_state
*state
;
1235 req
= tevent_req_create(mem_ctx
, &state
, struct cli_push_state
);
1242 state
->start_offset
= start_offset
;
1244 state
->source
= source
;
1248 state
->next_offset
= start_offset
;
1250 state
->chunk_size
= cli_write_max_bufsize(cli
, mode
);
1252 if (window_size
== 0) {
1253 window_size
= cli
->max_mux
* state
->chunk_size
;
1255 state
->num_reqs
= window_size
/state
->chunk_size
;
1256 if ((window_size
% state
->chunk_size
) > 0) {
1257 state
->num_reqs
+= 1;
1259 state
->num_reqs
= MIN(state
->num_reqs
, cli
->max_mux
);
1260 state
->num_reqs
= MAX(state
->num_reqs
, 1);
1262 state
->reqs
= TALLOC_ZERO_ARRAY(state
, struct cli_push_write_state
*,
1264 if (state
->reqs
== NULL
) {
1268 for (i
=0; i
<state
->num_reqs
; i
++) {
1269 if (!cli_push_write_setup(req
, state
, i
)) {
1278 if (state
->pending
== 0) {
1279 tevent_req_done(req
);
1280 return tevent_req_post(req
, ev
);
1286 tevent_req_nterror(req
, NT_STATUS_NO_MEMORY
);
1287 return tevent_req_post(req
, ev
);
1290 static void cli_push_written(struct tevent_req
*subreq
)
1292 struct cli_push_write_state
*substate
= tevent_req_callback_data(
1293 subreq
, struct cli_push_write_state
);
1294 struct tevent_req
*req
= substate
->req
;
1295 struct cli_push_state
*state
= tevent_req_data(
1296 req
, struct cli_push_state
);
1298 uint32_t idx
= substate
->idx
;
1300 state
->reqs
[idx
] = NULL
;
1301 state
->pending
-= 1;
1303 status
= cli_writeall_recv(subreq
);
1304 TALLOC_FREE(subreq
);
1305 TALLOC_FREE(substate
);
1306 if (!NT_STATUS_IS_OK(status
)) {
1307 tevent_req_nterror(req
, status
);
1312 if (!cli_push_write_setup(req
, state
, idx
)) {
1313 tevent_req_nterror(req
, NT_STATUS_NO_MEMORY
);
1318 if (state
->pending
== 0) {
1319 tevent_req_done(req
);
1324 NTSTATUS
cli_push_recv(struct tevent_req
*req
)
1326 return tevent_req_simple_recv_ntstatus(req
);
1329 NTSTATUS
cli_push(struct cli_state
*cli
, uint16_t fnum
, uint16_t mode
,
1330 off_t start_offset
, size_t window_size
,
1331 size_t (*source
)(uint8_t *buf
, size_t n
, void *priv
),
1334 TALLOC_CTX
*frame
= talloc_stackframe();
1335 struct event_context
*ev
;
1336 struct tevent_req
*req
;
1337 NTSTATUS status
= NT_STATUS_OK
;
1339 if (cli_has_async_calls(cli
)) {
1341 * Can't use sync call while an async call is in flight
1343 status
= NT_STATUS_INVALID_PARAMETER
;
1347 ev
= event_context_init(frame
);
1349 status
= NT_STATUS_NO_MEMORY
;
1353 req
= cli_push_send(frame
, ev
, cli
, fnum
, mode
, start_offset
,
1354 window_size
, source
, priv
);
1356 status
= NT_STATUS_NO_MEMORY
;
1360 if (!tevent_req_poll(req
, ev
)) {
1361 status
= map_nt_error_from_unix(errno
);
1365 status
= cli_push_recv(req
);
1368 if (!NT_STATUS_IS_OK(status
)) {
1369 cli_set_error(cli
, status
);