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