Fixed a problem in estream-printf.c.
[gnupg.git] / common / estream.h
1 /* estream.h - Extended stream I/O/ Library
2  * Copyright (C) 2004, 2005, 2006, 2007 g10 Code GmbH
3  *
4  * This file is part of Libestream.
5  *
6  * Libestream is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published
8  * by the Free Software Foundation; either version 2 of the License,
9  * or (at your option) any later version.
10  *
11  * Libestream is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with Libestream; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #ifndef ESTREAM_H
23 #define ESTREAM_H
24
25 #include <sys/types.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28
29 /* To use this file with libraries the following macro is useful:
30
31      #define _ESTREAM_EXT_SYM_PREFIX _foo_
32
33        This prefixes all external symbols with "_foo_".
34
35  */
36
37
38 #ifdef _ESTREAM_EXT_SYM_PREFIX
39 #ifndef _ESTREAM_PREFIX
40 #define _ESTREAM_PREFIX1(x,y)  x ## y
41 #define _ESTREAM_PREFIX2(x,y) _ESTREAM_PREFIX1(x,y)
42 #define _ESTREAM_PREFIX(x)    _ESTREAM_PREFIX2(_ESTREAM_EXT_SYM_PREFIX,x)
43 #endif /*_ESTREAM_PREFIX*/
44 #define es_fopen              _ESTREAM_PREFIX(es_fopen)
45 #define es_mopen              _ESTREAM_PREFIX(es_mopen)
46 #define es_open_memstream     _ESTREAM_PREFIX(es_open_memstream)
47 #define es_fdopen             _ESTREAM_PREFIX(es_fdopen)
48 #define es_fdopen_nc          _ESTREAM_PREFIX(es_fdopen_nc)
49 #define es_fpopen             _ESTREAM_PREFIX(es_fpopen)
50 #define es_fpopen_nc          _ESTREAM_PREFIX(es_fpopen_nc)
51 #define es_freopen            _ESTREAM_PREFIX(es_freopen)
52 #define es_fopencookie        _ESTREAM_PREFIX(es_fopencookie)
53 #define es_fclose             _ESTREAM_PREFIX(es_fclose)
54 #define es_fileno             _ESTREAM_PREFIX(es_fileno)
55 #define es_fileno_unlocked    _ESTREAM_PREFIX(es_fileno_unlocked)
56 #define es_flockfile          _ESTREAM_PREFIX(es_flockfile)
57 #define es_ftrylockfile       _ESTREAM_PREFIX(es_ftrylockfile)
58 #define es_funlockfile        _ESTREAM_PREFIX(es_funlockfile)
59 #define es_feof               _ESTREAM_PREFIX(es_feof)
60 #define es_feof_unlocked      _ESTREAM_PREFIX(es_feof_unlocked)
61 #define es_ferror             _ESTREAM_PREFIX(es_ferror)
62 #define es_ferror_unlocked    _ESTREAM_PREFIX(es_ferror_unlocked)
63 #define es_clearerr           _ESTREAM_PREFIX(es_clearerr)
64 #define es_clearerr_unlocked  _ESTREAM_PREFIX(es_clearerr_unlocked)
65 #define es_fflush             _ESTREAM_PREFIX(es_fflush)
66 #define es_fseek              _ESTREAM_PREFIX(es_fseek)
67 #define es_fseeko             _ESTREAM_PREFIX(es_fseeko)
68 #define es_ftell              _ESTREAM_PREFIX(es_ftell)
69 #define es_ftello             _ESTREAM_PREFIX(es_ftello)
70 #define es_rewind             _ESTREAM_PREFIX(es_rewind)
71 #define es_fgetc              _ESTREAM_PREFIX(es_fgetc)
72 #define es_fputc              _ESTREAM_PREFIX(es_fputc)
73 #define _es_getc_underflow    _ESTREAM_PREFIX(_es_getc_underflow)
74 #define _es_putc_overflow     _ESTREAM_PREFIX(_es_putc_overflow)
75 #define es_ungetc             _ESTREAM_PREFIX(es_ungetc)
76 #define es_read               _ESTREAM_PREFIX(es_read)
77 #define es_write              _ESTREAM_PREFIX(es_write)
78 #define es_write_sanitized    _ESTREAM_PREFIX(es_write_sanitized)
79 #define es_write_hexstring    _ESTREAM_PREFIX(es_write_hexstring)
80 #define es_fread              _ESTREAM_PREFIX(es_fread)
81 #define es_fwrite             _ESTREAM_PREFIX(es_fwrite)
82 #define es_fgets              _ESTREAM_PREFIX(es_fgets)
83 #define es_fputs              _ESTREAM_PREFIX(es_fputs)
84 #define es_getline            _ESTREAM_PREFIX(es_getline)
85 #define es_read_line          _ESTREAM_PREFIX(es_read_line)
86 #define es_free               _ESTREAM_PREFIX(es_free)
87 #define es_fprf               _ESTREAM_PREFIX(es_fprf)
88 #define es_vfprf              _ESTREAM_PREFIX(es_vfprf)
89 #define es_setvbuf            _ESTREAM_PREFIX(es_setvbuf)
90 #define es_setbuf             _ESTREAM_PREFIX(es_setbuf)
91 #define es_tmpfile            _ESTREAM_PREFIX(es_tmpfile)
92 #define es_opaque_set         _ESTREAM_PREFIX(es_opaque_set)
93 #define es_opaque_get         _ESTREAM_PREFIX(es_opaque_get)
94 #define es_write_sanitized_utf8_buffer  \
95               _ESTREAM_PREFIX(es_write_sanitized_utf8_buffer)
96 #endif /*_ESTREAM_EXT_SYM_PREFIX*/
97
98
99 #ifdef __cplusplus
100 extern "C"
101 {
102 #if 0
103 }
104 #endif
105 #endif
106
107
108 /* Forward declaration for the (opaque) internal type.  */
109 struct estream_internal;
110
111 /* The definition of this struct is entirely private.  You must not
112    use it for anything.  It is only here so some functions can be
113    implemented as macros.  */
114 struct es__stream
115 {
116   /* The layout of this struct must never change.  It may be grown,
117      but only if all functions which access the new members are
118      versioned.  */
119
120   /* A pointer to the stream buffer.  */
121   unsigned char *buffer;
122
123   /* The size of the buffer in bytes.  */
124   size_t buffer_size;
125
126   /* The length of the usable data in the buffer, only valid when in
127      read mode (see flags).  */
128   size_t data_len;
129
130   /* The current position of the offset pointer, valid in read and
131      write mode.  */
132   size_t data_offset;
133
134   size_t data_flushed;
135   unsigned char *unread_buffer;
136   size_t unread_buffer_size;
137
138   /* The number of unread bytes.  */
139   size_t unread_data_len;
140
141   /* Various flags.  */
142   struct {
143     unsigned int writing: 1;
144     unsigned int reserved: 7;
145   } flags;
146
147   /* A pointer to our internal data for this stream.  */
148   struct estream_internal *intern;
149 };
150
151 /* The opaque type for an estream.  */
152 typedef struct es__stream *estream_t;
153
154 \f
155 typedef ssize_t (*es_cookie_read_function_t) (void *cookie,
156                                               void *buffer, size_t size);
157 typedef ssize_t (*es_cookie_write_function_t) (void *cookie,
158                                                const void *buffer,
159                                                size_t size);
160 typedef int (*es_cookie_seek_function_t) (void *cookie,
161                                           off_t *pos, int whence);
162 typedef int (*es_cookie_close_function_t) (void *cookie);
163
164 typedef struct es_cookie_io_functions
165 {
166   es_cookie_read_function_t func_read;
167   es_cookie_write_function_t func_write;
168   es_cookie_seek_function_t func_seek;
169   es_cookie_close_function_t func_close;
170 } es_cookie_io_functions_t;
171
172 \f
173 #ifndef _ESTREAM_GCC_A_PRINTF
174 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
175 # define _ESTREAM_GCC_A_PRINTF( f, a )  __attribute__ ((format (printf,f,a)))
176 #else
177 # define _ESTREAM_GCC_A_PRINTF( f, a )
178 #endif
179 #endif /*_ESTREAM_GCC_A_PRINTF*/
180
181
182 #ifndef ES__RESTRICT
183 #  if defined __GNUC__ && defined __GNUC_MINOR__
184 #    if  (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 92))
185 #      define ES__RESTRICT __restrict__
186 #    endif
187 #  endif
188 #endif
189 #ifndef ES__RESTRICT
190 #  define ES__RESTRICT
191 #endif
192
193 int es_init (void);
194
195 estream_t es_fopen (const char *ES__RESTRICT path,
196                     const char *ES__RESTRICT mode);
197 estream_t es_mopen (unsigned char *ES__RESTRICT data,
198                     size_t data_n, size_t data_len,
199                     unsigned int grow,
200                     void *(*func_realloc) (void *mem, size_t size),
201                     void (*func_free) (void *mem),
202                     const char *ES__RESTRICT mode);
203 estream_t es_open_memstream (char **ptr, size_t *size);
204 estream_t es_fdopen (int filedes, const char *mode);
205 estream_t es_fdopen_nc (int filedes, const char *mode);
206 estream_t es_fpopen (FILE *fp, const char *mode);
207 estream_t es_fpopen_nc (FILE *fp, const char *mode);
208 estream_t es_freopen (const char *ES__RESTRICT path,
209                       const char *ES__RESTRICT mode,
210                       estream_t ES__RESTRICT stream);
211 estream_t es_fopencookie (void *ES__RESTRICT cookie,
212                           const char *ES__RESTRICT mode,
213                           es_cookie_io_functions_t functions);
214 int es_fclose (estream_t stream);
215 int es_fileno (estream_t stream);
216 int es_fileno_unlocked (estream_t stream);
217
218 void es_flockfile (estream_t stream);
219 int es_ftrylockfile (estream_t stream);
220 void es_funlockfile (estream_t stream);
221
222 int es_feof (estream_t stream);
223 int es_feof_unlocked (estream_t stream);
224 int es_ferror (estream_t stream);
225 int es_ferror_unlocked (estream_t stream);
226 void es_clearerr (estream_t stream);
227 void es_clearerr_unlocked (estream_t stream);
228
229 int es_fflush (estream_t stream);
230 int es_fseek (estream_t stream, long int offset, int whence);
231 int es_fseeko (estream_t stream, off_t offset, int whence);
232 long int es_ftell (estream_t stream);
233 off_t es_ftello (estream_t stream);
234 void es_rewind (estream_t stream);
235
236 int es_fgetc (estream_t stream);
237 int es_fputc (int c, estream_t stream);
238
239 int _es_getc_underflow (estream_t stream);
240 int _es_putc_overflow (int c, estream_t stream);
241
242 #define es_getc_unlocked(stream)                                \
243   (((!(stream)->flags.writing)                                  \
244     && ((stream)->data_offset < (stream)->data_len)             \
245     && (! (stream)->unread_data_len))                           \
246   ? ((int) (stream)->buffer[((stream)->data_offset)++])         \
247   : _es_getc_underflow ((stream)))
248
249 #define es_putc_unlocked(c, stream)                             \
250   (((stream)->flags.writing                                     \
251     && ((stream)->data_offset < (stream)->buffer_size)          \
252     && (c != '\n'))                                             \
253   ? ((int) ((stream)->buffer[((stream)->data_offset)++] = (c))) \
254   : _es_putc_overflow ((c), (stream)))
255
256 #define es_getc(stream)    es_fgetc (stream)
257 #define es_putc(c, stream) es_fputc (c, stream)
258
259 int es_ungetc (int c, estream_t stream);
260
261 int es_read (estream_t ES__RESTRICT stream,
262              void *ES__RESTRICT buffer, size_t bytes_to_read,
263              size_t *ES__RESTRICT bytes_read);
264 int es_write (estream_t ES__RESTRICT stream,
265               const void *ES__RESTRICT buffer, size_t bytes_to_write,
266               size_t *ES__RESTRICT bytes_written);
267 int es_write_sanitized (estream_t ES__RESTRICT stream,
268                         const void *ES__RESTRICT buffer, size_t length,
269                         const char *delimiters,
270                         size_t *ES__RESTRICT bytes_written);
271 int es_write_hexstring (estream_t ES__RESTRICT stream,
272                         const void *ES__RESTRICT buffer, size_t length,
273                         int reserved, size_t *ES__RESTRICT bytes_written);
274
275 size_t es_fread (void *ES__RESTRICT ptr, size_t size, size_t nitems,
276                  estream_t ES__RESTRICT stream);
277 size_t es_fwrite (const void *ES__RESTRICT ptr, size_t size, size_t memb,
278                   estream_t ES__RESTRICT stream);
279
280 char *es_fgets (char *ES__RESTRICT s, int n, estream_t ES__RESTRICT stream);
281 int es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream);
282
283 ssize_t es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr,
284                     size_t *ES__RESTRICT n,
285                     estream_t stream);
286 ssize_t es_read_line (estream_t stream,
287                       char **addr_of_buffer, size_t *length_of_buffer,
288                       size_t *max_length);
289 void es_free (void *a);
290
291 int es_fprintf (estream_t ES__RESTRICT stream,
292                 const char *ES__RESTRICT format, ...)
293      _ESTREAM_GCC_A_PRINTF(2,3);
294 int es_vfprintf (estream_t ES__RESTRICT stream,
295                  const char *ES__RESTRICT format, va_list ap)
296      _ESTREAM_GCC_A_PRINTF(2,0);
297 int es_setvbuf (estream_t ES__RESTRICT stream,
298                 char *ES__RESTRICT buf, int mode, size_t size);
299 void es_setbuf (estream_t ES__RESTRICT stream, char *ES__RESTRICT buf);
300
301 estream_t es_tmpfile (void);
302
303 void es_opaque_set (estream_t ES__RESTRICT stream, void *ES__RESTRICT opaque);
304 void *es_opaque_get (estream_t stream);
305
306
307 #ifdef GNUPG_MAJOR_VERSION
308 int es_write_sanitized_utf8_buffer (estream_t stream,
309                                     const void *buffer, size_t length,
310                                     const char *delimiters,
311                                     size_t *bytes_written);
312 #endif /*GNUPG_MAJOR_VERSION*/
313
314
315 #ifdef __cplusplus
316 }
317 #endif
318 #endif /*ESTREAM_H*/