Made rprintf() of size_t value portable.
[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;
45 static int multiplex_out_fd;
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
274                 if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) {
275                         read_error_fd();
276                 }
277
278                 if (io_filesfrom_f_out != -1) {
279                         if (io_filesfrom_buflen) {
280                                 if (FD_ISSET(io_filesfrom_f_out, &w_fds)) {
281                                         int l = write(io_filesfrom_f_out,
282                                                       io_filesfrom_bp,
283                                                       io_filesfrom_buflen);
284                                         if (l > 0) {
285                                                 if (!(io_filesfrom_buflen -= l))
286                                                         io_filesfrom_bp = io_filesfrom_buf;
287                                                 else
288                                                         io_filesfrom_bp += l;
289                                         } else {
290                                                 /* XXX should we complain? */
291                                                 io_filesfrom_f_out = -1;
292                                         }
293                                 }
294                         } else if (io_filesfrom_f_in != -1) {
295                                 if (FD_ISSET(io_filesfrom_f_in, &r_fds)) {
296                                         int l = read(io_filesfrom_f_in,
297                                                      io_filesfrom_buf,
298                                                      sizeof io_filesfrom_buf);
299                                         if (l <= 0) {
300                                                 /* Send end-of-file marker */
301                                                 io_filesfrom_buf[0] = '\0';
302                                                 io_filesfrom_buf[1] = '\0';
303                                                 io_filesfrom_buflen = io_filesfrom_lastchar? 2 : 1;
304                                                 io_filesfrom_f_in = -1;
305                                         } else {
306                                                 extern int eol_nulls;
307                                                 if (!eol_nulls) {
308                                                         char *s = io_filesfrom_buf + l;
309                                                         /* Transform CR and/or LF into '\0' */
310                                                         while (s-- > io_filesfrom_buf) {
311                                                                 if (*s == '\n' || *s == '\r')
312                                                                         *s = '\0';
313                                                         }
314                                                 }
315                                                 if (!io_filesfrom_lastchar) {
316                                                         /* Last buf ended with a '\0', so don't
317                                                          * let this buf start with one. */
318                                                         while (l && !*io_filesfrom_bp)
319                                                                 io_filesfrom_bp++, l--;
320                                                 }
321                                                 if (!l)
322                                                         io_filesfrom_bp = io_filesfrom_buf;
323                                                 else {
324                                                         char *f = io_filesfrom_bp;
325                                                         char *t = f;
326                                                         char *eob = f + l;
327                                                         /* Eliminate any multi-'\0' runs. */
328                                                         while (f != eob) {
329                                                                 if (!(*t++ = *f++)) {
330                                                                         while (f != eob && !*f)
331                                                                                 f++, l--;
332                                                                 }
333                                                         }
334                                                         io_filesfrom_lastchar = f[-1];
335                                                 }
336                                                 io_filesfrom_buflen = l;
337                                         }
338                                 }
339                         }
340                 }
341
342                 if (!FD_ISSET(fd, &r_fds)) continue;
343
344                 n = read(fd, buf, len);
345
346                 if (n > 0) {
347                         buf += n;
348                         len -= n;
349                         ret += n;
350                         if (io_timeout)
351                                 last_io = time(NULL);
352                         continue;
353                 } else if (n == 0) {
354                         whine_about_eof ();
355                         return -1; /* doesn't return */
356                 } else if (n == -1) {
357                         if (errno == EINTR || errno == EWOULDBLOCK ||
358                             errno == EAGAIN) 
359                                 continue;
360                         else
361                                 die_from_readerr (errno);
362                 }
363         }
364
365         return ret;
366 }
367
368 /**
369  * Read a line into the "fname" buffer (which must be at least MAXPATHLEN
370  * characters long).
371  */
372 int read_filesfrom_line(int fd, char *fname)
373 {
374         char ch, *s, *eob = fname + MAXPATHLEN - 1;
375         int cnt;
376         extern int io_timeout;
377         extern int eol_nulls;
378         extern char *remote_filesfrom_file;
379         extern int am_server;
380         int reading_remotely = remote_filesfrom_file || (am_server && fd == 0);
381         int nulls = eol_nulls || reading_remotely;
382
383   start:
384         s = fname;
385         while (1) {
386                 cnt = read(fd, &ch, 1);
387                 if (cnt < 0 && (errno == EWOULDBLOCK
388                   || errno == EINTR || errno == EAGAIN)) {
389                         struct timeval tv;
390                         fd_set fds;
391                         FD_ZERO(&fds);
392                         FD_SET(fd, &fds);
393                         tv.tv_sec = io_timeout? io_timeout : SELECT_TIMEOUT;
394                         tv.tv_usec = 0;
395                         if (!select(fd+1, &fds, NULL, NULL, &tv))
396                                 check_timeout();
397                         continue;
398                 }
399                 if (cnt != 1)
400                         break;
401                 if (nulls? !ch : (ch == '\r' || ch == '\n')) {
402                         /* Skip empty lines if reading locally. */
403                         if (!reading_remotely && s == fname)
404                                 continue;
405                         break;
406                 }
407                 if (s < eob)
408                         *s++ = ch;
409         }
410         *s = '\0';
411
412         /* Dump comments. */
413         if (*fname == '#' || *fname == ';')
414                 goto start;
415
416         return s - fname;
417 }
418
419
420 /**
421  * Continue trying to read len bytes - don't return until len has been
422  * read.
423  **/
424 static void read_loop (int fd, char *buf, size_t len)
425 {
426         while (len) {
427                 int n = read_timeout(fd, buf, len);
428
429                 buf += n;
430                 len -= n;
431         }
432 }
433
434
435 /**
436  * Read from the file descriptor handling multiplexing - return number
437  * of bytes read.
438  * 
439  * Never returns <= 0. 
440  */
441 static int read_unbuffered(int fd, char *buf, size_t len)
442 {
443         static size_t remaining;
444         int tag, ret = 0;
445         char line[1024];
446
447         if (!io_multiplexing_in || fd != multiplex_in_fd)
448                 return read_timeout(fd, buf, len);
449
450         while (ret == 0) {
451                 if (remaining) {
452                         len = MIN(len, remaining);
453                         read_loop(fd, buf, len);
454                         remaining -= len;
455                         ret = len;
456                         continue;
457                 }
458
459                 read_loop(fd, line, 4);
460                 tag = IVAL(line, 0);
461
462                 remaining = tag & 0xFFFFFF;
463                 tag = tag >> 24;
464
465                 if (tag == MPLEX_BASE)
466                         continue;
467
468                 tag -= MPLEX_BASE;
469
470                 if (tag != FERROR && tag != FINFO) {
471                         rprintf(FERROR, "unexpected tag %d\n", tag);
472                         exit_cleanup(RERR_STREAMIO);
473                 }
474
475                 if (remaining > sizeof(line) - 1) {
476                         rprintf(FERROR, "multiplexing overflow %ld\n\n",
477                                 (long)remaining);
478                         exit_cleanup(RERR_STREAMIO);
479                 }
480
481                 read_loop(fd, line, remaining);
482                 line[remaining] = 0;
483
484                 rprintf((enum logcode) tag, "%s", line);
485                 remaining = 0;
486         }
487
488         return ret;
489 }
490
491
492
493 /**
494  * Do a buffered read from @p fd.  Don't return until all @p n bytes
495  * have been read.  If all @p n can't be read then exit with an
496  * error.
497  **/
498 static void readfd (int fd, char *buffer, size_t N)
499 {
500         int  ret;
501         size_t total=0;  
502         
503         while (total < N) {
504                 io_flush();
505
506                 ret = read_unbuffered (fd, buffer + total, N-total);
507                 total += ret;
508         }
509
510         stats.total_read += total;
511 }
512
513
514 int32 read_int(int f)
515 {
516         char b[4];
517         int32 ret;
518
519         readfd(f,b,4);
520         ret = IVAL(b,0);
521         if (ret == (int32)0xffffffff) return -1;
522         return ret;
523 }
524
525 int64 read_longint(int f)
526 {
527         int64 ret;
528         char b[8];
529         ret = read_int(f);
530
531         if ((int32)ret != (int32)0xffffffff) {
532                 return ret;
533         }
534
535 #ifdef NO_INT64
536         rprintf(FERROR,"Integer overflow - attempted 64 bit offset\n");
537         exit_cleanup(RERR_UNSUPPORTED);
538 #else
539         readfd(f,b,8);
540         ret = IVAL(b,0) | (((int64)IVAL(b,4))<<32);
541 #endif
542
543         return ret;
544 }
545
546 void read_buf(int f,char *buf,size_t len)
547 {
548         readfd(f,buf,len);
549 }
550
551 void read_sbuf(int f,char *buf,size_t len)
552 {
553         read_buf (f,buf,len);
554         buf[len] = 0;
555 }
556
557 unsigned char read_byte(int f)
558 {
559         unsigned char c;
560         read_buf (f, (char *)&c, 1);
561         return c;
562 }
563
564
565 /**
566  * Sleep after writing to limit I/O bandwidth usage.
567  *
568  * @todo Rather than sleeping after each write, it might be better to
569  * use some kind of averaging.  The current algorithm seems to always
570  * use a bit less bandwidth than specified, because it doesn't make up
571  * for slow periods.  But arguably this is a feature.  In addition, we
572  * ought to take the time used to write the data into account.
573  **/
574 static void sleep_for_bwlimit(int bytes_written)
575 {
576         struct timeval tv;
577
578         if (!bwlimit)
579                 return;
580
581         assert(bytes_written > 0);
582         assert(bwlimit > 0);
583         
584         tv.tv_usec = bytes_written * 1000 / bwlimit;
585         tv.tv_sec  = tv.tv_usec / 1000000;
586         tv.tv_usec = tv.tv_usec % 1000000;
587
588         select(0, NULL, NULL, NULL, &tv);
589 }
590
591
592 /**
593  * Write len bytes to the file descriptor @p fd.
594  *
595  * This function underlies the multiplexing system.  The body of the
596  * application never calls this function directly.
597  **/
598 static void writefd_unbuffered(int fd,char *buf,size_t len)
599 {
600         size_t total = 0;
601         fd_set w_fds, r_fds;
602         int fd_count, count;
603         struct timeval tv;
604
605         err_list_push();
606
607         no_flush++;
608
609         while (total < len) {
610                 FD_ZERO(&w_fds);
611                 FD_SET(fd,&w_fds);
612                 fd_count = fd;
613
614                 if (io_error_fd != -1) {
615                         FD_ZERO(&r_fds);
616                         FD_SET(io_error_fd,&r_fds);
617                         if (io_error_fd > fd_count) 
618                                 fd_count = io_error_fd;
619                 }
620
621                 tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT;
622                 tv.tv_usec = 0;
623
624                 errno = 0;
625
626                 count = select(fd_count+1,
627                                io_error_fd != -1?&r_fds:NULL,
628                                &w_fds,NULL,
629                                &tv);
630
631                 if (count == 0) {
632                         check_timeout();
633                 }
634
635                 if (count <= 0) {
636                         if (errno == EBADF) {
637                                 exit_cleanup(RERR_SOCKETIO);
638                         }
639                         continue;
640                 }
641
642                 if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) {
643                         read_error_fd();
644                 }
645
646                 if (FD_ISSET(fd, &w_fds)) {
647                         int ret;
648                         size_t n = len-total;
649                         ret = write(fd,buf+total,n);
650
651                         if (ret == -1 && errno == EINTR) {
652                                 continue;
653                         }
654
655                         if (ret == -1 && 
656                             (errno == EWOULDBLOCK || errno == EAGAIN)) {
657                                 msleep(1);
658                                 continue;
659                         }
660
661                         if (ret <= 0) {
662                                 /* Don't try to write errors back
663                                  * across the stream */
664                                 io_multiplexing_close();
665                                 rprintf(FERROR, RSYNC_NAME
666                                         ": writefd_unbuffered failed to write %ld bytes: phase \"%s\": %s\n",
667                                         (long) len, io_write_phase, 
668                                         strerror(errno));
669                                 exit_cleanup(RERR_STREAMIO);
670                         }
671
672                         sleep_for_bwlimit(ret);
673  
674                         total += ret;
675
676                         if (io_timeout)
677                                 last_io = time(NULL);
678                 }
679         }
680
681         no_flush--;
682 }
683
684
685 static char *io_buffer;
686 static int io_buffer_count;
687
688 void io_start_buffering(int fd)
689 {
690         if (io_buffer) return;
691         multiplex_out_fd = fd;
692         io_buffer = (char *)malloc(IO_BUFFER_SIZE);
693         if (!io_buffer) out_of_memory("writefd");
694         io_buffer_count = 0;
695 }
696
697 /**
698  * Write an message to a multiplexed stream. If this fails then rsync
699  * exits.
700  **/
701 static void mplex_write(int fd, enum logcode code, char *buf, size_t len)
702 {
703         char buffer[4096];
704         size_t n = len;
705
706         SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len);
707
708         if (n > (sizeof(buffer)-4)) {
709                 n = sizeof(buffer)-4;
710         }
711
712         memcpy(&buffer[4], buf, n);
713         writefd_unbuffered(fd, buffer, n+4);
714
715         len -= n;
716         buf += n;
717
718         if (len) {
719                 writefd_unbuffered(fd, buf, len);
720         }
721 }
722
723
724 void io_flush(void)
725 {
726         int fd = multiplex_out_fd;
727
728         err_list_push();
729
730         if (!io_buffer_count || no_flush) return;
731
732         if (io_multiplexing_out) {
733                 mplex_write(fd, FNONE, io_buffer, io_buffer_count);
734         } else {
735                 writefd_unbuffered(fd, io_buffer, io_buffer_count);
736         }
737         io_buffer_count = 0;
738 }
739
740
741 void io_end_buffering(void)
742 {
743         io_flush();
744         if (!io_multiplexing_out) {
745                 free(io_buffer);
746                 io_buffer = NULL;
747         }
748 }
749
750 static void writefd(int fd,char *buf,size_t len)
751 {
752         stats.total_written += len;
753
754         err_list_push();
755
756         if (!io_buffer || fd != multiplex_out_fd) {
757                 writefd_unbuffered(fd, buf, len);
758                 return;
759         }
760
761         while (len) {
762                 int n = MIN((int) len, IO_BUFFER_SIZE-io_buffer_count);
763                 if (n > 0) {
764                         memcpy(io_buffer+io_buffer_count, buf, n);
765                         buf += n;
766                         len -= n;
767                         io_buffer_count += n;
768                 }
769                 
770                 if (io_buffer_count == IO_BUFFER_SIZE) io_flush();
771         }
772 }
773
774
775 void write_int(int f,int32 x)
776 {
777         char b[4];
778         SIVAL(b,0,x);
779         writefd(f,b,4);
780 }
781
782
783 void write_int_named(int f, int32 x, const char *phase)
784 {
785         io_write_phase = phase;
786         write_int(f, x);
787         io_write_phase = phase_unknown;
788 }
789
790
791 /*
792  * Note: int64 may actually be a 32-bit type if ./configure couldn't find any
793  * 64-bit types on this platform.
794  */
795 void write_longint(int f, int64 x)
796 {
797         char b[8];
798
799         if (x <= 0x7FFFFFFF) {
800                 write_int(f, (int)x);
801                 return;
802         }
803
804 #ifdef NO_INT64
805         rprintf(FERROR,"Integer overflow - attempted 64 bit offset\n");
806         exit_cleanup(RERR_UNSUPPORTED);
807 #else
808         write_int(f, (int32)0xFFFFFFFF);
809         SIVAL(b,0,(x&0xFFFFFFFF));
810         SIVAL(b,4,((x>>32)&0xFFFFFFFF));
811
812         writefd(f,b,8);
813 #endif
814 }
815
816 void write_buf(int f,char *buf,size_t len)
817 {
818         writefd(f,buf,len);
819 }
820
821 /** Write a string to the connection */
822 static void write_sbuf(int f,char *buf)
823 {
824         write_buf(f, buf, strlen(buf));
825 }
826
827
828 void write_byte(int f,unsigned char c)
829 {
830         write_buf(f,(char *)&c,1);
831 }
832
833
834
835 /**
836  * Read a line of up to @p maxlen characters into @p buf.  Does not
837  * contain a trailing newline or carriage return.
838  *
839  * @return 1 for success; 0 for io error or truncation.
840  **/
841 int read_line(int f, char *buf, size_t maxlen)
842 {
843         while (maxlen) {
844                 buf[0] = 0;
845                 read_buf(f, buf, 1);
846                 if (buf[0] == 0)
847                         return 0;
848                 if (buf[0] == '\n') {
849                         buf[0] = 0;
850                         break;
851                 }
852                 if (buf[0] != '\r') {
853                         buf++;
854                         maxlen--;
855                 }
856         }
857         if (maxlen == 0) {
858                 *buf = 0;
859                 return 0;
860         }
861
862         return 1;
863 }
864
865
866 void io_printf(int fd, const char *format, ...)
867 {
868         va_list ap;  
869         char buf[1024];
870         int len;
871         
872         va_start(ap, format);
873         len = vsnprintf(buf, sizeof(buf), format, ap);
874         va_end(ap);
875
876         if (len < 0) exit_cleanup(RERR_STREAMIO);
877
878         write_sbuf(fd, buf);
879 }
880
881
882 /** Setup for multiplexing an error stream with the data stream */
883 void io_start_multiplex_out(int fd)
884 {
885         multiplex_out_fd = fd;
886         io_flush();
887         io_start_buffering(fd);
888         io_multiplexing_out = 1;
889 }
890
891 /** Setup for multiplexing an error stream with the data stream */
892 void io_start_multiplex_in(int fd)
893 {
894         multiplex_in_fd = fd;
895         io_flush();
896         io_multiplexing_in = 1;
897 }
898
899 /** Write an message to the multiplexed error stream */
900 int io_multiplex_write(enum logcode code, char *buf, size_t len)
901 {
902         if (!io_multiplexing_out) return 0;
903
904         io_flush();
905         stats.total_written += (len+4);
906         mplex_write(multiplex_out_fd, code, buf, len);
907         return 1;
908 }
909
910 /** Stop output multiplexing */
911 void io_multiplexing_close(void)
912 {
913         io_multiplexing_out = 0;
914 }
915