]>
git.ipfire.org Git - thirdparty/rsync.git/blob - io.c
2 Copyright (C) Andrew Tridgell 1996
3 Copyright (C) Paul Mackerras 1996
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 Utilities used in rsync
27 static int64 total_written
;
28 static int64 total_read
;
31 extern int sparse_files
;
32 extern int io_timeout
;
34 int64
write_total(void)
39 int64
read_total(void)
44 static int buffer_f_in
= -1;
46 void setup_nonblocking(int f_in
,int f_out
)
48 set_blocking(f_out
,0);
53 static char *read_buffer
;
54 static char *read_buffer_p
;
55 static int read_buffer_len
;
56 static int read_buffer_size
;
59 /* This function was added to overcome a deadlock problem when using
60 * ssh. It looks like we can't allow our receive queue to get full or
61 * ssh will clag up. Uggh. */
62 static void read_check(int f
)
68 if (read_buffer_len
== 0) {
69 read_buffer_p
= read_buffer
;
72 if ((n
=num_waiting(f
)) <= 0)
75 /* things could deteriorate if we read in really small chunks */
78 if (read_buffer_p
!= read_buffer
) {
79 memmove(read_buffer
,read_buffer_p
,read_buffer_len
);
80 read_buffer_p
= read_buffer
;
83 if (n
> (read_buffer_size
- read_buffer_len
)) {
84 read_buffer_size
+= n
;
86 read_buffer
= (char *)malloc(read_buffer_size
);
88 read_buffer
= (char *)realloc(read_buffer
,read_buffer_size
);
89 if (!read_buffer
) out_of_memory("read check");
90 read_buffer_p
= read_buffer
;
93 n
= read(f
,read_buffer
+read_buffer_len
,n
);
99 static time_t last_io
;
102 static void check_timeout(void)
106 if (!io_timeout
) return;
109 last_io
= time(NULL
);
115 if (last_io
&& io_timeout
&& (t
-last_io
)>io_timeout
) {
116 rprintf(FERROR
,"read timeout after %d second - exiting\n",
122 static int readfd(int fd
,char *buffer
,int N
)
128 if (read_buffer_len
< N
)
129 read_check(buffer_f_in
);
132 if (read_buffer_len
> 0 && buffer_f_in
== fd
) {
133 ret
= MIN(read_buffer_len
,N
-total
);
134 memcpy(buffer
+total
,read_buffer_p
,ret
);
135 read_buffer_p
+= ret
;
136 read_buffer_len
-= ret
;
141 while ((ret
= read(fd
,buffer
+ total
,N
-total
)) == -1) {
144 if (errno
!= EAGAIN
&& errno
!= EWOULDBLOCK
)
148 tv
.tv_sec
= io_timeout
;
151 if (select(fd
+1, &fds
, NULL
, NULL
, &tv
) != 1) {
162 last_io
= time(NULL
);
167 int32
read_int(int f
)
171 if ((ret
=readfd(f
,b
,4)) != 4) {
173 rprintf(FERROR
,"(%d) Error reading %d bytes : %s\n",
174 getpid(),4,ret
==-1?strerror(errno
):"EOF");
181 int64
read_longint(int f
)
183 extern int remote_version
;
188 if ((int32
)ret
!= (int32
)0xffffffff) return ret
;
191 rprintf(FERROR
,"Integer overflow - attempted 64 bit offset\n");
194 if (remote_version
>= 16) {
195 if ((ret
=readfd(f
,b
,8)) != 8) {
197 rprintf(FERROR
,"(%d) Error reading %d bytes : %s\n",
198 getpid(),8,ret
==-1?strerror(errno
):"EOF");
202 ret
= IVAL(b
,0) | (((int64
)IVAL(b
,4))<<32);
209 void read_buf(int f
,char *buf
,int len
)
212 if ((ret
=readfd(f
,buf
,len
)) != len
) {
214 rprintf(FERROR
,"(%d) Error reading %d bytes : %s\n",
215 getpid(),len
,ret
==-1?strerror(errno
):"EOF");
221 void read_sbuf(int f
,char *buf
,int len
)
227 unsigned char read_byte(int f
)
230 read_buf(f
,(char *)&c
,1);
235 static char last_byte
;
236 static int last_sparse
;
238 int sparse_end(int f
)
241 do_lseek(f
,-1,SEEK_CUR
);
242 return (write(f
,&last_byte
,1) == 1 ? 0 : -1);
249 static int write_sparse(int f
,char *buf
,int len
)
254 for (l1
=0;l1
<len
&& buf
[l1
]==0;l1
++) ;
255 for (l2
=0;l2
<(len
-l1
) && buf
[len
-(l2
+1)]==0;l2
++) ;
257 last_byte
= buf
[len
-1];
259 if (l1
== len
|| l2
> 0)
263 do_lseek(f
,l1
,SEEK_CUR
);
268 if ((ret
=write(f
,buf
+l1
,len
-(l1
+l2
))) != len
-(l1
+l2
)) {
269 if (ret
== -1 || ret
== 0) return ret
;
274 do_lseek(f
,l2
,SEEK_CUR
);
281 int write_file(int f
,char *buf
,int len
)
286 return write(f
,buf
,len
);
289 int len1
= MIN(len
, SPARSE_WRITE_SIZE
);
290 int r1
= write_sparse(f
, buf
, len1
);
292 if (ret
> 0) return ret
;
303 static int writefd(int fd
,char *buf
,int len
)
307 int fd_count
, count
, got_select
=0;
310 if (buffer_f_in
== -1)
311 return write(fd
,buf
,len
);
313 while (total
< len
) {
314 int ret
= write(fd
,buf
+total
,len
-total
);
316 if (ret
== 0) return total
;
318 if (ret
== -1 && !(errno
== EWOULDBLOCK
|| errno
== EAGAIN
))
321 if (ret
== -1 && got_select
) {
322 /* hmmm, we got a write select on the fd and then failed to write.
323 Why doesn't that mean that the fd is dead? It doesn't on some
324 systems it seems (eg. IRIX) */
327 rprintf(FERROR
,"write exception\n");
336 read_check(buffer_f_in
);
342 if (buffer_f_in
!= -1) {
343 FD_SET(buffer_f_in
,&r_fds
);
344 if (buffer_f_in
> fd
)
345 fd_count
= buffer_f_in
+1;
348 tv
.tv_sec
= BLOCKING_TIMEOUT
;
350 count
= select(fd_count
,buffer_f_in
== -1? NULL
: &r_fds
,
352 if (count
== -1 && errno
!= EINTR
) {
354 rprintf(FERROR
,"select error: %s\n", strerror(errno
));
363 if (FD_ISSET(fd
, &w_fds
)) {
372 last_io
= time(NULL
);
379 void write_int(int f
,int32 x
)
384 if ((ret
=writefd(f
,b
,4)) != 4) {
385 rprintf(FERROR
,"write_int failed : %s\n",
386 ret
==-1?strerror(errno
):"EOF");
392 void write_longint(int f
, int64 x
)
394 extern int remote_version
;
398 if (remote_version
< 16 || x
<= 0x7FFFFFFF) {
399 write_int(f
, (int)x
);
404 SIVAL(b
,0,(x
&0xFFFFFFFF));
405 SIVAL(b
,4,((x
>>32)&0xFFFFFFFF));
407 if ((ret
=writefd(f
,b
,8)) != 8) {
408 rprintf(FERROR
,"write_longint failed : %s\n",
409 ret
==-1?strerror(errno
):"EOF");
415 void write_buf(int f
,char *buf
,int len
)
418 if ((ret
=writefd(f
,buf
,len
)) != len
) {
419 rprintf(FERROR
,"write_buf failed : %s\n",
420 ret
==-1?strerror(errno
):"EOF");
423 total_written
+= len
;
426 /* write a string to the connection */
427 void write_sbuf(int f
,char *buf
)
429 write_buf(f
, buf
, strlen(buf
));
433 void write_byte(int f
,unsigned char c
)
435 write_buf(f
,(char *)&c
,1);
438 void write_flush(int f
)
443 int read_line(int f
, char *buf
, int maxlen
)
447 if (buf
[0] == '\n') {
451 if (buf
[0] != '\r') {
464 void io_printf(int fd
, const char *format
, ...)
470 va_start(ap
, format
);
473 len
= vsnprintf(buf
, sizeof(buf
)-1, format
, ap
);
475 len
= vsprintf(buf
, format
, ap
);
479 if (len
< 0) exit_cleanup(1);