exit_cleanup(RERR_STREAMIO);
}
-
/**
* Read from a socket with I/O timeout. return the number of bytes
* read. If no bytes can be read then exit, never return a number <= 0.
*/
static int read_timeout(int fd, char *buf, size_t len)
{
- int n, ret = 0;
+ int n, cnt = 0;
io_flush(NORMAL_FLUSH);
- while (ret == 0) {
+ while (cnt == 0) {
/* until we manage to read *something* */
fd_set r_fds, w_fds;
struct timeval tv;
buf += n;
len -= n;
- ret += n;
+ cnt += n;
if (fd == sock_f_in && io_timeout)
last_io_in = time(NULL);
}
- return ret;
+ return cnt;
}
/**
return s - fname;
}
-
static char *iobuf_out;
static int iobuf_out_cnt;
iobuf_out_cnt = 0;
}
-
static char *iobuf_in;
static size_t iobuf_in_siz;
out_of_memory("io_start_buffering_in");
}
-
void io_end_buffering(void)
{
io_flush(NORMAL_FLUSH);
}
}
-
void maybe_flush_socket(void)
{
if (iobuf_out && iobuf_out_cnt && time(NULL) - last_io_out >= 5)
io_flush(NORMAL_FLUSH);
}
-
void maybe_send_keepalive(void)
{
if (time(NULL) - last_io_out >= allowed_lull) {
}
}
-
/**
* Continue trying to read len bytes - don't return until len has been
* read.
}
}
-
/**
* Read from the file descriptor handling multiplexing - return number
* of bytes read.
static size_t remaining;
static size_t iobuf_in_ndx;
size_t msg_bytes;
- int tag, ret = 0;
+ int tag, cnt = 0;
char line[BIGPATHBUFLEN];
if (!iobuf_in || fd != sock_f_in)
iobuf_in_ndx = 0;
}
- while (ret == 0) {
+ while (cnt == 0) {
if (remaining) {
len = MIN(len, remaining);
memcpy(buf, iobuf_in + iobuf_in_ndx, len);
iobuf_in_ndx += len;
remaining -= len;
- ret = len;
+ cnt = len;
break;
}
if (remaining == 0)
io_flush(NORMAL_FLUSH);
- return ret;
+ return cnt;
}
-
-
/**
* Do a buffered read from @p fd. Don't return until all @p n bytes
* have been read. If all @p n can't be read then exit with an
**/
static void readfd(int fd, char *buffer, size_t N)
{
- int ret;
+ int cnt;
size_t total = 0;
while (total < N) {
- ret = readfd_unbuffered(fd, buffer + total, N-total);
- total += ret;
+ cnt = readfd_unbuffered(fd, buffer + total, N-total);
+ total += cnt;
}
if (fd == write_batch_monitor_in) {
stats.total_read += total;
}
-
int read_shortint(int f)
{
uchar b[2];
return (b[1] << 8) + b[0];
}
-
int32 read_int(int f)
{
char b[4];
- int32 ret;
+ int32 num;
readfd(f,b,4);
- ret = IVAL(b,0);
- if (ret == (int32)0xffffffff)
+ num = IVAL(b,0);
+ if (num == (int32)0xffffffff)
return -1;
- return ret;
+ return num;
}
int64 read_longint(int f)
{
- int64 ret;
+ int64 num;
char b[8];
- ret = read_int(f);
+ num = read_int(f);
- if ((int32)ret != (int32)0xffffffff)
- return ret;
+ if ((int32)num != (int32)0xffffffff)
+ return num;
#if SIZEOF_INT64 < 8
rprintf(FERROR, "Integer overflow: attempted 64-bit offset\n");
exit_cleanup(RERR_UNSUPPORTED);
#else
readfd(f,b,8);
- ret = IVAL(b,0) | (((int64)IVAL(b,4))<<32);
+ num = IVAL(b,0) | (((int64)IVAL(b,4))<<32);
#endif
- return ret;
+ return num;
}
void read_buf(int f,char *buf,size_t len)
write_int(f, sum->remainder);
}
-
/**
* Sleep after writing to limit I/O bandwidth usage.
*
total_written = (sleep_usec - elapsed_usec) * bwlimit / (ONE_SEC/1024);
}
-
/* Write len bytes to the file descriptor fd, looping as necessary to get
* the job done and also (in certain circumstances) reading any data on
* msg_fd_in to avoid deadlock.
{
size_t n, total = 0;
fd_set w_fds, r_fds;
- int maxfd, count, ret, using_r_fds;
+ int maxfd, count, cnt, using_r_fds;
struct timeval tv;
no_flush++;
n = len - total;
if (bwlimit && n > bwlimit_writemax)
n = bwlimit_writemax;
- ret = write(fd, buf + total, n);
+ cnt = write(fd, buf + total, n);
- if (ret <= 0) {
- if (ret < 0) {
+ if (cnt <= 0) {
+ if (cnt < 0) {
if (errno == EINTR)
continue;
if (errno == EWOULDBLOCK || errno == EAGAIN) {
exit_cleanup(RERR_STREAMIO);
}
- total += ret;
+ total += cnt;
if (fd == sock_f_out) {
if (io_timeout || am_generator)
last_io_out = time(NULL);
- sleep_for_bwlimit(ret);
+ sleep_for_bwlimit(cnt);
}
}
no_flush--;
}
-
/**
* Write an message to a multiplexed stream. If this fails then rsync
* exits.
contiguous_write_len = 0;
}
-
void io_flush(int flush_it_all)
{
msg_list_flush(flush_it_all);
iobuf_out_cnt = 0;
}
-
static void writefd(int fd,char *buf,size_t len)
{
if (fd == msg_fd_out) {
}
}
-
void write_shortint(int f, int x)
{
uchar b[2];
writefd(f, (char *)b, 2);
}
-
void write_int(int f,int32 x)
{
char b[4];
writefd(f,b,4);
}
-
void write_int_named(int f, int32 x, const char *phase)
{
io_write_phase = phase;
io_write_phase = phase_unknown;
}
-
/*
* Note: int64 may actually be a 32-bit type if ./configure couldn't find any
* 64-bit types on this platform.
writefd(f, str, len);
}
-
/**
* Read a line of up to @p maxlen characters into @p buf (not counting
* the trailing null). Strips the (required) trailing newline and all
return maxlen > 0;
}
-
void io_printf(int fd, const char *format, ...)
{
va_list ap;
write_sbuf(fd, buf);
}
-
/** Setup for multiplexing a MSG_* stream with the data stream. */
void io_start_multiplex_out(void)
{
Matt McCutchen's Web Site / rsync / rsync.git / commitdiff