---

io.c File Reference

Socket and pipe IO utilities used in rsync. More...

Go to the source code of this file.

Functions
void	read_loop (int fd, char *buf, size_t len)
	Continue trying to read len bytes - don't return until len has been read. More...
void	check_timeout (void)
void	io_set_error_fd (int fd)
	Setup the fd used to propagate errors. More...
void	read_error_fd (void)
	Read some data from the error fd and write it to the write log code. More...
void	whine_about_eof (void)
	It's almost always an error to get an EOF when we're trying to read from the network, because the protocol is self-terminating. More...
void	die_from_readerr (int err)
int	read_timeout (int fd, char *buf, size_t len)
	Read from a socket with IO timeout. More...
int	read_unbuffered (int fd, char *buf, size_t len)
	Read from the file descriptor handling multiplexing - return number of bytes read. More...
void	readfd (int fd, char *buffer, size_t N)
	Do a buffered read from fd. More...
int32	read_int (int f)
int64	read_longint (int f)
void	read_buf (int f, char *buf, size_t len)
void	read_sbuf (int f, char *buf, size_t len)
unsigned char	read_byte (int f)
void	sleep_for_bwlimit (int bytes_written)
	Sleep after writing to limit I/O bandwidth usage. More...
void	writefd_unbuffered (int fd, char *buf, size_t len)
	Write len bytes to the file descriptor fd. More...
void	io_start_buffering (int fd)
void	mplex_write (int fd, enum logcode code, char *buf, size_t len)
	Write an message to a multiplexed stream. More...
void	io_flush (void)
void	io_end_buffering (void)
void	writefd (int fd, char *buf, size_t len)
void	write_int (int f, int32 x)
void	write_int_named (int f, int32 x, const char *phase)
void	write_longint (int f, int64 x)
void	write_buf (int f, char *buf, size_t len)
void	write_sbuf (int f, char *buf)
	Write a string to the connection. More...
void	write_byte (int f, unsigned char c)
int	read_line (int f, char *buf, size_t maxlen)
	Read a line of up to maxlen characters into buf. More...
void	io_printf (int fd, const char *format,...)
void	io_start_multiplex_out (int fd)
	Setup for multiplexing an error stream with the data stream. More...
void	io_start_multiplex_in (int fd)
	Setup for multiplexing an error stream with the data stream. More...
int	io_multiplex_write (enum logcode code, char *buf, size_t len)
	Write an message to the multiplexed error stream. More...
void	io_multiplexing_close (void)
	Stop output multiplexing. More...
Variables
int	io_multiplexing_out
int	io_multiplexing_in
int	multiplex_in_fd
int	multiplex_out_fd
time_t	last_io
int	no_flush
int	bwlimit
int	verbose
int	io_timeout
stats	stats
const char	phase_unknown [] = "unknown"
const char *	io_write_phase = phase_unknown
	The connection might be dropped at some point; perhaps because the remote instance crashed. More...
const char *	io_read_phase = phase_unknown
int	kludge_around_eof = False
	Ignore EOF errors while reading a module listing if the remote version is 24 or less. More...
int	io_error_fd = -1
char *	io_buffer
int	io_buffer_count

---

Detailed Description

Socket and pipe IO utilities used in rsync.

rsync provides its own multiplexing system, which is used to send stderr and stdout over a single socket. We need this because stdout normally carries the binary data stream, and stderr all our error messages.

For historical reasons this is off during the start of the connection, but it's switched on quite early using io_start_multiplex_out() and io_start_multiplex_in().

Definition in file io.c.

---

Function Documentation

void read_loop (  int    fd, char *    buf, size_t    len )  [static]

Continue trying to read len bytes - don't return until len has been read. Definition at line 267 of file io.c. References read_timeout(). Referenced by read_error_fd(), and read_unbuffered(). { while (len) { int n = read_timeout(fd, buf, len); buf += n; len -= n; } }

void check_timeout (  void    )  [static]

Definition at line 82 of file io.c. References am_daemon, err_list_push(), FERROR, io_timeout, last_io, and rprintf(). Referenced by read_timeout(), and writefd_unbuffered(). { extern int am_server, am_daemon; time_t t; err_list_push(); if (!io_timeout) return; if (!last_io) { last_io = time(NULL); return; } t = time(NULL); if (last_io && io_timeout && (t-last_io) >= io_timeout) { if (!am_server && !am_daemon) { rprintf(FERROR,"io timeout after %d seconds - exiting\n", (int)(t-last_io)); } exit_cleanup(RERR_TIMEOUT); } }

void io_set_error_fd (  int    fd )

Setup the fd used to propagate errors. Definition at line 108 of file io.c. References io_error_fd. Referenced by do_recv(). { io_error_fd = fd; }

void read_error_fd (  void    )  [static]

Read some data from the error fd and write it to the write log code. Definition at line 114 of file io.c. References io_error_fd, logcode, read_loop(), rwrite(), and tag. Referenced by read_timeout(), and writefd_unbuffered(). { char buf[200]; size_t n; int fd = io_error_fd; int tag, len; /* io_error_fd is temporarily disabled -- is this meant to * prevent indefinite recursion? */ io_error_fd = -1; read_loop(fd, buf, 4); tag = IVAL(buf, 0); len = tag & 0xFFFFFF; tag = tag >> 24; tag -= MPLEX_BASE; while (len) { n = len; if (n > (sizeof(buf)-1)) n = sizeof(buf)-1; read_loop(fd, buf, n); rwrite((enum logcode)tag, buf, n); len -= n; } io_error_fd = fd; }

void whine_about_eof (  void    )  [static]

It's almost always an error to get an EOF when we're trying to read from the network, because the protocol is self-terminating. However, there is one unfortunate cases where it is not, which is rsync <2.4.6 sending a list of modules on a server, since the list is terminated by closing the socket. So, for the section of the program where that is a problem (start_socket_client), kludge_around_eof is True and we just exit. Definition at line 155 of file io.c. References FERROR, rprintf(), and stats::total_read. Referenced by read_timeout(). { if (kludge_around_eof) exit_cleanup (0); else { rprintf (FERROR, "%s: connection unexpectedly closed " "(%.0f bytes read so far)\n", RSYNC_NAME, (double)stats.total_read); exit_cleanup (RERR_STREAMIO); } }

void die_from_readerr (  int    err )  [static]

Definition at line 170 of file io.c. References FERROR, io_multiplexing_close(), and rprintf(). Referenced by read_timeout(). { /* this prevents us trying to write errors on a dead socket */ io_multiplexing_close(); rprintf(FERROR, "%s: read error: %s\n", RSYNC_NAME, strerror (err)); exit_cleanup(RERR_STREAMIO); }

int read_timeout (  int    fd, char *    buf, size_t    len )  [static]

Read from a socket with IO timeout. return the number of bytes read. If no bytes can be read then exit, never return a number <= 0. TODO: If the remote shell connection fails, then current versions actually report an "unexpected EOF" error here. Since it's a fairly common mistake to try to use rsh when ssh is required, we should trap that: if we fail to read any data at all, we should give a better explanation. We can tell whether the connection has started by looking e.g. at whether the remote version is known yet. Definition at line 192 of file io.c. References check_timeout(), die_from_readerr(), io_error_fd, io_flush(), io_timeout, last_io, read_error_fd(), and whine_about_eof(). Referenced by read_loop(), and read_unbuffered(). { int n, ret=0; io_flush(); while (ret == 0) { /* until we manage to read *something* */ fd_set fds; struct timeval tv; int fd_count = fd+1; int count; FD_ZERO(&fds); FD_SET(fd, &fds); if (io_error_fd != -1) { FD_SET(io_error_fd, &fds); if (io_error_fd > fd) fd_count = io_error_fd+1; } tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT; tv.tv_usec = 0; errno = 0; count = select(fd_count, &fds, NULL, NULL, &tv); if (count == 0) { check_timeout(); } if (count <= 0) { if (errno == EBADF) { exit_cleanup(RERR_SOCKETIO); } continue; } if (io_error_fd != -1 && FD_ISSET(io_error_fd, &fds)) { read_error_fd(); } if (!FD_ISSET(fd, &fds)) continue; n = read(fd, buf, len); if (n > 0) { buf += n; len -= n; ret += n; if (io_timeout) last_io = time(NULL); continue; } else if (n == 0) { whine_about_eof (); return -1; /* doesn't return */ } else if (n == -1) { if (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN) continue; else die_from_readerr (errno); } } return ret; }

int read_unbuffered (  int    fd, char *    buf, size_t    len )  [static]

Read from the file descriptor handling multiplexing - return number of bytes read. Never returns <= 0. Definition at line 284 of file io.c. References FERROR, FINFO, io_multiplexing_in, logcode, multiplex_in_fd, read_loop(), read_timeout(), rprintf(), and tag. Referenced by readfd(). { static size_t remaining; int tag, ret = 0; char line[1024]; if (!io_multiplexing_in || fd != multiplex_in_fd) return read_timeout(fd, buf, len); while (ret == 0) { if (remaining) { len = MIN(len, remaining); read_loop(fd, buf, len); remaining -= len; ret = len; continue; } read_loop(fd, line, 4); tag = IVAL(line, 0); remaining = tag & 0xFFFFFF; tag = tag >> 24; if (tag == MPLEX_BASE) continue; tag -= MPLEX_BASE; if (tag != FERROR && tag != FINFO) { rprintf(FERROR, "unexpected tag %d\n", tag); exit_cleanup(RERR_STREAMIO); } if (remaining > sizeof(line) - 1) { rprintf(FERROR, "multiplexing overflow %d\n\n", remaining); exit_cleanup(RERR_STREAMIO); } read_loop(fd, line, remaining); line[remaining] = 0; rprintf((enum logcode) tag, "%s", line); remaining = 0; } return ret; }

void readfd (  int    fd, char *    buffer, size_t    N )  [static]

Do a buffered read from fd. Don't return until all n bytes have been read. If all n can't be read then exit with an error. Definition at line 341 of file io.c. References io_flush(), read_unbuffered(), and stats::total_read. Referenced by read_buf(), read_int(), and read_longint(). { int ret; size_t total=0; while (total < N) { io_flush(); ret = read_unbuffered (fd, buffer + total, N-total); total += ret; } stats.total_read += total; }

int32 read_int (  int    f )

Definition at line 357 of file io.c. References readfd(). Referenced by client_run(), do_recv(), do_server_sender(), generate_files(), read_longint(), receive_data(), receive_file_entry(), receive_sums(), recv_deflated_token(), recv_exclude_list(), recv_file_list(), recv_files(), recv_uid_list(), send_files(), setup_protocol(), and simple_recv_token(). { char b[4]; int32 ret; readfd(f,b,4); ret = IVAL(b,0); if (ret == (int32)0xffffffff) return -1; return ret; }

int64 read_longint (  int    f )

Definition at line 368 of file io.c. References FERROR, read_int(), readfd(), and rprintf(). Referenced by receive_file_entry(), and report(). { extern int remote_version; int64 ret; char b[8]; ret = read_int(f); if ((int32)ret != (int32)0xffffffff) { return ret; } #ifdef NO_INT64 rprintf(FERROR,"Integer overflow - attempted 64 bit offset\n"); exit_cleanup(RERR_UNSUPPORTED); #else if (remote_version >= 16) { readfd(f,b,8); ret = IVAL(b,0) | (((int64)IVAL(b,4))<<32); } #endif return ret; }

void read_buf (  int    f, char *    buf, size_t    len )

Definition at line 392 of file io.c. References readfd(). Referenced by read_byte(), read_line(), read_sbuf(), receive_data(), receive_file_entry(), receive_sums(), recv_deflated_token(), and simple_recv_token(). { readfd(f,buf,len); }

void read_sbuf (  int    f, char *    buf, size_t    len )

Definition at line 397 of file io.c. References read_buf(). Referenced by receive_file_entry(), recv_exclude_list(), and recv_uid_list(). { read_buf (f,buf,len); buf[len] = 0; }

unsigned char read_byte (  int    f )

Definition at line 403 of file io.c. References read_buf(). Referenced by receive_file_entry(), recv_deflated_token(), recv_file_list(), and recv_uid_list(). { unsigned char c; read_buf (f, (char *)&c, 1); return c; }

void sleep_for_bwlimit (  int    bytes_written )  [static]

Sleep after writing to limit I/O bandwidth usage. Todo: Rather than sleeping after each write, it might be better to use some kind of averaging. The current algorithm seems to always use a bit less bandwidth than specified, because it doesn't make up for slow periods. But arguably this is a feature. In addition, we ought to take the time used to write the data into account. Definition at line 420 of file io.c. References bwlimit. Referenced by writefd_unbuffered(). { struct timeval tv; if (!bwlimit) return; assert(bytes_written > 0); assert(bwlimit > 0); tv.tv_usec = bytes_written * 1000 / bwlimit; tv.tv_sec = tv.tv_usec / 1000000; tv.tv_usec = tv.tv_usec % 1000000; select(0, NULL, NULL, NULL, &tv); }

void writefd_unbuffered (  int    fd, char *    buf, size_t    len )  [static]

Write len bytes to the file descriptor fd. This function underlies the multiplexing system. The body of the application never calls this function directly. Definition at line 444 of file io.c. References check_timeout(), err_list_push(), FERROR, io_error_fd, io_multiplexing_close(), io_timeout, io_write_phase, last_io, msleep(), no_flush, read_error_fd(), rprintf(), and sleep_for_bwlimit(). Referenced by io_flush(), mplex_write(), and writefd(). { size_t total = 0; fd_set w_fds, r_fds; int fd_count, count; struct timeval tv; err_list_push(); no_flush++; while (total < len) { FD_ZERO(&w_fds); FD_ZERO(&r_fds); FD_SET(fd,&w_fds); fd_count = fd; if (io_error_fd != -1) { FD_SET(io_error_fd,&r_fds); if (io_error_fd > fd_count) fd_count = io_error_fd; } tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT; tv.tv_usec = 0; errno = 0; count = select(fd_count+1, io_error_fd != -1?&r_fds:NULL, &w_fds,NULL, &tv); if (count == 0) { check_timeout(); } if (count <= 0) { if (errno == EBADF) { exit_cleanup(RERR_SOCKETIO); } continue; } if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) { read_error_fd(); } if (FD_ISSET(fd, &w_fds)) { int ret; size_t n = len-total; ret = write(fd,buf+total,n); if (ret == -1 && errno == EINTR) { continue; } if (ret == -1 && (errno == EWOULDBLOCK || errno == EAGAIN)) { msleep(1); continue; } if (ret <= 0) { /* Don't try to write errors back * across the stream */ io_multiplexing_close(); rprintf(FERROR, RSYNC_NAME ": writefd_unbuffered failed to write %ld bytes: phase \"%s\": %s\n", (long) len, io_write_phase, strerror(errno)); exit_cleanup(RERR_STREAMIO); } sleep_for_bwlimit(ret); total += ret; if (io_timeout) last_io = time(NULL); } } no_flush--; }

void io_start_buffering (  int    fd )

Definition at line 534 of file io.c. References io_buffer, io_buffer_count, multiplex_out_fd, and out_of_memory(). Referenced by do_recv(), io_start_multiplex_out(), and send_file_list(). { if (io_buffer) return; multiplex_out_fd = fd; io_buffer = (char *)malloc(IO_BUFFER_SIZE); if (!io_buffer) out_of_memory("writefd"); io_buffer_count = 0; }

void mplex_write (  int    fd, enum logcode    code, char *    buf, size_t    len )  [static]

Write an message to a multiplexed stream. If this fails then rsync exits. Definition at line 547 of file io.c. References code, logcode, and writefd_unbuffered(). Referenced by io_flush(), and io_multiplex_write(). { char buffer[4096]; size_t n = len; SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len); if (n > (sizeof(buffer)-4)) { n = sizeof(buffer)-4; } memcpy(&buffer[4], buf, n); writefd_unbuffered(fd, buffer, n+4); len -= n; buf += n; if (len) { writefd_unbuffered(fd, buf, len); } }

void io_flush (  void    )

Definition at line 570 of file io.c. References err_list_push(), FNONE, io_buffer, io_buffer_count, mplex_write(), multiplex_out_fd, no_flush, and writefd_unbuffered(). Referenced by _exit_cleanup(), client_run(), do_recv(), do_server_sender(), io_end_buffering(), io_multiplex_write(), io_start_multiplex_in(), io_start_multiplex_out(), read_timeout(), readfd(), wait_process(), and writefd(). { int fd = multiplex_out_fd; err_list_push(); if (!io_buffer_count || no_flush) return; if (io_multiplexing_out) { mplex_write(fd, FNONE, io_buffer, io_buffer_count); } else { writefd_unbuffered(fd, io_buffer, io_buffer_count); } io_buffer_count = 0; }

void io_end_buffering (  void    )

Definition at line 587 of file io.c. References io_buffer, io_flush(), and io_multiplexing_out. Referenced by send_file_list(). { io_flush(); if (!io_multiplexing_out) { free(io_buffer); io_buffer = NULL; } }

void writefd (  int    fd, char *    buf, size_t    len )  [static]

Definition at line 596 of file io.c. References err_list_push(), io_buffer, io_buffer_count, io_flush(), multiplex_out_fd, stats::total_written, and writefd_unbuffered(). Referenced by write_buf(), write_int(), and write_longint(). { stats.total_written += len; err_list_push(); if (!io_buffer || fd != multiplex_out_fd) { writefd_unbuffered(fd, buf, len); return; } while (len) { int n = MIN((int) len, IO_BUFFER_SIZE-io_buffer_count); if (n > 0) { memcpy(io_buffer+io_buffer_count, buf, n); buf += n; len -= n; io_buffer_count += n; } if (io_buffer_count == IO_BUFFER_SIZE) io_flush(); } }

void write_int (  int    f, int32    x )

Definition at line 621 of file io.c. References writefd(). Referenced by do_recv(), generate_files(), recv_files(), recv_generator(), send_deflated_token(), send_exclude_list(), send_file_entry(), send_file_list(), send_files(), send_sums(), send_uid_list(), setup_protocol(), simple_send_token(), write_int_named(), and write_longint(). { char b[4]; SIVAL(b,0,x); writefd(f,b,4); }

void write_int_named (  int    f, int32    x, const char *    phase )

Definition at line 629 of file io.c. References io_write_phase, phase_unknown, and write_int(). { io_write_phase = phase; write_int(f, x); io_write_phase = phase_unknown; }

void write_longint (  int    f, int64    x )

Definition at line 641 of file io.c. References write_int(), and writefd(). Referenced by report(), and send_file_entry(). { extern int remote_version; char b[8]; if (remote_version < 16 || x <= 0x7FFFFFFF) { write_int(f, (int)x); return; } write_int(f, (int32)0xFFFFFFFF); SIVAL(b,0,(x&0xFFFFFFFF)); SIVAL(b,4,((x>>32)&0xFFFFFFFF)); writefd(f,b,8); }

void write_buf (  int    f, char *    buf, size_t    len )

Definition at line 658 of file io.c. References writefd(). Referenced by match_sums(), send_deflated_token(), send_exclude_list(), send_file_entry(), send_files(), send_sums(), send_uid_list(), simple_send_token(), write_byte(), and write_sbuf(). { writefd(f,buf,len); }

void write_sbuf (  int    f, char *    buf )  [static]

Write a string to the connection. Definition at line 664 of file io.c. References write_buf(). Referenced by io_printf(). { write_buf(f, buf, strlen(buf)); }

void write_byte (  int    f, unsigned char    c )

Definition at line 670 of file io.c. References write_buf(). Referenced by send_deflated_token(), send_file_entry(), and send_uid_list(). { write_buf(f,(char *)&c,1); }

int read_line (  int    f, char *    buf, size_t    maxlen )

Read a line of up to maxlen characters into buf. Does not contain a trailing newline or carriage return. Returns: 1 for success; 0 for io error or truncation. Definition at line 683 of file io.c. References read_buf(). Referenced by auth_server(), rsync_module(), start_daemon(), and start_socket_client(). { while (maxlen) { buf[0] = 0; read_buf(f, buf, 1); if (buf[0] == 0) return 0; if (buf[0] == '\n') { buf[0] = 0; break; } if (buf[0] != '\r') { buf++; maxlen--; } } if (maxlen == 0) { *buf = 0; return 0; } return 1; }

void io_printf (  int    fd, const char *    format, ...    )

Definition at line 708 of file io.c. References vsnprintf(), and write_sbuf(). Referenced by auth_client(), auth_server(), rsync_module(), send_listing(), start_daemon(), and start_socket_client(). { va_list ap; char buf[1024]; int len; va_start(ap, format); len = vsnprintf(buf, sizeof(buf), format, ap); va_end(ap); if (len < 0) exit_cleanup(RERR_STREAMIO); write_sbuf(fd, buf); }

void io_start_multiplex_out (  int    fd )

Setup for multiplexing an error stream with the data stream. Definition at line 725 of file io.c. References io_flush(), io_multiplexing_out, io_start_buffering(), and multiplex_out_fd. Referenced by rsync_module(), and start_server(). { multiplex_out_fd = fd; io_flush(); io_start_buffering(fd); io_multiplexing_out = 1; }

void io_start_multiplex_in (  int    fd )

Setup for multiplexing an error stream with the data stream. Definition at line 734 of file io.c. References io_flush(), io_multiplexing_in, and multiplex_in_fd. Referenced by client_run(), and start_socket_client(). { multiplex_in_fd = fd; io_flush(); io_multiplexing_in = 1; }

int io_multiplex_write (  enum logcode    code, char *    buf, size_t    len )

Write an message to the multiplexed error stream. Definition at line 742 of file io.c. References code, io_flush(), io_multiplexing_out, logcode, mplex_write(), multiplex_out_fd, and stats::total_written. Referenced by rwrite(). { if (!io_multiplexing_out) return 0; io_flush(); stats.total_written += (len+4); mplex_write(multiplex_out_fd, code, buf, len); return 1; }

void io_multiplexing_close (  void    )

Stop output multiplexing. Definition at line 753 of file io.c. References io_multiplexing_out. Referenced by die_from_readerr(), do_recv(), and writefd_unbuffered(). { io_multiplexing_out = 0; }

---

Variable Documentation

int io_multiplexing_out [static]

Definition at line 42 of file io.c. Referenced by io_end_buffering(), io_multiplex_write(), io_multiplexing_close(), and io_start_multiplex_out().

int io_multiplexing_in [static]

Definition at line 43 of file io.c. Referenced by io_start_multiplex_in(), and read_unbuffered().

int multiplex_in_fd [static]

Definition at line 44 of file io.c. Referenced by io_start_multiplex_in(), and read_unbuffered().

int multiplex_out_fd [static]

Definition at line 45 of file io.c. Referenced by io_flush(), io_multiplex_write(), io_start_buffering(), io_start_multiplex_out(), and writefd().

time_t last_io [static]

Definition at line 46 of file io.c. Referenced by check_timeout(), read_timeout(), and writefd_unbuffered().

int no_flush [static]

Definition at line 47 of file io.c. Referenced by io_flush(), and writefd_unbuffered().

int bwlimit

Definition at line 49 of file io.c. Referenced by server_options(), and sleep_for_bwlimit().

int verbose

Definition at line 50 of file io.c.

int io_timeout

Definition at line 51 of file io.c. Referenced by check_timeout(), read_timeout(), server_options(), and writefd_unbuffered().

struct stats stats

Definition at line 52 of file io.c.

const char phase_unknown[] = "unknown"

Definition at line 55 of file io.c. Referenced by write_int_named().

const char* io_write_phase = phase_unknown

The connection might be dropped at some point; perhaps because the remote instance crashed. Just giving the offset on the stream is not very helpful. So instead we try to make io_phase_name point to something useful. For buffered/multiplexed IO these names will be somewhat approximate; perhaps for ease of support we would rather make the buffer always flush when a single application-level IO finishes. Todo: Perhaps we want some simple stack functionality, but there's no need to overdo it. Definition at line 70 of file io.c. Referenced by write_int_named(), and writefd_unbuffered().

const char* io_read_phase = phase_unknown

Definition at line 71 of file io.c.

int kludge_around_eof = False

Ignore EOF errors while reading a module listing if the remote version is 24 or less. Definition at line 75 of file io.c. Referenced by start_socket_client().

int io_error_fd = -1 [static]

Definition at line 78 of file io.c. Referenced by io_set_error_fd(), read_error_fd(), read_timeout(), and writefd_unbuffered().

char* io_buffer [static]

Definition at line 531 of file io.c. Referenced by io_end_buffering(), io_flush(), io_start_buffering(), and writefd().

int io_buffer_count [static]

Definition at line 532 of file io.c. Referenced by io_flush(), io_start_buffering(), and writefd().

---