Merge branch 'mirbsd'
[alioth/cvs.git] / src / buffer.c
1 /*
2  * Copyright (C) 1996-2005 The Free Software Foundation, Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2, or (at your option)
7  * any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 /* Code for the buffer data structure.  */
16
17 #include "cvs.h"
18 #include "buffer.h"
19 #include "pagealign_alloc.h"
20
21 #if defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT)
22
23 # include <sys/socket.h>
24
25 /* OS/2 doesn't have EIO.  FIXME: this whole notion of turning
26    a different error into EIO strikes me as pretty dubious.  */
27 # if !defined( EIO )
28 #   define EIO EBADPOS
29 # endif
30
31 /* Local functions.  */
32 static void buf_default_memory_error (struct buffer *);
33 static struct buffer_data *get_buffer_data (void);
34
35
36
37 /* Initialize a buffer structure.  */
38 struct buffer *
39 buf_initialize (type_buf_input input,
40                 type_buf_output output,
41                 type_buf_flush flush,
42                 type_buf_block block,
43                 type_buf_get_fd get_fd,
44                 type_buf_shutdown shutdown,
45                 type_buf_memory_error memory_error,
46                 void *closure)
47 {
48     struct buffer *buf;
49
50     buf = xmalloc (sizeof (struct buffer));
51     buf->data = NULL;
52     buf->last = NULL;
53     buf->nonblocking = false;
54     buf->input = input;
55     buf->output = output;
56     buf->flush = flush;
57     buf->block = block;
58     buf->get_fd = get_fd;
59     buf->shutdown = shutdown;
60     buf->memory_error = memory_error ? memory_error : buf_default_memory_error;
61     buf->closure = closure;
62     return buf;
63 }
64
65
66
67 /* Free a buffer structure.  */
68 void
69 buf_free (struct buffer *buf)
70 {
71     if (buf->closure != NULL)
72     {
73         free (buf->closure);
74         buf->closure = NULL;
75     }
76     buf_free_data (buf);
77     free (buf);
78 }
79
80
81
82 /* Initialize a buffer structure which is not to be used for I/O.  */
83 struct buffer *
84 buf_nonio_initialize( void (*memory) (struct buffer *) )
85 {
86     return buf_initialize (NULL, NULL, NULL, NULL, NULL, NULL, memory, NULL);
87 }
88
89
90
91 /* Default memory error handler.  */
92 static void
93 buf_default_memory_error (struct buffer *buf)
94 {
95     error (1, 0, "out of memory");
96 }
97
98
99
100 /* Allocate more buffer_data structures.  */
101 /* Get a new buffer_data structure.  */
102 static struct buffer_data *
103 get_buffer_data (void)
104 {
105     struct buffer_data *ret;
106
107     ret = xmalloc (sizeof (struct buffer_data));
108     ret->text = pagealign_xalloc (BUFFER_DATA_SIZE);
109
110     return ret;
111 }
112
113
114
115 /* See whether a buffer and its file descriptor is empty.  */
116 int
117 buf_empty (buf)
118     struct buffer *buf;
119 {
120         /* Try and read any data on the file descriptor first.
121          * We already know the descriptor is non-blocking.
122          */
123         buf_input_data (buf, NULL);
124         return buf_empty_p (buf);
125 }
126
127
128
129 /* See whether a buffer is empty.  */
130 int
131 buf_empty_p (struct buffer *buf)
132 {
133     struct buffer_data *data;
134
135     for (data = buf->data; data != NULL; data = data->next)
136         if (data->size > 0)
137             return 0;
138     return 1;
139 }
140
141
142
143 # if defined (SERVER_FLOWCONTROL) || defined (PROXY_SUPPORT)
144 /*
145  * Count how much data is stored in the buffer..
146  * Note that each buffer is a xmalloc'ed chunk BUFFER_DATA_SIZE.
147  */
148 int
149 buf_count_mem (struct buffer *buf)
150 {
151     struct buffer_data *data;
152     int mem = 0;
153
154     for (data = buf->data; data != NULL; data = data->next)
155         mem += BUFFER_DATA_SIZE;
156
157     return mem;
158 }
159 # endif /* SERVER_FLOWCONTROL || PROXY_SUPPORT */
160
161
162
163 /* Add data DATA of length LEN to BUF.  */
164 void
165 buf_output (struct buffer *buf, const char *data, size_t len)
166 {
167     if (buf->data != NULL
168         && (((buf->last->text + BUFFER_DATA_SIZE)
169              - (buf->last->bufp + buf->last->size))
170             >= len))
171     {
172         memcpy (buf->last->bufp + buf->last->size, data, len);
173         buf->last->size += len;
174         return;
175     }
176
177     while (1)
178     {
179         struct buffer_data *newdata;
180
181         newdata = get_buffer_data ();
182         if (newdata == NULL)
183         {
184             (*buf->memory_error) (buf);
185             return;
186         }
187
188         if (buf->data == NULL)
189             buf->data = newdata;
190         else
191             buf->last->next = newdata;
192         newdata->next = NULL;
193         buf->last = newdata;
194
195         newdata->bufp = newdata->text;
196
197         if (len <= BUFFER_DATA_SIZE)
198         {
199             newdata->size = len;
200             memcpy (newdata->text, data, len);
201             return;
202         }
203
204         newdata->size = BUFFER_DATA_SIZE;
205         memcpy (newdata->text, data, BUFFER_DATA_SIZE);
206
207         data += BUFFER_DATA_SIZE;
208         len -= BUFFER_DATA_SIZE;
209     }
210
211     /*NOTREACHED*/
212 }
213
214
215
216 /* Add a '\0' terminated string to BUF.  */
217 void
218 buf_output0 (struct buffer *buf, const char *string)
219 {
220     buf_output (buf, string, strlen (string));
221 }
222
223
224
225 /* Add a single character to BUF.  */
226 void
227 buf_append_char (struct buffer *buf, int ch)
228 {
229     if (buf->data != NULL
230         && (buf->last->text + BUFFER_DATA_SIZE
231             != buf->last->bufp + buf->last->size))
232     {
233         *(buf->last->bufp + buf->last->size) = ch;
234         ++buf->last->size;
235     }
236     else
237     {
238         char b;
239
240         b = ch;
241         buf_output (buf, &b, 1);
242     }
243 }
244
245
246
247 /* Free struct buffer_data's from the list starting with FIRST and ending at
248  * LAST, inclusive.
249  */
250 static inline void
251 buf_free_datas (struct buffer_data *first, struct buffer_data *last)
252 {
253     struct buffer_data *b, *n, *p;
254     b = first;
255     do
256     {
257         p = b;
258         n = b->next;
259         pagealign_free (b->text);
260         free (b);
261         b = n;
262     } while (p != last);
263 }
264
265
266
267 /*
268  * Send all the output we've been saving up.  Returns 0 for success or
269  * errno code.  If the buffer has been set to be nonblocking, this
270  * will just write until the write would block.
271  */
272 int
273 buf_send_output (struct buffer *buf)
274 {
275     assert (buf->output != NULL);
276
277     while (buf->data != NULL)
278     {
279         struct buffer_data *data;
280
281         data = buf->data;
282
283         if (data->size > 0)
284         {
285             int status;
286             size_t nbytes;
287
288             status = (*buf->output) (buf->closure, data->bufp, data->size,
289                                      &nbytes);
290             if (status != 0)
291             {
292                 /* Some sort of error.  Discard the data, and return.  */
293                 buf_free_data (buf);
294                 return status;
295             }
296
297             if (nbytes != data->size)
298             {
299                 /* Not all the data was written out.  This is only
300                    permitted in nonblocking mode.  Adjust the buffer,
301                    and return.  */
302
303                 assert (buf->nonblocking);
304
305                 data->size -= nbytes;
306                 data->bufp += nbytes;
307
308                 return 0;
309             }
310         }
311
312         buf->data = data->next;
313         buf_free_datas (data, data);
314     }
315
316     buf->last = NULL;
317
318     return 0;
319 }
320
321
322
323 /*
324  * Flush any data queued up in the buffer.  If BLOCK is nonzero, then
325  * if the buffer is in nonblocking mode, put it into blocking mode for
326  * the duration of the flush.  This returns 0 on success, or an error
327  * code.
328  */
329 int
330 buf_flush (struct buffer *buf, bool block)
331 {
332     int nonblocking;
333     int status;
334
335     assert (buf->flush != NULL);
336
337     nonblocking = buf->nonblocking;
338     if (nonblocking && block)
339     {
340         status = set_block (buf);
341         if (status != 0)
342             return status;
343     }
344
345     status = buf_send_output (buf);
346     if (status == 0)
347         status = (*buf->flush) (buf->closure);
348
349     if (nonblocking && block)
350     {
351         int blockstat;
352
353         blockstat = set_nonblock (buf);
354         if (status == 0)
355             status = blockstat;
356     }
357
358     return status;
359 }
360
361
362
363 /*
364  * Set buffer BUF to nonblocking I/O.  Returns 0 for success or errno
365  * code.
366  */
367 int
368 set_nonblock (struct buffer *buf)
369 {
370     int status;
371
372     if (buf->nonblocking)
373         return 0;
374     assert (buf->block != NULL);
375     status = (*buf->block) (buf->closure, 0);
376     if (status != 0)
377         return status;
378     buf->nonblocking = true;
379     return 0;
380 }
381
382
383
384 /*
385  * Set buffer BUF to blocking I/O.  Returns 0 for success or errno
386  * code.
387  */
388 int
389 set_block (struct buffer *buf)
390 {
391     int status;
392
393     if (! buf->nonblocking)
394         return 0;
395     assert (buf->block != NULL);
396     status = (*buf->block) (buf->closure, 1);
397     if (status != 0)
398         return status;
399     buf->nonblocking = false;
400     return 0;
401 }
402
403
404
405 /*
406  * Send a character count and some output.  Returns errno code or 0 for
407  * success.
408  *
409  * Sending the count in binary is OK since this is only used on a pipe
410  * within the same system.
411  */
412 int
413 buf_send_counted (struct buffer *buf)
414 {
415     int size;
416     struct buffer_data *data;
417
418     size = 0;
419     for (data = buf->data; data != NULL; data = data->next)
420         size += data->size;
421
422     data = get_buffer_data ();
423     if (data == NULL)
424     {
425         (*buf->memory_error) (buf);
426         return ENOMEM;
427     }
428
429     data->next = buf->data;
430     buf->data = data;
431     if (buf->last == NULL)
432         buf->last = data;
433
434     data->bufp = data->text;
435     data->size = sizeof (int);
436
437     *((int *) data->text) = size;
438
439     return buf_send_output (buf);
440 }
441
442
443
444 /*
445  * Send a special count.  COUNT should be negative.  It will be
446  * handled specially by buf_copy_counted.  This function returns 0 or
447  * an errno code.
448  *
449  * Sending the count in binary is OK since this is only used on a pipe
450  * within the same system.
451  */
452 int
453 buf_send_special_count (struct buffer *buf, int count)
454 {
455     struct buffer_data *data;
456
457     data = get_buffer_data ();
458     if (data == NULL)
459     {
460         (*buf->memory_error) (buf);
461         return ENOMEM;
462     }
463
464     data->next = buf->data;
465     buf->data = data;
466     if (buf->last == NULL)
467         buf->last = data;
468
469     data->bufp = data->text;
470     data->size = sizeof (int);
471
472     *((int *) data->text) = count;
473
474     return buf_send_output (buf);
475 }
476
477
478
479 /* Append a list of buffer_data structures to an buffer.  */
480 void
481 buf_append_data (struct buffer *buf, struct buffer_data *data,
482                  struct buffer_data *last)
483 {
484     if (data != NULL)
485     {
486         if (buf->data == NULL)
487             buf->data = data;
488         else
489             buf->last->next = data;
490         buf->last = last;
491     }
492 }
493
494
495
496 # ifdef PROXY_SUPPORT
497 /* Copy data structures and append them to a buffer.
498  *
499  * ERRORS
500  *   Failure to allocate memory here is fatal.
501  */
502 void
503 buf_copy_data (struct buffer *buf, struct buffer_data *data,
504                struct buffer_data *last)
505 {
506     struct buffer_data *first, *new, *cur, *prev;
507
508     assert (buf);
509     assert (data);
510
511     prev = first = NULL;
512     cur = data;
513     while (1)
514     {
515         new = get_buffer_data ();
516         if (!new) error (1, errno, "Failed to allocate buffer data.");
517
518         if (!first) first = new;
519         memcpy (new->text, cur->bufp, cur->size);
520         new->bufp = new->text;
521         new->size = cur->size;
522         new->next = NULL;
523         if (prev) prev->next = new;
524         if (cur == last) break;
525         prev = new;
526         cur = cur->next;
527     }
528
529     buf_append_data (buf, first, new);
530 }
531 # endif /* PROXY_SUPPORT */
532
533
534
535 /* Dispose of any remaining data in the buffer.  */
536 void
537 buf_free_data (struct buffer *buffer)
538 {
539   if (buffer->data) {
540     buf_free_datas (buffer->data, buffer->last);
541     buffer->data = buffer->last = NULL;
542   }
543 }
544
545
546
547 /* Append the data in one buffer to another.  This removes the data
548  * from the source buffer.
549  */
550 void
551 buf_append_buffer (struct buffer *to, struct buffer *from)
552 {
553     struct buffer_data *n;
554
555     /* Copy the data pointer to the new buf.  */
556     buf_append_data (to, from->data, from->last);
557
558     n = from->data;
559     while (n)
560     {
561         if (n == from->last) break;
562         n = n->next;
563     }
564
565     /* Remove from the original location.  */
566     from->data = NULL;
567     from->last = NULL;
568 }
569
570
571
572 /*
573  * Copy the contents of file F into buffer_data structures.  We can't
574  * copy directly into an buffer, because we want to handle failure and
575  * success differently.  Returns 0 on success, or -2 if out of
576  * memory, or a status code on error.  Since the caller happens to
577  * know the size of the file, it is passed in as SIZE.  On success,
578  * this function sets *RETP and *LASTP, which may be passed to
579  * buf_append_data.
580  */
581 int
582 buf_read_file (FILE *f, long int size, struct buffer_data **retp,
583                struct buffer_data **lastp)
584 {
585     int status;
586
587     *retp = NULL;
588     *lastp = NULL;
589
590     while (size > 0)
591     {
592         struct buffer_data *data;
593         int get;
594
595         data = get_buffer_data ();
596         if (data == NULL)
597         {
598             status = -2;
599             goto error_return;
600         }
601
602         if (*retp == NULL)
603             *retp = data;
604         else
605             (*lastp)->next = data;
606         data->next = NULL;
607         *lastp = data;
608
609         data->bufp = data->text;
610         data->size = 0;
611
612         if (size > BUFFER_DATA_SIZE)
613             get = BUFFER_DATA_SIZE;
614         else
615             get = size;
616
617         errno = EIO;
618         if (fread (data->text, get, 1, f) != 1)
619         {
620             status = errno;
621             goto error_return;
622         }
623
624         data->size += get;
625         size -= get;
626     }
627
628     return 0;
629
630   error_return:
631     if (*retp != NULL)
632         buf_free_datas (*retp, (*lastp)->next);
633     return status;
634 }
635
636
637
638 /*
639  * Copy the contents of file F into buffer_data structures.  We can't
640  * copy directly into an buffer, because we want to handle failure and
641  * success differently.  Returns 0 on success, or -2 if out of
642  * memory, or a status code on error.  On success, this function sets
643  * *RETP and *LASTP, which may be passed to buf_append_data.
644  */
645 int
646 buf_read_file_to_eof (FILE *f, struct buffer_data **retp,
647                       struct buffer_data **lastp)
648 {
649     int status;
650
651     *retp = NULL;
652     *lastp = NULL;
653
654     while (!feof (f))
655     {
656         struct buffer_data *data;
657         int get, nread;
658
659         data = get_buffer_data ();
660         if (data == NULL)
661         {
662             status = -2;
663             goto error_return;
664         }
665
666         if (*retp == NULL)
667             *retp = data;
668         else
669             (*lastp)->next = data;
670         data->next = NULL;
671         *lastp = data;
672
673         data->bufp = data->text;
674         data->size = 0;
675
676         get = BUFFER_DATA_SIZE;
677
678         errno = EIO;
679         nread = fread (data->text, 1, get, f);
680         if (nread == 0 && !feof (f))
681         {
682             status = errno;
683             goto error_return;
684         }
685
686         data->size = nread;
687     }
688
689     return 0;
690
691   error_return:
692     if (*retp != NULL)
693         buf_free_datas (*retp, (*lastp)->next);
694     return status;
695 }
696
697
698
699 /* Return the number of bytes in a chain of buffer_data structures.  */
700 int
701 buf_chain_length (struct buffer_data *buf)
702 {
703     int size = 0;
704     while (buf)
705     {
706         size += buf->size;
707         buf = buf->next;
708     }
709     return size;
710 }
711
712
713
714 /* Return the number of bytes in a buffer.  */
715 int
716 buf_length (struct buffer *buf)
717 {
718     return buf_chain_length (buf->data);
719 }
720
721
722
723 /*
724  * Read an arbitrary amount of data into an input buffer.  The buffer
725  * will be in nonblocking mode, and we just grab what we can.  Return
726  * 0 on success, or -1 on end of file, or -2 if out of memory, or an
727  * error code.  If COUNTP is not NULL, *COUNTP is set to the number of
728  * bytes read.
729  */
730 int
731 buf_input_data (struct buffer *buf, size_t *countp)
732 {
733     assert (buf->input != NULL);
734
735     if (countp != NULL)
736         *countp = 0;
737
738     while (1)
739     {
740         int status;
741         size_t get, nbytes;
742
743         if (buf->data == NULL
744             || (buf->last->bufp + buf->last->size
745                 == buf->last->text + BUFFER_DATA_SIZE))
746         {
747             struct buffer_data *data;
748
749             data = get_buffer_data ();
750             if (data == NULL)
751             {
752                 (*buf->memory_error) (buf);
753                 return -2;
754             }
755
756             if (buf->data == NULL)
757                 buf->data = data;
758             else
759                 buf->last->next = data;
760             data->next = NULL;
761             buf->last = data;
762
763             data->bufp = data->text;
764             data->size = 0;
765         }
766
767         get = ((buf->last->text + BUFFER_DATA_SIZE)
768                - (buf->last->bufp + buf->last->size));
769
770         status = (*buf->input) (buf->closure,
771                                 buf->last->bufp + buf->last->size,
772                                 0, get, &nbytes);
773         if (status != 0)
774             return status;
775
776         buf->last->size += nbytes;
777         if (countp != NULL)
778             *countp += nbytes;
779
780         if (nbytes < get)
781         {
782             /* If we did not fill the buffer, then presumably we read
783                all the available data.  */
784             return 0;
785         }
786     }
787
788     /*NOTREACHED*/
789 }
790
791
792
793 /*
794  * Read a line (characters up to a \012) from an input buffer.  (We
795  * use \012 rather than \n for the benefit of non Unix clients for
796  * which \n means something else).  This returns 0 on success, or -1
797  * on end of file, or -2 if out of memory, or an error code.  If it
798  * succeeds, it sets *LINE to an allocated buffer holding the contents
799  * of the line.  The trailing \012 is not included in the buffer.  If
800  * LENP is not NULL, then *LENP is set to the number of bytes read;
801  * strlen may not work, because there may be embedded null bytes.
802  */
803 int
804 buf_read_line (struct buffer *buf, char **line, size_t *lenp)
805 {
806     return buf_read_short_line (buf, line, lenp, SIZE_MAX);
807 }
808
809
810
811 /* Like buf_read_line, but return -2 if no newline is found in MAX characters.
812  */
813 int
814 buf_read_short_line (struct buffer *buf, char **line, size_t *lenp,
815                      size_t max)
816 {
817     assert (buf->input != NULL);
818
819     *line = NULL;
820
821     while (1)
822     {
823         size_t len, finallen, predicted_len;
824         struct buffer_data *data;
825         char *nl;
826
827         /* See if there is a newline in BUF.  */
828         len = 0;
829         for (data = buf->data; data != NULL; data = data->next)
830         {
831             nl = memchr (data->bufp, '\012', data->size);
832             if (nl != NULL)
833             {
834                 finallen = nl - data->bufp;
835                 if (xsum (len, finallen) >= max) return -2;
836                 len += finallen;
837                 break;
838             }
839             else if (xsum (len, data->size) >= max) return -2;
840             len += data->size;
841         }
842
843         /* If we found a newline, copy the line into a memory buffer,
844            and remove it from BUF.  */
845         if (data != NULL)
846         {
847             char *p;
848             struct buffer_data *nldata;
849
850             p = xmalloc (len + 1);
851             if (p == NULL)
852                 return -2;
853             *line = p;
854
855             nldata = data;
856             data = buf->data;
857             while (data != nldata)
858             {
859                 struct buffer_data *next;
860
861                 memcpy (p, data->bufp, data->size);
862                 p += data->size;
863                 next = data->next;
864                 buf_free_datas (data, data);
865                 data = next;
866             }
867
868             memcpy (p, data->bufp, finallen);
869             p[finallen] = '\0';
870
871             data->size -= finallen + 1;
872             data->bufp = nl + 1;
873             buf->data = data;
874
875             if (lenp != NULL)
876                 *lenp = len;
877
878             return 0;
879         }
880
881         /* Read more data until we get a newline or MAX characters.  */
882         predicted_len = 0;
883         while (1)
884         {
885             int status;
886             size_t size, nbytes;
887             char *mem;
888
889             if (buf->data == NULL
890                 || (buf->last->bufp + buf->last->size
891                     == buf->last->text + BUFFER_DATA_SIZE))
892             {
893                 data = get_buffer_data ();
894                 if (data == NULL)
895                 {
896                     (*buf->memory_error) (buf);
897                     return -2;
898                 }
899
900                 if (buf->data == NULL)
901                     buf->data = data;
902                 else
903                     buf->last->next = data;
904                 data->next = NULL;
905                 buf->last = data;
906
907                 data->bufp = data->text;
908                 data->size = 0;
909             }
910
911             mem = buf->last->bufp + buf->last->size;
912             size = (buf->last->text + BUFFER_DATA_SIZE) - mem;
913
914             /* We need to read at least 1 byte.  We can handle up to
915                SIZE bytes.  This will only be efficient if the
916                underlying communication stream does its own buffering,
917                or is clever about getting more than 1 byte at a time.  */
918             status = (*buf->input) (buf->closure, mem, 1, size, &nbytes);
919             if (status != 0)
920                 return status;
921
922             predicted_len += nbytes;
923             buf->last->size += nbytes;
924
925             /* Optimize slightly to avoid an unnecessary call to memchr.  */
926             if (nbytes == 1)
927             {
928                 if (*mem == '\012')
929                     break;
930             }
931             else
932             {
933                 if (memchr (mem, '\012', nbytes) != NULL)
934                     break;
935             }
936             if (xsum (len, predicted_len) >= max) return -2;
937         }
938     }
939 }
940
941
942
943 /*
944  * Extract data from the input buffer BUF.  This will read up to WANT
945  * bytes from the buffer.  It will set *RETDATA to point at the bytes,
946  * and set *GOT to the number of bytes to be found there.  Any buffer
947  * call which uses BUF may change the contents of the buffer at *DATA,
948  * so the data should be fully processed before any further calls are
949  * made.  This returns 0 on success, or -1 on end of file, or -2 if
950  * out of memory, or an error code.
951  */
952 int
953 buf_read_data (struct buffer *buf, size_t want, char **retdata, size_t *got)
954 {
955     assert (buf->input != NULL);
956
957     while (buf->data != NULL && buf->data->size == 0)
958     {
959         struct buffer_data *next;
960
961         next = buf->data->next;
962         buf_free_datas (buf->data, buf->data);
963         buf->data = next;
964         if (next == NULL)
965             buf->last = NULL;
966     }
967
968     if (buf->data == NULL)
969     {
970         struct buffer_data *data;
971         int status;
972         size_t get, nbytes;
973
974         data = get_buffer_data ();
975         if (data == NULL)
976         {
977             (*buf->memory_error) (buf);
978             return -2;
979         }
980
981         buf->data = data;
982         buf->last = data;
983         data->next = NULL;
984         data->bufp = data->text;
985         data->size = 0;
986
987         if (want < BUFFER_DATA_SIZE)
988             get = want;
989         else
990             get = BUFFER_DATA_SIZE;
991         status = (*buf->input) (buf->closure, data->bufp, get,
992                                 BUFFER_DATA_SIZE, &nbytes);
993         if (status != 0)
994             return status;
995
996         data->size = nbytes;
997     }
998
999     *retdata = buf->data->bufp;
1000     if (want < buf->data->size)
1001     {
1002         *got = want;
1003         buf->data->size -= want;
1004         buf->data->bufp += want;
1005     }
1006     else
1007     {
1008         *got = buf->data->size;
1009         buf->data->size = 0;
1010     }
1011
1012     return 0;
1013 }
1014
1015
1016
1017 /*
1018  * Copy lines from an input buffer to an output buffer.
1019  * This copies all complete lines (characters up to a
1020  * newline) from INBUF to OUTBUF.  Each line in OUTBUF is preceded by the
1021  * character COMMAND and a space.
1022  */
1023 void
1024 buf_copy_lines (struct buffer *outbuf, struct buffer *inbuf, int command)
1025 {
1026     while (1)
1027     {
1028         struct buffer_data *data;
1029         struct buffer_data *nldata;
1030         char *nl;
1031         int len;
1032
1033         /* See if there is a newline in INBUF.  */
1034         nldata = NULL;
1035         nl = NULL;
1036         for (data = inbuf->data; data != NULL; data = data->next)
1037         {
1038             nl = memchr (data->bufp, '\n', data->size);
1039             if (nl != NULL)
1040             {
1041                 nldata = data;
1042                 break;
1043             }
1044         }
1045
1046         if (nldata == NULL)
1047         {
1048             /* There are no more lines in INBUF.  */
1049             return;
1050         }
1051
1052         /* Put in the command.  */
1053         buf_append_char (outbuf, command);
1054         buf_append_char (outbuf, ' ');
1055
1056         if (inbuf->data != nldata)
1057         {
1058             /*
1059              * Simply move over all the buffers up to the one containing
1060              * the newline.
1061              */
1062             for (data = inbuf->data; data->next != nldata; data = data->next);
1063             data->next = NULL;
1064             buf_append_data (outbuf, inbuf->data, data);
1065             inbuf->data = nldata;
1066         }
1067
1068         /*
1069          * If the newline is at the very end of the buffer, just move
1070          * the buffer onto OUTBUF.  Otherwise we must copy the data.
1071          */
1072         len = nl + 1 - nldata->bufp;
1073         if (len == nldata->size)
1074         {
1075             inbuf->data = nldata->next;
1076             if (inbuf->data == NULL)
1077                 inbuf->last = NULL;
1078
1079             nldata->next = NULL;
1080             buf_append_data (outbuf, nldata, nldata);
1081         }
1082         else
1083         {
1084             buf_output (outbuf, nldata->bufp, len);
1085             nldata->bufp += len;
1086             nldata->size -= len;
1087         }
1088     }
1089 }
1090
1091
1092
1093 /*
1094  * Copy counted data from one buffer to another.  The count is an
1095  * integer, host size, host byte order (it is only used across a
1096  * pipe).  If there is enough data, it should be moved over.  If there
1097  * is not enough data, it should remain on the original buffer.  A
1098  * negative count is a special case.  if one is seen, *SPECIAL is set
1099  * to the (negative) count value and no additional data is gathered
1100  * from the buffer; normally *SPECIAL is set to 0.  This function
1101  * returns the number of bytes it needs to see in order to actually
1102  * copy something over.
1103  */
1104 int
1105 buf_copy_counted (struct buffer *outbuf, struct buffer *inbuf, int *special)
1106 {
1107     *special = 0;
1108
1109     while (1)
1110     {
1111         struct buffer_data *data;
1112         int need;
1113         union
1114         {
1115             char intbuf[sizeof (int)];
1116             int i;
1117         } u;
1118         char *intp;
1119         int count;
1120         struct buffer_data *start;
1121         int startoff;
1122         struct buffer_data *stop;
1123         int stopwant;
1124
1125         /* See if we have enough bytes to figure out the count.  */
1126         need = sizeof (int);
1127         intp = u.intbuf;
1128         for (data = inbuf->data; data != NULL; data = data->next)
1129         {
1130             if (data->size >= need)
1131             {
1132                 memcpy (intp, data->bufp, need);
1133                 break;
1134             }
1135             memcpy (intp, data->bufp, data->size);
1136             intp += data->size;
1137             need -= data->size;
1138         }
1139         if (data == NULL)
1140         {
1141             /* We don't have enough bytes to form an integer.  */
1142             return need;
1143         }
1144
1145         count = u.i;
1146         start = data;
1147         startoff = need;
1148
1149         if (count < 0)
1150         {
1151             /* A negative COUNT is a special case meaning that we
1152                don't need any further information.  */
1153             stop = start;
1154             stopwant = 0;
1155         }
1156         else
1157         {
1158             /*
1159              * We have an integer in COUNT.  We have gotten all the
1160              * data from INBUF in all buffers before START, and we
1161              * have gotten STARTOFF bytes from START.  See if we have
1162              * enough bytes remaining in INBUF.
1163              */
1164             need = count - (start->size - startoff);
1165             if (need <= 0)
1166             {
1167                 stop = start;
1168                 stopwant = count;
1169             }
1170             else
1171             {
1172                 for (data = start->next; data != NULL; data = data->next)
1173                 {
1174                     if (need <= data->size)
1175                         break;
1176                     need -= data->size;
1177                 }
1178                 if (data == NULL)
1179                 {
1180                     /* We don't have enough bytes.  */
1181                     return need;
1182                 }
1183                 stop = data;
1184                 stopwant = need;
1185             }
1186         }
1187
1188         /*
1189          * We have enough bytes.  Free any buffers in INBUF before
1190          * START, and remove STARTOFF bytes from START, so that we can
1191          * forget about STARTOFF.
1192          */
1193         start->bufp += startoff;
1194         start->size -= startoff;
1195
1196         if (start->size == 0)
1197             start = start->next;
1198
1199         if (stop->size == stopwant)
1200         {
1201             stop = stop->next;
1202             stopwant = 0;
1203         }
1204
1205         while (inbuf->data != start)
1206         {
1207             data = inbuf->data;
1208             inbuf->data = data->next;
1209             buf_free_datas (data, data);
1210         }
1211
1212         /* If COUNT is negative, set *SPECIAL and get out now.  */
1213         if (count < 0)
1214         {
1215             *special = count;
1216             return 0;
1217         }
1218
1219         /*
1220          * We want to copy over the bytes from START through STOP.  We
1221          * only want STOPWANT bytes from STOP.
1222          */
1223
1224         if (start != stop)
1225         {
1226             /* Attach the buffers from START through STOP to OUTBUF.  */
1227             for (data = start; data->next != stop; data = data->next);
1228             inbuf->data = stop;
1229             data->next = NULL;
1230             buf_append_data (outbuf, start, data);
1231         }
1232
1233         if (stopwant > 0)
1234         {
1235             buf_output (outbuf, stop->bufp, stopwant);
1236             stop->bufp += stopwant;
1237             stop->size -= stopwant;
1238         }
1239     }
1240
1241     /*NOTREACHED*/
1242 }
1243
1244
1245
1246 int
1247 buf_get_fd (struct buffer *buf)
1248 {
1249     if (buf->get_fd)
1250         return (*buf->get_fd) (buf->closure);
1251     return -1;
1252 }
1253
1254
1255
1256 /* Shut down a buffer.  This returns 0 on success, or an errno code.  */
1257 int
1258 buf_shutdown (struct buffer *buf)
1259 {
1260     if (buf->shutdown) return (*buf->shutdown) (buf);
1261     return 0;
1262 }
1263
1264
1265
1266 /* Certain types of communication input and output data in packets,
1267    where each packet is translated in some fashion.  The packetizing
1268    buffer type supports that, given a buffer which handles lower level
1269    I/O and a routine to translate the data in a packet.
1270
1271    This code uses two bytes for the size of a packet, so packets are
1272    restricted to 65536 bytes in total.
1273
1274    The translation functions should just translate; they may not
1275    significantly increase or decrease the amount of data.  The actual
1276    size of the initial data is part of the translated data.  The
1277    output translation routine may add up to PACKET_SLOP additional
1278    bytes, and the input translation routine should shrink the data
1279    correspondingly.  */
1280
1281 # define PACKET_SLOP (100)
1282
1283 /* This structure is the closure field of a packetizing buffer.  */
1284
1285 struct packetizing_buffer
1286 {
1287     /* The underlying buffer.  */
1288     struct buffer *buf;
1289     /* The input translation function.  Exactly one of inpfn and outfn
1290        will be NULL.  The input translation function should
1291        untranslate the data in INPUT, storing the result in OUTPUT.
1292        SIZE is the amount of data in INPUT, and is also the size of
1293        OUTPUT.  This should return 0 on success, or an errno code.  */
1294     int (*inpfn) (void *fnclosure, const char *input, char *output,
1295                         size_t size);
1296     /* The output translation function.  This should translate the
1297        data in INPUT, storing the result in OUTPUT.  The first two
1298        bytes in INPUT will be the size of the data, and so will SIZE.
1299        This should set *TRANSLATED to the amount of translated data in
1300        OUTPUT.  OUTPUT is large enough to hold SIZE + PACKET_SLOP
1301        bytes.  This should return 0 on success, or an errno code.  */
1302     int (*outfn) (void *fnclosure, const char *input, char *output,
1303                         size_t size, size_t *translated);
1304     /* A closure for the translation function.  */
1305     void *fnclosure;
1306     /* For an input buffer, we may have to buffer up data here.  */
1307     /* This is non-zero if the buffered data has been translated.
1308        Otherwise, the buffered data has not been translated, and starts
1309        with the two byte packet size.  */
1310     bool translated;
1311     /* The amount of buffered data.  */
1312     size_t holdsize;
1313     /* The buffer allocated to hold the data.  */
1314     char *holdbuf;
1315     /* The size of holdbuf.  */
1316     size_t holdbufsize;
1317     /* If translated is set, we need another data pointer to track
1318        where we are in holdbuf.  If translated is clear, then this
1319        pointer is not used.  */
1320     char *holddata;
1321 };
1322
1323
1324
1325 static int packetizing_buffer_input (void *, char *, size_t, size_t, size_t *);
1326 static int packetizing_buffer_output (void *, const char *, size_t, size_t *);
1327 static int packetizing_buffer_flush (void *);
1328 static int packetizing_buffer_block (void *, bool);
1329 static int packetizing_buffer_get_fd (void *);
1330 static int packetizing_buffer_shutdown (struct buffer *);
1331
1332
1333
1334 /* Create a packetizing buffer.  */
1335 struct buffer *
1336 packetizing_buffer_initialize (struct buffer *buf,
1337                                int (*inpfn) (void *, const char *, char *,
1338                                              size_t),
1339                                int (*outfn) (void *, const char *, char *,
1340                                              size_t, size_t *),
1341                                void *fnclosure,
1342                                void (*memory) (struct buffer *))
1343 {
1344     struct packetizing_buffer *pb;
1345
1346     pb = xmalloc (sizeof *pb);
1347     memset (pb, 0, sizeof *pb);
1348
1349     pb->buf = buf;
1350     pb->inpfn = inpfn;
1351     pb->outfn = outfn;
1352     pb->fnclosure = fnclosure;
1353
1354     if (inpfn != NULL)
1355     {
1356         /* Add PACKET_SLOP to handle larger translated packets, and
1357            add 2 for the count.  This buffer is increased if
1358            necessary.  */
1359         pb->holdbufsize = BUFFER_DATA_SIZE + PACKET_SLOP + 2;
1360         pb->holdbuf = xmalloc (pb->holdbufsize);
1361     }
1362
1363     return buf_initialize (inpfn != NULL ? packetizing_buffer_input : NULL,
1364                            inpfn != NULL ? NULL : packetizing_buffer_output,
1365                            inpfn != NULL ? NULL : packetizing_buffer_flush,
1366                            packetizing_buffer_block,
1367                            packetizing_buffer_get_fd,
1368                            packetizing_buffer_shutdown,
1369                            memory,
1370                            pb);
1371 }
1372
1373
1374
1375 /* Input data from a packetizing buffer.  */
1376 static int
1377 packetizing_buffer_input (void *closure, char *data, size_t need, size_t size,
1378                           size_t *got)
1379 {
1380     struct packetizing_buffer *pb = closure;
1381
1382     *got = 0;
1383
1384     if (pb->holdsize > 0 && pb->translated)
1385     {
1386         size_t copy;
1387
1388         copy = pb->holdsize;
1389
1390         if (copy > size)
1391         {
1392             memcpy (data, pb->holddata, size);
1393             pb->holdsize -= size;
1394             pb->holddata += size;
1395             *got = size;
1396             return 0;
1397         }
1398
1399         memcpy (data, pb->holddata, copy);
1400         pb->holdsize = 0;
1401         pb->translated = false;
1402
1403         data += copy;
1404         need -= copy;
1405         size -= copy;
1406         *got = copy;
1407     }
1408
1409     while (need > 0 || *got == 0)
1410     {
1411         int status;
1412         size_t get, nread, count, tcount;
1413         char *bytes;
1414         static char *stackoutbuf = NULL;
1415         char *inbuf, *outbuf;
1416
1417         if (!stackoutbuf)
1418             stackoutbuf = xmalloc (BUFFER_DATA_SIZE + PACKET_SLOP);
1419
1420         /* If we don't already have the two byte count, get it.  */
1421         if (pb->holdsize < 2)
1422         {
1423             get = 2 - pb->holdsize;
1424             status = buf_read_data (pb->buf, get, &bytes, &nread);
1425             if (status != 0)
1426             {
1427                 /* buf_read_data can return -2, but a buffer input
1428                    function is only supposed to return -1, 0, or an
1429                    error code.  */
1430                 if (status == -2)
1431                     status = ENOMEM;
1432                 return status;
1433             }
1434
1435             if (nread == 0)
1436             {
1437                 /* The buffer is in nonblocking mode, and we didn't
1438                    manage to read anything.  */
1439                 return 0;
1440             }
1441
1442             if (get == 1)
1443                 pb->holdbuf[1] = bytes[0];
1444             else
1445             {
1446                 pb->holdbuf[0] = bytes[0];
1447                 if (nread < 2)
1448                 {
1449                     /* We only got one byte, but we needed two.  Stash
1450                        the byte we got, and try again.  */
1451                     pb->holdsize = 1;
1452                     continue;
1453                 }
1454                 pb->holdbuf[1] = bytes[1];
1455             }
1456             pb->holdsize = 2;
1457         }
1458
1459         /* Read the packet.  */
1460
1461         count = (((pb->holdbuf[0] & 0xff) << 8)
1462                  + (pb->holdbuf[1] & 0xff));
1463
1464         if (count + 2 > pb->holdbufsize)
1465         {
1466             char *n;
1467
1468             /* We didn't allocate enough space in the initialize
1469                function.  */
1470
1471             n = xrealloc (pb->holdbuf, count + 2);
1472             if (n == NULL)
1473             {
1474                 (*pb->buf->memory_error) (pb->buf);
1475                 return ENOMEM;
1476             }
1477             pb->holdbuf = n;
1478             pb->holdbufsize = count + 2;
1479         }
1480
1481         get = count - (pb->holdsize - 2);
1482
1483         status = buf_read_data (pb->buf, get, &bytes, &nread);
1484         if (status != 0)
1485         {
1486             /* buf_read_data can return -2, but a buffer input
1487                function is only supposed to return -1, 0, or an error
1488                code.  */
1489             if (status == -2)
1490                 status = ENOMEM;
1491             return status;
1492         }
1493
1494         if (nread == 0)
1495         {
1496             /* We did not get any data.  Presumably the buffer is in
1497                nonblocking mode.  */
1498             return 0;
1499         }
1500
1501         if (nread < get)
1502         {
1503             /* We did not get all the data we need to fill the packet.
1504                buf_read_data does not promise to return all the bytes
1505                requested, so we must try again.  */
1506             memcpy (pb->holdbuf + pb->holdsize, bytes, nread);
1507             pb->holdsize += nread;
1508             continue;
1509         }
1510
1511         /* We have a complete untranslated packet of COUNT bytes.  */
1512
1513         if (pb->holdsize == 2)
1514         {
1515             /* We just read the entire packet (the 2 bytes in
1516                PB->HOLDBUF are the size).  Save a memcpy by
1517                translating directly from BYTES.  */
1518             inbuf = bytes;
1519         }
1520         else
1521         {
1522             /* We already had a partial packet in PB->HOLDBUF.  We
1523                need to copy the new data over to make the input
1524                contiguous.  */
1525             memcpy (pb->holdbuf + pb->holdsize, bytes, nread);
1526             inbuf = pb->holdbuf + 2;
1527         }
1528
1529         if (count <= BUFFER_DATA_SIZE + PACKET_SLOP)
1530             outbuf = stackoutbuf;
1531         else
1532         {
1533             outbuf = xmalloc (count);
1534             if (outbuf == NULL)
1535             {
1536                 (*pb->buf->memory_error) (pb->buf);
1537                 return ENOMEM;
1538             }
1539         }
1540
1541         status = (*pb->inpfn) (pb->fnclosure, inbuf, outbuf, count);
1542         if (status != 0)
1543             return status;
1544
1545         /* The first two bytes in the translated buffer are the real
1546            length of the translated data.  */
1547         tcount = ((outbuf[0] & 0xff) << 8) + (outbuf[1] & 0xff);
1548
1549         if (tcount > count)
1550             error (1, 0, "Input translation failure");
1551
1552         if (tcount > size)
1553         {
1554             /* We have more data than the caller has provided space
1555                for.  We need to save some of it for the next call.  */
1556
1557             memcpy (data, outbuf + 2, size);
1558             *got += size;
1559
1560             pb->holdsize = tcount - size;
1561             memcpy (pb->holdbuf, outbuf + 2 + size, tcount - size);
1562             pb->holddata = pb->holdbuf;
1563             pb->translated = true;
1564
1565             if (outbuf != stackoutbuf)
1566                 free (outbuf);
1567
1568             return 0;
1569         }
1570
1571         memcpy (data, outbuf + 2, tcount);
1572
1573         if (outbuf != stackoutbuf)
1574             free (outbuf);
1575
1576         pb->holdsize = 0;
1577
1578         data += tcount;
1579         need -= tcount;
1580         size -= tcount;
1581         *got += tcount;
1582     }
1583
1584     return 0;
1585 }
1586
1587
1588
1589 /* Output data to a packetizing buffer.  */
1590 static int
1591 packetizing_buffer_output (void *closure, const char *data, size_t have,
1592                            size_t *wrote)
1593 {
1594     struct packetizing_buffer *pb = closure;
1595     static char *inbuf = NULL;  /* These two buffers are static so that they
1596                                  * depend on the size of BUFFER_DATA_SIZE yet
1597                                  * still only be allocated once per run.
1598                                  */
1599     static char *stack_outbuf = NULL;
1600     struct buffer_data *outdata = NULL; /* Initialize to silence -Wall.  Dumb.
1601                                          */
1602     char *outbuf;
1603     size_t size, translated;
1604     int status;
1605
1606     /* It would be easy to xmalloc a buffer, but I don't think this
1607        case can ever arise.  */
1608     assert (have <= BUFFER_DATA_SIZE);
1609
1610     if (!inbuf)
1611     {
1612         inbuf = xmalloc (BUFFER_DATA_SIZE + 2);
1613         stack_outbuf = xmalloc (BUFFER_DATA_SIZE + PACKET_SLOP + 4);
1614     }
1615
1616     inbuf[0] = (have >> 8) & 0xff;
1617     inbuf[1] = have & 0xff;
1618     memcpy (inbuf + 2, data, have);
1619
1620     size = have + 2;
1621
1622     /* The output function is permitted to add up to PACKET_SLOP
1623        bytes, and we need 2 bytes for the size of the translated data.
1624        If we can guarantee that the result will fit in a buffer_data,
1625        we translate directly into one to avoid a memcpy in buf_output.  */
1626     if (size + PACKET_SLOP + 2 > BUFFER_DATA_SIZE)
1627         outbuf = stack_outbuf;
1628     else
1629     {
1630         outdata = get_buffer_data ();
1631         if (outdata == NULL)
1632         {
1633             (*pb->buf->memory_error) (pb->buf);
1634             return ENOMEM;
1635         }
1636
1637         outdata->next = NULL;
1638         outdata->bufp = outdata->text;
1639
1640         outbuf = outdata->text;
1641     }
1642
1643     status = (*pb->outfn) (pb->fnclosure, inbuf, outbuf + 2, size,
1644                            &translated);
1645     if (status != 0)
1646         return status;
1647
1648     /* The output function is permitted to add up to PACKET_SLOP
1649        bytes.  */
1650     assert (translated <= size + PACKET_SLOP);
1651
1652     outbuf[0] = (translated >> 8) & 0xff;
1653     outbuf[1] = translated & 0xff;
1654
1655     if (outbuf == stack_outbuf)
1656         buf_output (pb->buf, outbuf, translated + 2);
1657     else
1658     {
1659         outdata->size = translated + 2;
1660         buf_append_data (pb->buf, outdata, outdata);
1661     }
1662
1663     *wrote = have;
1664
1665     /* We will only be here because buf_send_output was called on the
1666        packetizing buffer.  That means that we should now call
1667        buf_send_output on the underlying buffer.  */
1668     return buf_send_output (pb->buf);
1669 }
1670
1671
1672
1673 /* Flush data to a packetizing buffer.  */
1674 static int
1675 packetizing_buffer_flush (void *closure)
1676 {
1677     struct packetizing_buffer *pb = closure;
1678
1679     /* Flush the underlying buffer.  Note that if the original call to
1680        buf_flush passed 1 for the BLOCK argument, then the buffer will
1681        already have been set into blocking mode, so we should always
1682        pass 0 here.  */
1683     return buf_flush (pb->buf, 0);
1684 }
1685
1686
1687
1688 /* The block routine for a packetizing buffer.  */
1689 static int
1690 packetizing_buffer_block (void *closure, bool block)
1691 {
1692     struct packetizing_buffer *pb = closure;
1693
1694     if (block)
1695         return set_block (pb->buf);
1696     else
1697         return set_nonblock (pb->buf);
1698 }
1699
1700
1701
1702 /* Return the file descriptor underlying any child buffers.  */
1703 static int
1704 packetizing_buffer_get_fd (void *closure)
1705 {
1706     struct packetizing_buffer *cb = closure;
1707     return buf_get_fd (cb->buf);
1708 }
1709
1710
1711
1712 /* Shut down a packetizing buffer.  */
1713 static int
1714 packetizing_buffer_shutdown (struct buffer *buf)
1715 {
1716     struct packetizing_buffer *pb = buf->closure;
1717
1718     return buf_shutdown (pb->buf);
1719 }
1720
1721
1722
1723 /* All server communication goes through buffer structures.  Most of
1724    the buffers are built on top of a file descriptor.  This structure
1725    is used as the closure field in a buffer.  */
1726
1727 struct fd_buffer
1728 {
1729     /* The file descriptor.  */
1730     int fd;
1731     /* Nonzero if the file descriptor is in blocking mode.  */
1732     int blocking;
1733     /* The child process id when fd is a pipe.  */
1734     pid_t child_pid;
1735     /* The connection info, when fd is a pipe to a server.  */
1736     cvsroot_t *root;
1737 };
1738
1739 static int fd_buffer_input (void *, char *, size_t, size_t, size_t *);
1740 static int fd_buffer_output (void *, const char *, size_t, size_t *);
1741 static int fd_buffer_flush (void *);
1742 static int fd_buffer_block (void *, bool);
1743 static int fd_buffer_get_fd (void *);
1744 static int fd_buffer_shutdown (struct buffer *);
1745
1746 /* Initialize a buffer built on a file descriptor.  FD is the file
1747    descriptor.  INPUT is nonzero if this is for input, zero if this is
1748    for output.  MEMORY is the function to call when a memory error
1749    occurs.  */
1750
1751 struct buffer *
1752 fd_buffer_initialize (int fd, pid_t child_pid, cvsroot_t *root, bool input,
1753                       void (*memory) (struct buffer *))
1754 {
1755     struct fd_buffer *n;
1756
1757     n = xmalloc (sizeof *n);
1758     n->fd = fd;
1759     n->child_pid = child_pid;
1760     n->root = root;
1761     fd_buffer_block (n, true);
1762     return buf_initialize (input ? fd_buffer_input : NULL,
1763                            input ? NULL : fd_buffer_output,
1764                            input ? NULL : fd_buffer_flush,
1765                            fd_buffer_block, fd_buffer_get_fd,
1766                            fd_buffer_shutdown,
1767                            memory,
1768                            n);
1769 }
1770
1771
1772
1773 /* The buffer input function for a buffer built on a file descriptor.
1774  *
1775  * In non-blocking mode, this function will read as many bytes as it can in a
1776  * single try, up to SIZE bytes, and return.
1777  *
1778  * In blocking mode with NEED > 0, this function will read as many bytes as it
1779  * can but will not return until it has read at least NEED bytes.
1780  *
1781  * In blocking mode with NEED == 0, this function will block until it can read
1782  * either at least one byte or EOF, then read as many bytes as are available
1783  * and return.  At the very least, compress_buffer_shutdown depends on this
1784  * behavior to read EOF and can loop indefinitely without it.
1785  *
1786  * ASSUMPTIONS
1787  *   NEED <= SIZE.
1788  *
1789  * INPUTS
1790  *   closure    Our FD_BUFFER struct.
1791  *   data       The start of our input buffer.
1792  *   need       How many bytes our caller needs.
1793  *   size       How many bytes are available in DATA.
1794  *   got        Where to store the number of bytes read.
1795  *
1796  * OUTPUTS
1797  *   data       Filled with bytes read.
1798  *   *got       Number of bytes actually read into DATA.
1799  *
1800  * RETURNS
1801  *   errno      On error.
1802  *   -1         On EOF.
1803  *   0          Otherwise.
1804  *
1805  * ERRORS
1806  *   This function can return an error if fd_buffer_block(), or the system
1807  *   read() or select() calls do.
1808  */
1809 static int
1810 fd_buffer_input (void *closure, char *data, size_t need, size_t size,
1811                  size_t *got)
1812 {
1813     struct fd_buffer *fb = closure;
1814     int nbytes;
1815
1816     assert (need <= size);
1817
1818     *got = 0;
1819
1820     if (fb->blocking)
1821     {
1822         int status;
1823         fd_set readfds;
1824
1825         /* Set non-block.  */
1826         status = fd_buffer_block (fb, false);
1827         if (status != 0) return status;
1828
1829         FD_ZERO (&readfds);
1830         FD_SET (fb->fd, &readfds);
1831         do
1832         {
1833             int numfds;
1834
1835             do {
1836                 /* This used to select on exceptions too, but as far
1837                    as I know there was never any reason to do that and
1838                    SCO doesn't let you select on exceptions on pipes.  */
1839                 numfds = fd_select (fb->fd + 1, &readfds, NULL, NULL, NULL);
1840                 if (numfds < 0 && errno != EINTR)
1841                 {
1842                     status = errno;
1843                     goto block_done;
1844                 }
1845             } while (numfds < 0);
1846
1847             nbytes = read (fb->fd, data + *got, size - *got);
1848
1849             if (nbytes == 0)
1850             {
1851                 /* End of file.  This assumes that we are using POSIX or BSD
1852                    style nonblocking I/O.  On System V we will get a zero
1853                    return if there is no data, even when not at EOF.  */
1854                 if (*got)
1855                 {
1856                     /* We already read some data, so return no error, counting
1857                      * on the fact that we will read EOF again next time.
1858                      */
1859                     status = 0;
1860                     break;
1861                 }
1862                 else
1863                 {
1864                     /* Return EOF.  */
1865                     status = -1;
1866                     break;
1867                 }
1868             }
1869
1870             if (nbytes < 0)
1871             {
1872                 /* Some error occurred.  */
1873                 if (!blocking_error (errno))
1874                 {
1875                     status = errno;
1876                     break;
1877                 }
1878                 /* else Everything's fine, we just didn't get any data.  */
1879             }
1880
1881             *got += nbytes;
1882         } while (*got < need);
1883
1884 block_done:
1885         if (status == 0 || status == -1)
1886         {
1887             int newstatus;
1888
1889             /* OK or EOF - Reset block.  */
1890             newstatus = fd_buffer_block (fb, true);
1891             if (newstatus) status = newstatus;
1892         }
1893         return status;
1894     }
1895
1896     /* The above will always return.  Handle non-blocking read.  */
1897     nbytes = read (fb->fd, data, size);
1898
1899     if (nbytes > 0)
1900     {
1901         *got = nbytes;
1902         return 0;
1903     }
1904
1905     if (nbytes == 0)
1906         /* End of file.  This assumes that we are using POSIX or BSD
1907            style nonblocking I/O.  On System V we will get a zero
1908            return if there is no data, even when not at EOF.  */
1909         return -1;
1910
1911     /* Some error occurred.  */
1912     if (blocking_error (errno))
1913         /* Everything's fine, we just didn't get any data.  */
1914         return 0;
1915
1916     return errno;
1917 }
1918
1919
1920
1921 /* The buffer output function for a buffer built on a file descriptor.  */
1922
1923 static int
1924 fd_buffer_output (void *closure, const char *data, size_t have, size_t *wrote)
1925 {
1926     struct fd_buffer *fd = closure;
1927
1928     *wrote = 0;
1929
1930     while (have > 0)
1931     {
1932         int nbytes;
1933
1934         nbytes = write (fd->fd, data, have);
1935
1936         if (nbytes <= 0)
1937         {
1938             if (! fd->blocking
1939                 && (nbytes == 0 || blocking_error (errno)))
1940             {
1941                 /* A nonblocking write failed to write any data.  Just
1942                    return.  */
1943                 return 0;
1944             }
1945
1946             /* Some sort of error occurred.  */
1947
1948             if (nbytes == 0)
1949                 return EIO;
1950
1951             return errno;
1952         }
1953
1954         *wrote += nbytes;
1955         data += nbytes;
1956         have -= nbytes;
1957     }
1958
1959     return 0;
1960 }
1961
1962
1963
1964 /* The buffer flush function for a buffer built on a file descriptor.  */
1965 static int
1966 fd_buffer_flush (void *closure)
1967 {
1968     /* We don't need to do anything here.  Our fd doesn't have its own buffer
1969      * and syncing won't do anything but slow us down.
1970      *
1971      * struct fd_buffer *fb = closure;
1972      *
1973      * if (fsync (fb->fd) < 0 && errno != EROFS && errno != EINVAL)
1974      *     return errno;
1975      */
1976     return 0;
1977 }
1978
1979
1980
1981 static struct stat devnull;
1982 static int devnull_set = -1;
1983
1984 /* The buffer block function for a buffer built on a file descriptor.  */
1985 static int
1986 fd_buffer_block (void *closure, bool block)
1987 {
1988     struct fd_buffer *fb = closure;
1989 # if defined (F_GETFL) && defined (O_NONBLOCK) && defined (F_SETFL)
1990     int flags;
1991
1992     flags = fcntl (fb->fd, F_GETFL, 0);
1993     if (flags < 0)
1994         return errno;
1995
1996     if (block)
1997         flags &= ~O_NONBLOCK;
1998     else
1999         flags |= O_NONBLOCK;
2000
2001     if (fcntl (fb->fd, F_SETFL, flags) < 0)
2002     {
2003         /*
2004          * BSD returns ENODEV when we try to set block/nonblock on /dev/null.
2005          * BSDI returns ENOTTY when we try to set block/nonblock on /dev/null.
2006          */
2007         struct stat sb;
2008         int save_errno = errno;
2009         bool isdevnull = false;
2010
2011         if (devnull_set == -1)
2012             devnull_set = stat ("/dev/null", &devnull);
2013
2014         if (devnull_set >= 0)
2015             /* Equivalent to /dev/null ? */
2016             isdevnull = (fstat (fb->fd, &sb) >= 0
2017                          && sb.st_dev == devnull.st_dev
2018                          && sb.st_ino == devnull.st_ino
2019                          && sb.st_mode == devnull.st_mode
2020                          && sb.st_uid == devnull.st_uid
2021                          && sb.st_gid == devnull.st_gid
2022                          && sb.st_size == devnull.st_size
2023                          && sb.st_blocks == devnull.st_blocks
2024                          && sb.st_blksize == devnull.st_blksize);
2025         if (isdevnull)
2026             errno = 0;
2027         else
2028         {
2029             errno = save_errno;
2030             return errno;
2031         }
2032     }
2033 # endif /* F_GETFL && O_NONBLOCK && F_SETFL */
2034
2035     fb->blocking = block;
2036
2037     return 0;
2038 }
2039
2040
2041
2042 static int
2043 fd_buffer_get_fd (void *closure)
2044 {
2045     struct fd_buffer *fb = closure;
2046     return fb->fd;
2047 }
2048
2049
2050
2051 /* The buffer shutdown function for a buffer built on a file descriptor.
2052  *
2053  * This function disposes of memory allocated for this buffer.
2054  */
2055 static int
2056 fd_buffer_shutdown (struct buffer *buf)
2057 {
2058     struct fd_buffer *fb = buf->closure;
2059     struct stat s;
2060     bool closefd, statted;
2061
2062     /* Must be an open pipe, socket, or file.  What could go wrong? */
2063     if (fstat (fb->fd, &s) == -1) statted = false;
2064     else statted = true;
2065     /* Don't bother to try closing the FD if we couldn't stat it.  This
2066      * probably won't work.
2067      *
2068      * (buf_shutdown() on some of the server/child communication pipes is
2069      * getting EBADF on both the fstat and the close.  I'm not sure why -
2070      * perhaps they were alredy closed somehow?
2071      */
2072     closefd = statted;
2073
2074     /* Flush the buffer if possible.  */
2075     if (buf->flush)
2076     {
2077         buf_flush (buf, 1);
2078         buf->flush = NULL;
2079     }
2080
2081     if (buf->input)
2082     {
2083         /* There used to be a check here for unread data in the buffer of
2084          * the pipe, but it was deemed unnecessary and possibly dangerous.  In
2085          * some sense it could be second-guessing the caller who requested it
2086          * closed, as well.
2087          */
2088
2089 /* FIXME:
2090  *
2091  * This mess of #ifdefs is hard to read.  There must be some relation between
2092  * the macros being checked which at least deserves comments - if
2093  * SHUTDOWN_SERVER, NO_SOCKET_TO_FD, & START_RSH_WITH_POPEN_RW were completely
2094  * independant, then the next few lines could easily refuse to compile.
2095  *
2096  * The note below about START_RSH_WITH_POPEN_RW never being set when
2097  * SHUTDOWN_SERVER is defined means that this code would always break on
2098  * systems with SHUTDOWN_SERVER defined and thus the comment must now be
2099  * incorrect or the code was broken since the comment was written.
2100  */
2101 # ifdef SHUTDOWN_SERVER
2102         if (fb->root && fb->root->method != server_method)
2103 # endif
2104 # ifndef NO_SOCKET_TO_FD
2105         {
2106             /* shutdown() sockets */
2107             if (statted && S_ISSOCK (s.st_mode))
2108                 shutdown (fb->fd, 0);
2109         }
2110 # endif /* NO_SOCKET_TO_FD */
2111 # ifdef START_RSH_WITH_POPEN_RW
2112 /* Can't be set with SHUTDOWN_SERVER defined */
2113         /* FIXME: This is now certainly broken since pclose is defined by ANSI
2114          * C to accept a FILE * argument.  The switch will need to happen at a
2115          * higher abstraction level to switch between initializing stdio & fd
2116          * buffers on systems that need this (or maybe an fd buffer that keeps
2117          * track of the FILE * could be used - I think flushing the stream
2118          * before beginning exclusive access via the FD is OK.
2119          */
2120         else if (fb->root && pclose (fb->fd) == EOF)
2121         {
2122             error (1, errno, "closing connection to %s",
2123                    fb->root->hostname);
2124             closefd = false;
2125         }
2126 # endif /* START_RSH_WITH_POPEN_RW */
2127
2128         buf->input = NULL;
2129     }
2130     else if (buf->output)
2131     {
2132 # ifdef SHUTDOWN_SERVER
2133         /* FIXME:  Should have a SHUTDOWN_SERVER_INPUT &
2134          * SHUTDOWN_SERVER_OUTPUT
2135          */
2136         if (fb->root && fb->root->method == server_method)
2137             SHUTDOWN_SERVER (fb->fd);
2138         else
2139 # endif
2140 # ifndef NO_SOCKET_TO_FD
2141         /* shutdown() sockets */
2142         if (statted && S_ISSOCK (s.st_mode))
2143             shutdown (fb->fd, 1);
2144 # else
2145         {
2146         /* I'm not sure I like this empty block, but the alternative
2147          * is another nested NO_SOCKET_TO_FD switch as above.
2148          */
2149         }
2150 # endif /* NO_SOCKET_TO_FD */
2151
2152         buf->output = NULL;
2153     }
2154
2155     if (statted && closefd && close (fb->fd) == -1)
2156     {
2157         if (server_active)
2158         {
2159             /* Syslog this? */
2160         }
2161 # ifdef CLIENT_SUPPORT
2162         else if (fb->root)
2163             error (1, errno, "closing down connection to %s",
2164                    fb->root->hostname);
2165             /* EXITS */
2166 # endif /* CLIENT_SUPPORT */
2167
2168         error (0, errno, "closing down buffer");
2169     }
2170
2171     /* If we were talking to a process, make sure it exited */
2172     if (fb->child_pid)
2173     {
2174         int w;
2175
2176         do
2177             w = waitpid (fb->child_pid, NULL, 0);
2178         while (w == -1 && errno == EINTR);
2179         if (w == -1)
2180             error (1, errno, "waiting for process %d", fb->child_pid);
2181     }
2182
2183     free (buf->closure);
2184     buf->closure = NULL;
2185
2186     return 0;
2187 }
2188 #endif /* defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) */