Applying my updated version of Craig Barratt's buffered I/O patch.
[rsync.git] / io.c
1 /* -*- c-file-style: "linux" -*-
2  * 
3  * Copyright (C) 1996-2001 by Andrew Tridgell 
4  * Copyright (C) Paul Mackerras 1996
5  * Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
6  * 
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  * 
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 /**
23  * @file io.c
24  *
25  * Socket and pipe IO utilities used in rsync.
26  *
27  * rsync provides its own multiplexing system, which is used to send
28  * stderr and stdout over a single socket.  We need this because
29  * stdout normally carries the binary data stream, and stderr all our
30  * error messages.
31  *
32  * For historical reasons this is off during the start of the
33  * connection, but it's switched on quite early using
34  * io_start_multiplex_out() and io_start_multiplex_in().
35  **/
36
37 #include "rsync.h"
38
39 /** If no timeout is specified then use a 60 second select timeout */
40 #define SELECT_TIMEOUT 60
41
42 static int io_multiplexing_out;
43 static int io_multiplexing_in;
44 static int multiplex_in_fd = -1;
45 static int multiplex_out_fd = -1;
46 static time_t last_io;
47 static int no_flush;
48
49 extern int bwlimit;
50 extern int verbose;
51 extern int io_timeout;
52 extern struct stats stats;
53
54
55 const char phase_unknown[] = "unknown";
56
57 /**
58  * The connection might be dropped at some point; perhaps because the
59  * remote instance crashed.  Just giving the offset on the stream is
60  * not very helpful.  So instead we try to make io_phase_name point to
61  * something useful.
62  *
63  * For buffered/multiplexed IO these names will be somewhat
64  * approximate; perhaps for ease of support we would rather make the
65  * buffer always flush when a single application-level IO finishes.
66  *
67  * @todo Perhaps we want some simple stack functionality, but there's
68  * no need to overdo it.
69  **/
70 const char *io_write_phase = phase_unknown;
71 const char *io_read_phase = phase_unknown;
72
73 /** Ignore EOF errors while reading a module listing if the remote
74     version is 24 or less. */
75 int kludge_around_eof = False;
76
77
78 static int io_error_fd = -1;
79 static int io_filesfrom_f_in = -1;
80 static int io_filesfrom_f_out = -1;
81 static char io_filesfrom_buf[2048];
82 static char *io_filesfrom_bp;
83 static char io_filesfrom_lastchar;
84 static int io_filesfrom_buflen;
85
86 static void read_loop(int fd, char *buf, size_t len);
87
88 static void check_timeout(void)
89 {
90         extern int am_server, am_daemon;
91         time_t t;
92
93         err_list_push();
94
95         if (!io_timeout) return;
96
97         if (!last_io) {
98                 last_io = time(NULL);
99                 return;
100         }
101
102         t = time(NULL);
103
104         if (last_io && io_timeout && (t-last_io) >= io_timeout) {
105                 if (!am_server && !am_daemon) {
106                         rprintf(FERROR,"io timeout after %d seconds - exiting\n", 
107                                 (int)(t-last_io));
108                 }
109                 exit_cleanup(RERR_TIMEOUT);
110         }
111 }
112
113 /** Setup the fd used to propagate errors */
114 void io_set_error_fd(int fd)
115 {
116         io_error_fd = fd;
117 }
118
119 /** Read some data from the error fd and write it to the write log code */
120 static void read_error_fd(void)
121 {
122         char buf[200];
123         size_t n;
124         int fd = io_error_fd;
125         int tag, len;
126
127         /* io_error_fd is temporarily disabled -- is this meant to
128          * prevent indefinite recursion? */
129         io_error_fd = -1;
130
131         read_loop(fd, buf, 4);
132         tag = IVAL(buf, 0);
133
134         len = tag & 0xFFFFFF;
135         tag = tag >> 24;
136         tag -= MPLEX_BASE;
137
138         while (len) {
139                 n = len;
140                 if (n > (sizeof buf - 1))
141                         n = sizeof buf - 1;
142                 read_loop(fd, buf, n);
143                 rwrite((enum logcode)tag, buf, n);
144                 len -= n;
145         }
146
147         io_error_fd = fd;
148 }
149
150 /**
151  * When we're the receiver and we have a local --files-from list of names
152  * that needs to be sent over the socket to the sender, we have to do two
153  * things at the same time: send the sender a list of what files we're
154  * processing and read the incoming file+info list from the sender.  We do
155  * this by augmenting the read_timeout() function to copy this data.  It
156  * uses the io_filesfrom_buf to read a block of data from f_in (when it is
157  * ready, since it might be a pipe) and then blast it out f_out (when it
158  * is ready to receive more data).
159  */
160 void io_set_filesfrom_fds(int f_in, int f_out)
161 {
162         io_filesfrom_f_in = f_in;
163         io_filesfrom_f_out = f_out;
164         io_filesfrom_bp = io_filesfrom_buf;
165         io_filesfrom_lastchar = '\0';
166         io_filesfrom_buflen = 0;
167 }
168
169 /**
170  * It's almost always an error to get an EOF when we're trying to read
171  * from the network, because the protocol is self-terminating.
172  *
173  * However, there is one unfortunate cases where it is not, which is
174  * rsync <2.4.6 sending a list of modules on a server, since the list
175  * is terminated by closing the socket. So, for the section of the
176  * program where that is a problem (start_socket_client),
177  * kludge_around_eof is True and we just exit.
178  */
179 static void whine_about_eof(void)
180 {
181         if (kludge_around_eof)
182                 exit_cleanup(0);
183         else {
184                 rprintf(FERROR,
185                         "%s: connection unexpectedly closed "
186                         "(%.0f bytes read so far)\n",
187                         RSYNC_NAME, (double)stats.total_read);
188
189                 exit_cleanup(RERR_STREAMIO);
190         }
191 }
192
193
194 static void die_from_readerr(int err)
195 {
196         /* this prevents us trying to write errors on a dead socket */
197         io_multiplexing_close();
198
199         rprintf(FERROR, "%s: read error: %s\n",
200                 RSYNC_NAME, strerror(err));
201         exit_cleanup(RERR_STREAMIO);
202 }
203
204
205 /**
206  * Read from a socket with IO timeout. return the number of bytes
207  * read. If no bytes can be read then exit, never return a number <= 0.
208  *
209  * TODO: If the remote shell connection fails, then current versions
210  * actually report an "unexpected EOF" error here.  Since it's a
211  * fairly common mistake to try to use rsh when ssh is required, we
212  * should trap that: if we fail to read any data at all, we should
213  * give a better explanation.  We can tell whether the connection has
214  * started by looking e.g. at whether the remote version is known yet.
215  */
216 static int read_timeout(int fd, char *buf, size_t len)
217 {
218         int n, ret=0;
219
220         io_flush();
221
222         while (ret == 0) {
223                 /* until we manage to read *something* */
224                 fd_set r_fds, w_fds;
225                 struct timeval tv;
226                 int fd_count = fd+1;
227                 int count;
228
229                 FD_ZERO(&r_fds);
230                 FD_SET(fd, &r_fds);
231                 if (io_error_fd != -1) {
232                         FD_SET(io_error_fd, &r_fds);
233                         if (io_error_fd >= fd_count) fd_count = io_error_fd+1;
234                 }
235                 if (io_filesfrom_f_out != -1) {
236                         int new_fd;
237                         if (io_filesfrom_buflen == 0) {
238                                 if (io_filesfrom_f_in != -1) {
239                                         FD_SET(io_filesfrom_f_in, &r_fds);
240                                         new_fd = io_filesfrom_f_in;
241                                 } else {
242                                         io_filesfrom_f_out = -1;
243                                         new_fd = -1;
244                                 }
245                         } else {
246                                 FD_ZERO(&w_fds);
247                                 FD_SET(io_filesfrom_f_out, &w_fds);
248                                 new_fd = io_filesfrom_f_out;
249                         }
250                         if (new_fd >= fd_count) fd_count = new_fd+1;
251                 }
252
253                 tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT;
254                 tv.tv_usec = 0;
255
256                 errno = 0;
257
258                 count = select(fd_count, &r_fds,
259                                io_filesfrom_buflen? &w_fds : NULL,
260                                NULL, &tv);
261
262                 if (count == 0) {
263                         check_timeout();
264                 }
265
266                 if (count <= 0) {
267                         if (errno == EBADF) {
268                                 exit_cleanup(RERR_SOCKETIO);
269                         }
270                         continue;
271                 }
272
273                 if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) {
274                         read_error_fd();
275                 }
276
277                 if (io_filesfrom_f_out != -1) {
278                         if (io_filesfrom_buflen) {
279                                 if (FD_ISSET(io_filesfrom_f_out, &w_fds)) {
280                                         int l = write(io_filesfrom_f_out,
281                                                       io_filesfrom_bp,
282                                                       io_filesfrom_buflen);
283                                         if (l > 0) {
284                                                 if (!(io_filesfrom_buflen -= l))
285                                                         io_filesfrom_bp = io_filesfrom_buf;
286                                                 else
287                                                         io_filesfrom_bp += l;
288                                         } else {
289                                                 /* XXX should we complain? */
290                                                 io_filesfrom_f_out = -1;
291                                         }
292                                 }
293                         } else if (io_filesfrom_f_in != -1) {
294                                 if (FD_ISSET(io_filesfrom_f_in, &r_fds)) {
295                                         int l = read(io_filesfrom_f_in,
296                                                      io_filesfrom_buf,
297                                                      sizeof io_filesfrom_buf);
298                                         if (l <= 0) {
299                                                 /* Send end-of-file marker */
300                                                 io_filesfrom_buf[0] = '\0';
301                                                 io_filesfrom_buf[1] = '\0';
302                                                 io_filesfrom_buflen = io_filesfrom_lastchar? 2 : 1;
303                                                 io_filesfrom_f_in = -1;
304                                         } else {
305                                                 extern int eol_nulls;
306                                                 if (!eol_nulls) {
307                                                         char *s = io_filesfrom_buf + l;
308                                                         /* Transform CR and/or LF into '\0' */
309                                                         while (s-- > io_filesfrom_buf) {
310                                                                 if (*s == '\n' || *s == '\r')
311                                                                         *s = '\0';
312                                                         }
313                                                 }
314                                                 if (!io_filesfrom_lastchar) {
315                                                         /* Last buf ended with a '\0', so don't
316                                                          * let this buf start with one. */
317                                                         while (l && !*io_filesfrom_bp)
318                                                                 io_filesfrom_bp++, l--;
319                                                 }
320                                                 if (!l)
321                                                         io_filesfrom_bp = io_filesfrom_buf;
322                                                 else {
323                                                         char *f = io_filesfrom_bp;
324                                                         char *t = f;
325                                                         char *eob = f + l;
326                                                         /* Eliminate any multi-'\0' runs. */
327                                                         while (f != eob) {
328                                                                 if (!(*t++ = *f++)) {
329                                                                         while (f != eob && !*f)
330                                                                                 f++, l--;
331                                                                 }
332                                                         }
333                                                         io_filesfrom_lastchar = f[-1];
334                                                 }
335                                                 io_filesfrom_buflen = l;
336                                         }
337                                 }
338                         }
339                 }
340
341                 if (!FD_ISSET(fd, &r_fds)) continue;
342
343                 n = read(fd, buf, len);
344
345                 if (n > 0) {
346                         buf += n;
347                         len -= n;
348                         ret += n;
349                         if (io_timeout)
350                                 last_io = time(NULL);
351                         continue;
352                 } else if (n == 0) {
353                         whine_about_eof();
354                         return -1; /* doesn't return */
355                 } else if (n == -1) {
356                         if (errno == EINTR || errno == EWOULDBLOCK ||
357                             errno == EAGAIN) 
358                                 continue;
359                         die_from_readerr(errno);
360                 }
361         }
362
363         return ret;
364 }
365
366 /**
367  * Read a line into the "fname" buffer (which must be at least MAXPATHLEN
368  * characters long).
369  */
370 int read_filesfrom_line(int fd, char *fname)
371 {
372         char ch, *s, *eob = fname + MAXPATHLEN - 1;
373         int cnt;
374         extern int io_timeout;
375         extern int eol_nulls;
376         extern char *remote_filesfrom_file;
377         int reading_remotely = remote_filesfrom_file != NULL;
378         int nulls = eol_nulls || reading_remotely;
379
380   start:
381         s = fname;
382         while (1) {
383                 cnt = read(fd, &ch, 1);
384                 if (cnt < 0 && (errno == EWOULDBLOCK
385                   || errno == EINTR || errno == EAGAIN)) {
386                         struct timeval tv;
387                         fd_set fds;
388                         FD_ZERO(&fds);
389                         FD_SET(fd, &fds);
390                         tv.tv_sec = io_timeout? io_timeout : SELECT_TIMEOUT;
391                         tv.tv_usec = 0;
392                         if (!select(fd+1, &fds, NULL, NULL, &tv))
393                                 check_timeout();
394                         continue;
395                 }
396                 if (cnt != 1)
397                         break;
398                 if (nulls? !ch : (ch == '\r' || ch == '\n')) {
399                         /* Skip empty lines if reading locally. */
400                         if (!reading_remotely && s == fname)
401                                 continue;
402                         break;
403                 }
404                 if (s < eob)
405                         *s++ = ch;
406         }
407         *s = '\0';
408
409         /* Dump comments. */
410         if (*fname == '#' || *fname == ';')
411                 goto start;
412
413         return s - fname;
414 }
415
416
417 /**
418  * Continue trying to read len bytes - don't return until len has been
419  * read.
420  **/
421 static void read_loop(int fd, char *buf, size_t len)
422 {
423         while (len) {
424                 int n = read_timeout(fd, buf, len);
425
426                 buf += n;
427                 len -= n;
428         }
429 }
430
431
432 /**
433  * Read from the file descriptor handling multiplexing - return number
434  * of bytes read.
435  * 
436  * Never returns <= 0. 
437  */
438 static int read_unbuffered(int fd, char *buf, size_t len)
439 {
440         static size_t remaining;
441         int tag, ret = 0;
442         char line[1024];
443         static char *buffer;
444         static size_t bufferIdx = 0;
445         static size_t bufferSz;
446
447         if (fd != multiplex_in_fd)
448                 return read_timeout(fd, buf, len);
449
450         if (!io_multiplexing_in && remaining == 0) {
451                 if (!buffer) {
452                         bufferSz = 2 * IO_BUFFER_SIZE;
453                         buffer   = new_array(char, bufferSz);
454                         if (!buffer) out_of_memory("read_unbuffered");
455                 }
456                 remaining = read_timeout(fd, buffer, bufferSz);
457                 bufferIdx = 0;
458         }
459
460         while (ret == 0) {
461                 if (remaining) {
462                         len = MIN(len, remaining);
463                         memcpy(buf, buffer + bufferIdx, len);
464                         bufferIdx += len;
465                         remaining -= len;
466                         ret = len;
467                         break;
468                 }
469
470                 read_loop(fd, line, 4);
471                 tag = IVAL(line, 0);
472
473                 remaining = tag & 0xFFFFFF;
474                 tag = tag >> 24;
475
476                 if (tag == MPLEX_BASE) {
477                         if (!buffer || remaining > bufferSz) {
478                                 buffer = realloc_array(buffer, char, remaining);
479                                 if (!buffer) out_of_memory("read_unbuffered");
480                                 bufferSz = remaining;
481                         }
482                         read_loop(fd, buffer, remaining);
483                         bufferIdx = 0;
484                         continue;
485                 }
486
487                 tag -= MPLEX_BASE;
488
489                 if (tag != FERROR && tag != FINFO) {
490                         rprintf(FERROR, "unexpected tag %d\n", tag);
491                         exit_cleanup(RERR_STREAMIO);
492                 }
493
494                 if (remaining > sizeof line - 1) {
495                         rprintf(FERROR, "multiplexing overflow %ld\n\n",
496                                 (long)remaining);
497                         exit_cleanup(RERR_STREAMIO);
498                 }
499
500                 read_loop(fd, line, remaining);
501                 line[remaining] = 0;
502
503                 rprintf((enum logcode) tag, "%s", line);
504                 remaining = 0;
505         }
506
507         if (remaining == 0)
508                 io_flush();
509
510         return ret;
511 }
512
513
514
515 /**
516  * Do a buffered read from @p fd.  Don't return until all @p n bytes
517  * have been read.  If all @p n can't be read then exit with an
518  * error.
519  **/
520 static void readfd(int fd, char *buffer, size_t N)
521 {
522         int  ret;
523         size_t total=0;  
524
525         while (total < N) {
526                 ret = read_unbuffered(fd, buffer + total, N-total);
527                 total += ret;
528         }
529
530         stats.total_read += total;
531 }
532
533
534 int32 read_int(int f)
535 {
536         char b[4];
537         int32 ret;
538
539         readfd(f,b,4);
540         ret = IVAL(b,0);
541         if (ret == (int32)0xffffffff) return -1;
542         return ret;
543 }
544
545 int64 read_longint(int f)
546 {
547         int64 ret;
548         char b[8];
549         ret = read_int(f);
550
551         if ((int32)ret != (int32)0xffffffff) {
552                 return ret;
553         }
554
555 #ifdef NO_INT64
556         rprintf(FERROR,"Integer overflow - attempted 64 bit offset\n");
557         exit_cleanup(RERR_UNSUPPORTED);
558 #else
559         readfd(f,b,8);
560         ret = IVAL(b,0) | (((int64)IVAL(b,4))<<32);
561 #endif
562
563         return ret;
564 }
565
566 void read_buf(int f,char *buf,size_t len)
567 {
568         readfd(f,buf,len);
569 }
570
571 void read_sbuf(int f,char *buf,size_t len)
572 {
573         read_buf(f,buf,len);
574         buf[len] = 0;
575 }
576
577 unsigned char read_byte(int f)
578 {
579         unsigned char c;
580         read_buf(f, (char *)&c, 1);
581         return c;
582 }
583
584
585 /**
586  * Sleep after writing to limit I/O bandwidth usage.
587  *
588  * @todo Rather than sleeping after each write, it might be better to
589  * use some kind of averaging.  The current algorithm seems to always
590  * use a bit less bandwidth than specified, because it doesn't make up
591  * for slow periods.  But arguably this is a feature.  In addition, we
592  * ought to take the time used to write the data into account.
593  **/
594 static void sleep_for_bwlimit(int bytes_written)
595 {
596         struct timeval tv;
597
598         if (!bwlimit)
599                 return;
600
601         assert(bytes_written > 0);
602         assert(bwlimit > 0);
603
604         tv.tv_usec = bytes_written * 1000 / bwlimit;
605         tv.tv_sec  = tv.tv_usec / 1000000;
606         tv.tv_usec = tv.tv_usec % 1000000;
607
608         select(0, NULL, NULL, NULL, &tv);
609 }
610
611
612 /**
613  * Write len bytes to the file descriptor @p fd.
614  *
615  * This function underlies the multiplexing system.  The body of the
616  * application never calls this function directly.
617  **/
618 static void writefd_unbuffered(int fd,char *buf,size_t len)
619 {
620         size_t total = 0;
621         fd_set w_fds, r_fds;
622         int fd_count, count;
623         struct timeval tv;
624
625         err_list_push();
626
627         no_flush++;
628
629         while (total < len) {
630                 FD_ZERO(&w_fds);
631                 FD_SET(fd,&w_fds);
632                 fd_count = fd;
633
634                 if (io_error_fd != -1) {
635                         FD_ZERO(&r_fds);
636                         FD_SET(io_error_fd,&r_fds);
637                         if (io_error_fd > fd_count) 
638                                 fd_count = io_error_fd;
639                 }
640
641                 tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT;
642                 tv.tv_usec = 0;
643
644                 errno = 0;
645
646                 count = select(fd_count+1,
647                                io_error_fd != -1?&r_fds:NULL,
648                                &w_fds,NULL,
649                                &tv);
650
651                 if (count == 0) {
652                         check_timeout();
653                 }
654
655                 if (count <= 0) {
656                         if (errno == EBADF) {
657                                 exit_cleanup(RERR_SOCKETIO);
658                         }
659                         continue;
660                 }
661
662                 if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) {
663                         read_error_fd();
664                 }
665
666                 if (FD_ISSET(fd, &w_fds)) {
667                         int ret;
668                         size_t n = len-total;
669                         ret = write(fd,buf+total,n);
670
671                         if (ret == -1 && errno == EINTR) {
672                                 continue;
673                         }
674
675                         if (ret == -1 && 
676                             (errno == EWOULDBLOCK || errno == EAGAIN)) {
677                                 msleep(1);
678                                 continue;
679                         }
680
681                         if (ret <= 0) {
682                                 /* Don't try to write errors back
683                                  * across the stream */
684                                 io_multiplexing_close();
685                                 rprintf(FERROR, RSYNC_NAME
686                                         ": writefd_unbuffered failed to write %ld bytes: phase \"%s\": %s\n",
687                                         (long) len, io_write_phase, 
688                                         strerror(errno));
689                                 exit_cleanup(RERR_STREAMIO);
690                         }
691
692                         sleep_for_bwlimit(ret);
693  
694                         total += ret;
695
696                         if (io_timeout)
697                                 last_io = time(NULL);
698                 }
699         }
700
701         no_flush--;
702 }
703
704
705 static char *io_buffer;
706 static int io_buffer_count;
707
708 void io_start_buffering_out(int fd)
709 {
710         if (io_buffer) return;
711         multiplex_out_fd = fd;
712         io_buffer = new_array(char, IO_BUFFER_SIZE);
713         if (!io_buffer) out_of_memory("writefd");
714         io_buffer_count = 0;
715 }
716
717 void io_start_buffering_in(int fd)
718 {
719         multiplex_in_fd = fd;
720 }
721
722 /**
723  * Write an message to a multiplexed stream. If this fails then rsync
724  * exits.
725  **/
726 static void mplex_write(int fd, enum logcode code, char *buf, size_t len)
727 {
728         char buffer[4096];
729         size_t n = len;
730
731         SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len);
732
733         if (n > (sizeof buffer - 4)) {
734                 n = sizeof buffer - 4;
735         }
736
737         memcpy(&buffer[4], buf, n);
738         writefd_unbuffered(fd, buffer, n+4);
739
740         len -= n;
741         buf += n;
742
743         if (len) {
744                 writefd_unbuffered(fd, buf, len);
745         }
746 }
747
748
749 void io_flush(void)
750 {
751         int fd = multiplex_out_fd;
752
753         err_list_push();
754
755         if (!io_buffer_count || no_flush) return;
756
757         if (io_multiplexing_out) {
758                 mplex_write(fd, FNONE, io_buffer, io_buffer_count);
759         } else {
760                 writefd_unbuffered(fd, io_buffer, io_buffer_count);
761         }
762         io_buffer_count = 0;
763 }
764
765
766 void io_end_buffering(void)
767 {
768         io_flush();
769         if (!io_multiplexing_out) {
770                 free(io_buffer);
771                 io_buffer = NULL;
772         }
773 }
774
775 static void writefd(int fd,char *buf,size_t len)
776 {
777         stats.total_written += len;
778
779         err_list_push();
780
781         if (!io_buffer || fd != multiplex_out_fd) {
782                 writefd_unbuffered(fd, buf, len);
783                 return;
784         }
785
786         while (len) {
787                 int n = MIN((int) len, IO_BUFFER_SIZE-io_buffer_count);
788                 if (n > 0) {
789                         memcpy(io_buffer+io_buffer_count, buf, n);
790                         buf += n;
791                         len -= n;
792                         io_buffer_count += n;
793                 }
794
795                 if (io_buffer_count == IO_BUFFER_SIZE) io_flush();
796         }
797 }
798
799
800 void write_int(int f,int32 x)
801 {
802         char b[4];
803         SIVAL(b,0,x);
804         writefd(f,b,4);
805 }
806
807
808 void write_int_named(int f, int32 x, const char *phase)
809 {
810         io_write_phase = phase;
811         write_int(f, x);
812         io_write_phase = phase_unknown;
813 }
814
815
816 /*
817  * Note: int64 may actually be a 32-bit type if ./configure couldn't find any
818  * 64-bit types on this platform.
819  */
820 void write_longint(int f, int64 x)
821 {
822         char b[8];
823
824         if (x <= 0x7FFFFFFF) {
825                 write_int(f, (int)x);
826                 return;
827         }
828
829 #ifdef NO_INT64
830         rprintf(FERROR,"Integer overflow - attempted 64 bit offset\n");
831         exit_cleanup(RERR_UNSUPPORTED);
832 #else
833         write_int(f, (int32)0xFFFFFFFF);
834         SIVAL(b,0,(x&0xFFFFFFFF));
835         SIVAL(b,4,((x>>32)&0xFFFFFFFF));
836
837         writefd(f,b,8);
838 #endif
839 }
840
841 void write_buf(int f,char *buf,size_t len)
842 {
843         writefd(f,buf,len);
844 }
845
846 /** Write a string to the connection */
847 static void write_sbuf(int f,char *buf)
848 {
849         write_buf(f, buf, strlen(buf));
850 }
851
852
853 void write_byte(int f,unsigned char c)
854 {
855         write_buf(f,(char *)&c,1);
856 }
857
858
859
860 /**
861  * Read a line of up to @p maxlen characters into @p buf.  Does not
862  * contain a trailing newline or carriage return.
863  *
864  * @return 1 for success; 0 for io error or truncation.
865  **/
866 int read_line(int f, char *buf, size_t maxlen)
867 {
868         while (maxlen) {
869                 buf[0] = 0;
870                 read_buf(f, buf, 1);
871                 if (buf[0] == 0)
872                         return 0;
873                 if (buf[0] == '\n') {
874                         buf[0] = 0;
875                         break;
876                 }
877                 if (buf[0] != '\r') {
878                         buf++;
879                         maxlen--;
880                 }
881         }
882         if (maxlen == 0) {
883                 *buf = 0;
884                 return 0;
885         }
886
887         return 1;
888 }
889
890
891 void io_printf(int fd, const char *format, ...)
892 {
893         va_list ap;  
894         char buf[1024];
895         int len;
896
897         va_start(ap, format);
898         len = vsnprintf(buf, sizeof buf, format, ap);
899         va_end(ap);
900
901         if (len < 0) exit_cleanup(RERR_STREAMIO);
902
903         write_sbuf(fd, buf);
904 }
905
906
907 /** Setup for multiplexing an error stream with the data stream */
908 void io_start_multiplex_out(int fd)
909 {
910         multiplex_out_fd = fd;
911         io_flush();
912         io_start_buffering_out(fd);
913         io_multiplexing_out = 1;
914 }
915
916 /** Setup for multiplexing an error stream with the data stream */
917 void io_start_multiplex_in(int fd)
918 {
919         multiplex_in_fd = fd;
920         io_flush();
921         io_multiplexing_in = 1;
922 }
923
924 /** Write an message to the multiplexed error stream */
925 int io_multiplex_write(enum logcode code, char *buf, size_t len)
926 {
927         if (!io_multiplexing_out) return 0;
928
929         io_flush();
930         stats.total_written += (len+4);
931         mplex_write(multiplex_out_fd, code, buf, len);
932         return 1;
933 }
934
935 /** Stop output multiplexing */
936 void io_multiplexing_close(void)
937 {
938         io_multiplexing_out = 0;
939 }
940