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