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 /* Declarations concerning the buffer data structure. */ 16 17 #if defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) 18 19 # include "getpagesize.h" 20 21 /* 22 * We must read data from a child process and send it across the 23 * network. We do not want to block on writing to the network, so we 24 * store the data from the child process in memory. A BUFFER 25 * structure holds the status of one communication, and uses a linked 26 * list of buffer_data structures to hold data. 27 */ 28 29 struct buffer; 30 31 typedef int (*type_buf_input) (void *, char *, size_t, size_t, size_t *); 32 typedef int (*type_buf_output) (void *, const char *, size_t, size_t *); 33 typedef int (*type_buf_flush) (void *); 34 typedef int (*type_buf_block) (void *, bool); 35 typedef int (*type_buf_get_fd) (void *); 36 typedef int (*type_buf_shutdown) (struct buffer *); 37 typedef void (*type_buf_memory_error) (struct buffer *); 38 39 struct buffer 40 { 41 /* Data. */ 42 struct buffer_data *data; 43 44 /* Last buffer on data chain. */ 45 struct buffer_data *last; 46 47 /* Nonzero if the buffer is in nonblocking mode. */ 48 bool nonblocking; 49 50 /* Functions must be provided to transfer data in and out of the 51 buffer. Either the input or output field must be set, but not 52 both. */ 53 54 /* Read data into the buffer DATA. There is room for up to SIZE 55 bytes. In blocking mode, wait until some input, at least NEED 56 bytes, is available (NEED may be 0 but that is the same as NEED 57 == 1). In non-blocking mode return immediately no matter how 58 much input is available; NEED is ignored. Return 0 on success, 59 or -1 on end of file, or an errno code. Set the number of 60 bytes read in *GOT. 61 62 If there are a nonzero number of bytes available, less than NEED, 63 followed by end of file, just read those bytes and return 0. */ 64 type_buf_input input; 65 66 /* Write data. This should write up to HAVE bytes from DATA. 67 This should return 0 on success, or an errno code. It should 68 set the number of bytes written in *WROTE. */ 69 type_buf_output output; 70 71 /* Flush any data which may be buffered up after previous calls to 72 OUTPUT. This should return 0 on success, or an errno code. */ 73 type_buf_flush flush; 74 75 /* Change the blocking mode of the underlying communication 76 stream. If BLOCK is non-zero, it should be placed into 77 blocking mode. Otherwise, it should be placed into 78 non-blocking mode. This should return 0 on success, or an 79 errno code. */ 80 type_buf_block block; 81 82 /* Return the file descriptor underlying this buffer, if any, or -1 83 * otherwise. 84 */ 85 type_buf_get_fd get_fd; 86 87 /* Shut down the communication stream. This does not mean that it 88 should be closed. It merely means that no more data will be 89 read or written, and that any final processing that is 90 appropriate should be done at this point. This may be NULL. 91 It should return 0 on success, or an errno code. This entry 92 point exists for the compression code. */ 93 type_buf_shutdown shutdown; 94 95 /* This field is passed to the INPUT, OUTPUT, and BLOCK functions. */ 96 void *closure; 97 98 /* Function to call if we can't allocate memory. */ 99 type_buf_memory_error memory_error; 100 }; 101 102 /* Data is stored in lists of these structures. */ 103 104 struct buffer_data 105 { 106 /* Next buffer in linked list. */ 107 struct buffer_data *next; 108 109 /* 110 * A pointer into the data area pointed to by the text field. This 111 * is where to find data that has not yet been written out. 112 */ 113 char *bufp; 114 115 /* The number of data bytes found at BUFP. */ 116 size_t size; 117 118 /* 119 * Actual buffer. This never changes after the structure is 120 * allocated. The buffer is BUFFER_DATA_SIZE bytes. 121 */ 122 char *text; 123 }; 124 125 /* The size we allocate for each buffer_data structure. */ 126 #define BUFFER_DATA_SIZE getpagesize () 127 128 /* The type of a function passed as a memory error handler. */ 129 typedef void (*BUFMEMERRPROC) (struct buffer *); 130 131 struct buffer *buf_initialize (type_buf_input, 132 type_buf_output, 133 type_buf_flush, 134 type_buf_block, 135 type_buf_get_fd, 136 type_buf_shutdown, 137 type_buf_memory_error, 138 void *); 139 void buf_free (struct buffer *); 140 struct buffer *buf_nonio_initialize (void (*) (struct buffer *)); 141 struct buffer *compress_buffer_initialize (struct buffer *, int, int, 142 void (*) (struct buffer *)); 143 struct buffer *packetizing_buffer_initialize 144 (struct buffer *, int (*) (void *, const char *, char *, size_t), 145 int (*) (void *, const char *, char *, size_t, size_t *), void *, 146 void (*) (struct buffer *)); 147 int buf_empty (struct buffer *); 148 int buf_empty_p (struct buffer *); 149 void buf_output (struct buffer *, const char *, size_t); 150 void buf_output0 (struct buffer *, const char *); 151 void buf_append_char (struct buffer *, int); 152 int buf_send_output (struct buffer *); 153 int buf_flush (struct buffer *, bool); 154 int set_nonblock (struct buffer *); 155 int set_block (struct buffer *); 156 int buf_send_counted (struct buffer *); 157 int buf_send_special_count (struct buffer *, int); 158 void buf_append_data (struct buffer *, struct buffer_data *, 159 struct buffer_data *); 160 void buf_append_buffer (struct buffer *, struct buffer *); 161 int buf_read_file (FILE *, long, struct buffer_data **, struct buffer_data **); 162 int buf_read_file_to_eof (FILE *, struct buffer_data **, 163 struct buffer_data **); 164 int buf_input_data (struct buffer *, size_t *); 165 int buf_read_line (struct buffer *, char **, size_t *); 166 int buf_read_short_line (struct buffer *buf, char **line, size_t *lenp, 167 size_t max); 168 int buf_read_data (struct buffer *, size_t, char **, size_t *); 169 void buf_copy_lines (struct buffer *, struct buffer *, int); 170 int buf_copy_counted (struct buffer *, struct buffer *, int *); 171 int buf_chain_length (struct buffer_data *); 172 int buf_length (struct buffer *); 173 int buf_get_fd (struct buffer *); 174 int buf_shutdown (struct buffer *); 175 #ifdef PROXY_SUPPORT 176 void buf_copy_data (struct buffer *buf, struct buffer_data *data, 177 struct buffer_data *last); 178 #endif /* PROXY_SUPPORT */ 179 void buf_free_data (struct buffer *); 180 181 #ifdef SERVER_FLOWCONTROL 182 int buf_count_mem (struct buffer *); 183 #endif /* SERVER_FLOWCONTROL */ 184 185 struct buffer * 186 fd_buffer_initialize (int fd, pid_t child_pid, cvsroot_t *root, bool input, 187 void (*memory) (struct buffer *)); 188 189 /* EWOULDBLOCK is not defined by POSIX, but some BSD systems will 190 return it, rather than EAGAIN, for nonblocking writes. */ 191 # ifdef EWOULDBLOCK 192 # define blocking_error(err) ((err) == EWOULDBLOCK || (err) == EAGAIN) 193 # else 194 # define blocking_error(err) ((err) == EAGAIN) 195 # endif 196 #endif /* defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) */ 197
Indexes created Sat Jun 20 00:25:23 UTC 2026