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
29struct buffer;
30
31typedef int (*type_buf_input) (void *, char *, size_t, size_t, size_t *);
32typedef int (*type_buf_output) (void *, const char *, size_t, size_t *);
33typedef int (*type_buf_flush) (void *);
34typedef int (*type_buf_block) (void *, bool);
35typedef int (*type_buf_get_fd) (void *);
36typedef int (*type_buf_shutdown) (struct buffer *);
37typedef void (*type_buf_memory_error) (struct buffer *);
38
39struct 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
104struct 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.  */
129typedef void (*BUFMEMERRPROC) (struct buffer *);
130
131struct 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 *);
139void buf_free (struct buffer *);
140struct buffer *buf_nonio_initialize (void (*) (struct buffer *));
141struct buffer *compress_buffer_initialize (struct buffer *, int, int,
142					   void (*) (struct buffer *));
143struct 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 *));
147int buf_empty (struct buffer *);
148int buf_empty_p (struct buffer *);
149void buf_output (struct buffer *, const char *, size_t);
150void buf_output0 (struct buffer *, const char *);
151void buf_append_char (struct buffer *, int);
152int buf_send_output (struct buffer *);
153int buf_flush (struct buffer *, bool);
154int set_nonblock (struct buffer *);
155int set_block (struct buffer *);
156int buf_send_counted (struct buffer *);
157int buf_send_special_count (struct buffer *, int);
158void buf_append_data (struct buffer *, struct buffer_data *,
159		      struct buffer_data *);
160void buf_append_buffer (struct buffer *, struct buffer *);
161int buf_read_file (FILE *, long, struct buffer_data **, struct buffer_data **);
162int buf_read_file_to_eof (FILE *, struct buffer_data **,
163			  struct buffer_data **);
164int buf_input_data (struct buffer *, size_t *);
165int buf_read_line (struct buffer *, char **, size_t *);
166int buf_read_short_line (struct buffer *buf, char **line, size_t *lenp,
167                         size_t max);
168int buf_read_data (struct buffer *, size_t, char **, size_t *);
169void buf_copy_lines (struct buffer *, struct buffer *, int);
170int buf_copy_counted (struct buffer *, struct buffer *, int *);
171int buf_chain_length (struct buffer_data *);
172int buf_length (struct buffer *);
173int buf_get_fd (struct buffer *);
174int buf_shutdown (struct buffer *);
175#ifdef PROXY_SUPPORT
176void buf_copy_data (struct buffer *buf, struct buffer_data *data,
177                    struct buffer_data *last);
178#endif /* PROXY_SUPPORT */
179void buf_free_data (struct buffer *);
180
181#ifdef SERVER_FLOWCONTROL
182int buf_count_mem (struct buffer *);
183#endif /* SERVER_FLOWCONTROL */
184
185struct buffer *
186fd_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