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
->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;
40 * Send a read&x request
43 struct async_req
*cli_read_andx_send(TALLOC_CTX
*mem_ctx
,
44 struct cli_state
*cli
, int fnum
,
45 off_t offset
, size_t size
)
47 struct async_req
*result
;
48 struct cli_request
*req
;
49 bool bigoffset
= False
;
52 if (size
> cli_read_max_bufsize(cli
)) {
53 DEBUG(0, ("cli_read_andx_send got size=%d, can only handle "
54 "size=%d\n", (int)size
,
55 (int)cli_read_max_bufsize(cli
)));
59 result
= cli_request_new(mem_ctx
, cli
->event_ctx
, cli
, 12, 0, &req
);
61 DEBUG(0, ("cli_request_new failed\n"));
65 req
= cli_request_get(result
);
67 req
->data
.read
.ofs
= offset
;
68 req
->data
.read
.size
= size
;
69 req
->data
.read
.received
= 0;
70 req
->data
.read
.rcvbuf
= NULL
;
72 if ((SMB_BIG_UINT
)offset
>> 32)
75 cli_set_message(req
->outbuf
, bigoffset
? 12 : 10, 0, False
);
77 SCVAL(req
->outbuf
,smb_com
,SMBreadX
);
78 SSVAL(req
->outbuf
,smb_tid
,cli
->cnum
);
79 cli_setup_packet_buf(cli
, req
->outbuf
);
81 SCVAL(req
->outbuf
,smb_vwv0
,0xFF);
82 SCVAL(req
->outbuf
,smb_vwv0
+1,0);
83 SSVAL(req
->outbuf
,smb_vwv1
,0);
84 SSVAL(req
->outbuf
,smb_vwv2
,fnum
);
85 SIVAL(req
->outbuf
,smb_vwv3
,offset
);
86 SSVAL(req
->outbuf
,smb_vwv5
,size
);
87 SSVAL(req
->outbuf
,smb_vwv6
,size
);
88 SSVAL(req
->outbuf
,smb_vwv7
,(size
>> 16));
89 SSVAL(req
->outbuf
,smb_vwv8
,0);
90 SSVAL(req
->outbuf
,smb_vwv9
,0);
91 SSVAL(req
->outbuf
,smb_mid
,req
->mid
);
94 SIVAL(req
->outbuf
, smb_vwv10
,
95 (((SMB_BIG_UINT
)offset
)>>32) & 0xffffffff);
98 cli_calculate_sign_mac(cli
, req
->outbuf
);
100 event_fd_set_writeable(cli
->fd_event
);
102 if (cli_encryption_on(cli
)) {
104 status
= cli_encrypt_message(cli
, req
->outbuf
, &enc_buf
);
105 if (!NT_STATUS_IS_OK(status
)) {
106 DEBUG(0, ("Error in encrypting client message. "
107 "Error %s\n", nt_errstr(status
)));
111 req
->outbuf
= enc_buf
;
112 req
->enc_state
= cli
->trans_enc_state
;
119 * Pull the data out of a finished async read_and_x request. rcvbuf is
120 * talloced from the request, so better make sure that you copy it away before
121 * you talloc_free(req). "rcvbuf" is NOT a talloc_ctx of its own, so do not
125 NTSTATUS
cli_read_andx_recv(struct async_req
*req
, ssize_t
*received
,
128 struct cli_request
*cli_req
= cli_request_get(req
);
132 SMB_ASSERT(req
->state
>= ASYNC_REQ_DONE
);
133 if (req
->state
== ASYNC_REQ_ERROR
) {
137 status
= cli_pull_error(cli_req
->inbuf
);
139 if (NT_STATUS_IS_ERR(status
)) {
143 /* size is the number of bytes the server returned.
145 size
= SVAL(cli_req
->inbuf
, smb_vwv5
);
146 size
|= (((unsigned int)(SVAL(cli_req
->inbuf
, smb_vwv7
))) << 16);
148 if (size
> cli_req
->data
.read
.size
) {
149 DEBUG(5,("server returned more than we wanted!\n"));
150 return NT_STATUS_UNEXPECTED_IO_ERROR
;
153 *rcvbuf
= (uint8_t *)
154 (smb_base(cli_req
->inbuf
) + SVAL(cli_req
->inbuf
, smb_vwv6
));
160 * Parallel read support.
162 * cli_pull sends as many read&x requests as the server would allow via
163 * max_mux at a time. When replies flow back in, the data is written into
164 * the callback function "sink" in the right order.
167 struct cli_pull_state
{
168 struct async_req
*req
;
170 struct cli_state
*cli
;
175 NTSTATUS (*sink
)(char *buf
, size_t n
, void *priv
);
181 * Outstanding requests
184 struct async_req
**reqs
;
187 * For how many bytes did we send requests already?
192 * Next request index to push into "sink". This walks around the "req"
193 * array, taking care that the requests are pushed to "sink" in the
194 * right order. If necessary (i.e. replies don't come in in the right
195 * order), replies are held back in "reqs".
200 * How many bytes did we push into "sink"?
206 static char *cli_pull_print(TALLOC_CTX
*mem_ctx
, struct async_req
*req
)
208 struct cli_pull_state
*state
= talloc_get_type_abort(
209 req
->private_data
, struct cli_pull_state
);
212 result
= async_req_print(mem_ctx
, req
);
213 if (result
== NULL
) {
217 return talloc_asprintf_append_buffer(
218 result
, "num_reqs=%d, top_req=%d",
219 state
->num_reqs
, state
->top_req
);
222 static void cli_pull_read_done(struct async_req
*read_req
);
225 * Prepare an async pull request
228 struct async_req
*cli_pull_send(TALLOC_CTX
*mem_ctx
, struct cli_state
*cli
,
229 uint16_t fnum
, off_t start_offset
,
230 SMB_OFF_T size
, size_t window_size
,
231 NTSTATUS (*sink
)(char *buf
, size_t n
,
235 struct async_req
*result
;
236 struct cli_pull_state
*state
;
239 result
= async_req_new(mem_ctx
, cli
->event_ctx
);
240 if (result
== NULL
) {
243 state
= talloc(result
, struct cli_pull_state
);
247 result
->private_data
= state
;
248 result
->print
= cli_pull_print
;
253 state
->start_offset
= start_offset
;
262 if (!async_post_status(result
, NT_STATUS_OK
)) {
268 state
->chunk_size
= cli_read_max_bufsize(cli
);
270 state
->num_reqs
= MAX(window_size
/state
->chunk_size
, 1);
271 state
->num_reqs
= MIN(state
->num_reqs
, cli
->max_mux
);
273 state
->reqs
= TALLOC_ZERO_ARRAY(state
, struct async_req
*,
275 if (state
->reqs
== NULL
) {
279 state
->requested
= 0;
281 for (i
=0; i
<state
->num_reqs
; i
++) {
283 size_t request_thistime
;
285 if (state
->requested
>= size
) {
290 size_left
= size
- state
->requested
;
291 request_thistime
= MIN(size_left
, state
->chunk_size
);
293 state
->reqs
[i
] = cli_read_andx_send(
294 state
->reqs
, cli
, fnum
,
295 state
->start_offset
+ state
->requested
,
298 if (state
->reqs
[i
] == NULL
) {
302 state
->reqs
[i
]->async
.fn
= cli_pull_read_done
;
303 state
->reqs
[i
]->async
.priv
= result
;
305 state
->requested
+= request_thistime
;
315 * Handle incoming read replies, push the data into sink and send out new
316 * requests if necessary.
319 static void cli_pull_read_done(struct async_req
*read_req
)
321 struct async_req
*pull_req
= talloc_get_type_abort(
322 read_req
->async
.priv
, struct async_req
);
323 struct cli_pull_state
*state
= talloc_get_type_abort(
324 pull_req
->private_data
, struct cli_pull_state
);
325 struct cli_request
*read_state
= cli_request_get(read_req
);
328 status
= cli_read_andx_recv(read_req
, &read_state
->data
.read
.received
,
329 &read_state
->data
.read
.rcvbuf
);
330 if (!NT_STATUS_IS_OK(status
)) {
331 async_req_error(state
->req
, status
);
336 * This loop is the one to take care of out-of-order replies. All
337 * pending requests are in state->reqs, state->reqs[top_req] is the
338 * one that is to be pushed next. If however a request later than
339 * top_req is replied to, then we can't push yet. If top_req is
340 * replied to at a later point then, we need to push all the finished
344 while (state
->reqs
[state
->top_req
] != NULL
) {
345 struct cli_request
*top_read
;
347 DEBUG(11, ("cli_pull_read_done: top_req = %d\n",
350 if (state
->reqs
[state
->top_req
]->state
< ASYNC_REQ_DONE
) {
351 DEBUG(11, ("cli_pull_read_done: top request not yet "
356 top_read
= cli_request_get(state
->reqs
[state
->top_req
]);
358 DEBUG(10, ("cli_pull_read_done: Pushing %d bytes, %d already "
359 "pushed\n", (int)top_read
->data
.read
.received
,
360 (int)state
->pushed
));
362 status
= state
->sink((char *)top_read
->data
.read
.rcvbuf
,
363 top_read
->data
.read
.received
,
365 if (!NT_STATUS_IS_OK(status
)) {
366 async_req_error(state
->req
, status
);
369 state
->pushed
+= top_read
->data
.read
.received
;
371 TALLOC_FREE(state
->reqs
[state
->top_req
]);
373 if (state
->requested
< state
->size
) {
374 struct async_req
*new_req
;
376 size_t request_thistime
;
378 size_left
= state
->size
- state
->requested
;
379 request_thistime
= MIN(size_left
, state
->chunk_size
);
381 DEBUG(10, ("cli_pull_read_done: Requesting %d bytes "
382 "at %d, position %d\n",
383 (int)request_thistime
,
384 (int)(state
->start_offset
388 new_req
= cli_read_andx_send(
389 state
->reqs
, state
->cli
, state
->fnum
,
390 state
->start_offset
+ state
->requested
,
393 if (async_req_nomem(new_req
, state
->req
)) {
397 new_req
->async
.fn
= cli_pull_read_done
;
398 new_req
->async
.priv
= pull_req
;
400 state
->reqs
[state
->top_req
] = new_req
;
401 state
->requested
+= request_thistime
;
404 state
->top_req
= (state
->top_req
+1) % state
->num_reqs
;
407 async_req_done(pull_req
);
410 NTSTATUS
cli_pull_recv(struct async_req
*req
, SMB_OFF_T
*received
)
412 struct cli_pull_state
*state
= talloc_get_type_abort(
413 req
->private_data
, struct cli_pull_state
);
415 SMB_ASSERT(req
->state
>= ASYNC_REQ_DONE
);
416 if (req
->state
== ASYNC_REQ_ERROR
) {
419 *received
= state
->pushed
;
423 NTSTATUS
cli_pull(struct cli_state
*cli
, uint16_t fnum
,
424 off_t start_offset
, SMB_OFF_T size
, size_t window_size
,
425 NTSTATUS (*sink
)(char *buf
, size_t n
, void *priv
),
426 void *priv
, SMB_OFF_T
*received
)
428 TALLOC_CTX
*frame
= talloc_stackframe();
429 struct async_req
*req
;
430 NTSTATUS result
= NT_STATUS_NO_MEMORY
;
432 if (cli_tmp_event_ctx(frame
, cli
) == NULL
) {
436 req
= cli_pull_send(frame
, cli
, fnum
, start_offset
, size
, window_size
,
442 while (req
->state
< ASYNC_REQ_DONE
) {
443 event_loop_once(cli
->event_ctx
);
446 result
= cli_pull_recv(req
, received
);
452 static NTSTATUS
cli_read_sink(char *buf
, size_t n
, void *priv
)
454 char **pbuf
= (char **)priv
;
455 memcpy(*pbuf
, buf
, n
);
460 ssize_t
cli_read(struct cli_state
*cli
, int fnum
, char *buf
,
461 off_t offset
, size_t size
)
466 status
= cli_pull(cli
, fnum
, offset
, size
, size
,
467 cli_read_sink
, &buf
, &ret
);
468 if (!NT_STATUS_IS_OK(status
)) {
469 cli_set_error(cli
, status
);
475 #if 0 /* relies on client_receive_smb(), now a static in libsmb/clientgen.c */
477 /* This call is INCOMPATIBLE with SMB signing. If you remove the #if 0
478 you must fix ensure you don't attempt to sign the packets - data
479 *will* be currupted */
481 /****************************************************************************
482 Issue a single SMBreadraw and don't wait for a reply.
483 ****************************************************************************/
485 static bool cli_issue_readraw(struct cli_state
*cli
, int fnum
, off_t offset
,
489 if (!cli
->sign_info
.use_smb_signing
) {
490 DEBUG(0, ("Cannot use readraw and SMB Signing\n"));
494 memset(cli
->outbuf
,'\0',smb_size
);
495 memset(cli
->inbuf
,'\0',smb_size
);
497 cli_set_message(cli
->outbuf
,10,0,True
);
499 SCVAL(cli
->outbuf
,smb_com
,SMBreadbraw
);
500 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
501 cli_setup_packet(cli
);
503 SSVAL(cli
->outbuf
,smb_vwv0
,fnum
);
504 SIVAL(cli
->outbuf
,smb_vwv1
,offset
);
505 SSVAL(cli
->outbuf
,smb_vwv2
,size
);
506 SSVAL(cli
->outbuf
,smb_vwv3
,size
);
507 SSVAL(cli
->outbuf
,smb_mid
,cli
->mid
+ i
);
509 return cli_send_smb(cli
);
512 /****************************************************************************
513 Tester for the readraw call.
514 ****************************************************************************/
516 ssize_t
cli_readraw(struct cli_state
*cli
, int fnum
, char *buf
, off_t offset
, size_t size
)
527 * Set readsize to the maximum size we can handle in one readraw.
532 while (total
< size
) {
533 readsize
= MIN(readsize
, size
-total
);
535 /* Issue a read and receive a reply */
537 if (!cli_issue_readraw(cli
, fnum
, offset
, readsize
, 0))
540 if (!client_receive_smb(cli
->fd
, cli
->inbuf
, cli
->timeout
))
543 size2
= smb_len(cli
->inbuf
);
545 if (size2
> readsize
) {
546 DEBUG(5,("server returned more than we wanted!\n"));
548 } else if (size2
< 0) {
549 DEBUG(5,("read return < 0!\n"));
553 /* Copy data into buffer */
557 memcpy(buf
+ total
, p
, size2
);
564 * If the server returned less than we asked for we're at EOF.
567 if (size2
< readsize
)
575 /****************************************************************************
576 Issue a single SMBwrite and don't wait for a reply.
577 ****************************************************************************/
579 static bool cli_issue_write(struct cli_state
*cli
,
588 bool large_writex
= false;
589 /* We can only do direct writes if not signing and not encrypting. */
590 bool direct_writes
= !client_is_signing_on(cli
) && !cli_encryption_on(cli
);
592 if (!direct_writes
&& size
+ 1 > cli
->bufsize
) {
593 cli
->outbuf
= (char *)SMB_REALLOC(cli
->outbuf
, size
+ 1024);
597 cli
->inbuf
= (char *)SMB_REALLOC(cli
->inbuf
, size
+ 1024);
598 if (cli
->inbuf
== NULL
) {
599 SAFE_FREE(cli
->outbuf
);
602 cli
->bufsize
= size
+ 1024;
605 memset(cli
->outbuf
,'\0',smb_size
);
606 memset(cli
->inbuf
,'\0',smb_size
);
608 if (cli
->capabilities
& CAP_LARGE_FILES
) {
613 cli_set_message(cli
->outbuf
,14,0,True
);
615 cli_set_message(cli
->outbuf
,12,0,True
);
618 SCVAL(cli
->outbuf
,smb_com
,SMBwriteX
);
619 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
620 cli_setup_packet(cli
);
622 SCVAL(cli
->outbuf
,smb_vwv0
,0xFF);
623 SSVAL(cli
->outbuf
,smb_vwv2
,fnum
);
625 SIVAL(cli
->outbuf
,smb_vwv3
,offset
);
626 SIVAL(cli
->outbuf
,smb_vwv5
,0);
627 SSVAL(cli
->outbuf
,smb_vwv7
,mode
);
629 SSVAL(cli
->outbuf
,smb_vwv8
,(mode
& 0x0008) ? size
: 0);
631 * According to CIFS-TR-1p00, this following field should only
632 * be set if CAP_LARGE_WRITEX is set. We should check this
633 * locally. However, this check might already have been
634 * done by our callers.
636 SSVAL(cli
->outbuf
,smb_vwv9
,(size
>>16));
637 SSVAL(cli
->outbuf
,smb_vwv10
,size
);
638 /* +1 is pad byte. */
639 SSVAL(cli
->outbuf
,smb_vwv11
,
640 smb_buf(cli
->outbuf
) - smb_base(cli
->outbuf
) + 1);
643 SIVAL(cli
->outbuf
,smb_vwv12
,(((SMB_BIG_UINT
)offset
)>>32) & 0xffffffff);
646 p
= smb_base(cli
->outbuf
) + SVAL(cli
->outbuf
,smb_vwv11
) -1;
647 *p
++ = '\0'; /* pad byte. */
648 if (!direct_writes
) {
649 memcpy(p
, buf
, size
);
651 if (size
> 0x1FFFF) {
652 /* This is a POSIX 14 word large write. */
653 set_message_bcc(cli
->outbuf
, 0); /* Set bcc to zero. */
654 _smb_setlen_large(cli
->outbuf
,smb_size
+ 28 + 1 /* pad */ + size
- 4);
656 cli_setup_bcc(cli
, p
+size
);
659 SSVAL(cli
->outbuf
,smb_mid
,cli
->mid
+ i
);
661 show_msg(cli
->outbuf
);
663 /* For direct writes we now need to write the data
664 * directly out of buf. */
665 return cli_send_smb_direct_writeX(cli
, buf
, size
);
667 return cli_send_smb(cli
);
671 /****************************************************************************
673 write_mode: 0x0001 disallow write cacheing
674 0x0002 return bytes remaining
675 0x0004 use raw named pipe protocol
676 0x0008 start of message mode named pipe protocol
677 ****************************************************************************/
679 ssize_t
cli_write(struct cli_state
*cli
,
680 int fnum
, uint16 write_mode
,
681 const char *buf
, off_t offset
, size_t size
)
683 ssize_t bwritten
= 0;
684 unsigned int issued
= 0;
685 unsigned int received
= 0;
690 if(cli
->max_mux
> 1) {
691 mpx
= cli
->max_mux
-1;
696 /* Default (small) writesize. */
697 writesize
= (cli
->max_xmit
- (smb_size
+32)) & ~1023;
699 if (write_mode
== 0 &&
700 !client_is_signing_on(cli
) &&
701 !cli_encryption_on(cli
) &&
702 (cli
->posix_capabilities
& CIFS_UNIX_LARGE_WRITE_CAP
) &&
703 (cli
->capabilities
& CAP_LARGE_FILES
)) {
704 /* Only do massive writes if we can do them direct
705 * with no signing or encrypting - not on a pipe. */
706 writesize
= CLI_SAMBA_MAX_POSIX_LARGE_WRITEX_SIZE
;
707 } else if (cli
->capabilities
& CAP_LARGE_WRITEX
) {
709 writesize
= CLI_SAMBA_MAX_LARGE_WRITEX_SIZE
;
710 } else if (!client_is_signing_on(cli
)) {
711 /* Windows restricts signed writes to max_xmit.
712 * Found by Volker. */
713 writesize
= CLI_WINDOWS_MAX_LARGE_WRITEX_SIZE
;
717 blocks
= (size
+ (writesize
-1)) / writesize
;
719 while (received
< blocks
) {
721 while ((issued
- received
< mpx
) && (issued
< blocks
)) {
722 ssize_t bsent
= issued
* writesize
;
723 ssize_t size1
= MIN(writesize
, size
- bsent
);
725 if (!cli_issue_write(cli
, fnum
, offset
+ bsent
,
733 if (!cli_receive_smb(cli
)) {
739 if (cli_is_error(cli
))
742 bwritten
+= SVAL(cli
->inbuf
, smb_vwv2
);
743 if (writesize
> 0xFFFF) {
744 bwritten
+= (((int)(SVAL(cli
->inbuf
, smb_vwv4
)))<<16);
748 while (received
< issued
&& cli_receive_smb(cli
)) {
755 /****************************************************************************
756 write to a file using a SMBwrite and not bypassing 0 byte writes
757 ****************************************************************************/
759 ssize_t
cli_smbwrite(struct cli_state
*cli
,
760 int fnum
, char *buf
, off_t offset
, size_t size1
)
766 size_t size
= MIN(size1
, cli
->max_xmit
- 48);
768 memset(cli
->outbuf
,'\0',smb_size
);
769 memset(cli
->inbuf
,'\0',smb_size
);
771 cli_set_message(cli
->outbuf
,5, 0,True
);
773 SCVAL(cli
->outbuf
,smb_com
,SMBwrite
);
774 SSVAL(cli
->outbuf
,smb_tid
,cli
->cnum
);
775 cli_setup_packet(cli
);
777 SSVAL(cli
->outbuf
,smb_vwv0
,fnum
);
778 SSVAL(cli
->outbuf
,smb_vwv1
,size
);
779 SIVAL(cli
->outbuf
,smb_vwv2
,offset
);
780 SSVAL(cli
->outbuf
,smb_vwv4
,0);
782 p
= smb_buf(cli
->outbuf
);
784 SSVAL(p
, 0, size
); p
+= 2;
785 memcpy(p
, buf
+ total
, size
); p
+= size
;
787 cli_setup_bcc(cli
, p
);
789 if (!cli_send_smb(cli
))
792 if (!cli_receive_smb(cli
))
795 if (cli_is_error(cli
))
798 size
= SVAL(cli
->inbuf
,smb_vwv0
);