Changes to let the key listing use estream to help systems without
[gnupg.git] / common / estream.h
1 /* estream.h - Extended stream I/O/ Library
2  * Copyright (C) 2004 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 \f
30 /* Forward declaration for the (opaque) internal type.  */
31 struct estream_internal;
32
33 /* The definition of this struct is entirely private.  You must not
34    use it for anything.  It is only here so some functions can be
35    implemented as macros.  */
36 struct es__stream
37 {
38   /* The layout of this struct must never change.  It may be grown,
39      but only if all functions which access the new members are
40      versioned.  */
41
42   /* A pointer to the stream buffer.  */
43   unsigned char *buffer;
44
45   /* The size of the buffer in bytes.  */
46   size_t buffer_size;
47
48   /* The length of the usable data in the buffer, only valid when in
49      read mode (see flags).  */
50   size_t data_len;
51
52   /* The current position of the offset pointer, valid in read and
53      write mode.  */
54   size_t data_offset;
55
56   size_t data_flushed;
57   unsigned char *unread_buffer;
58   size_t unread_buffer_size;
59
60   /* The number of unread bytes.  */
61   size_t unread_data_len;
62
63   /* Various flags.  */
64 #define ES__FLAG_WRITING        (1 << 0)
65   unsigned int flags;
66
67   /* A pointer to our internal data for this stream.  */
68   struct estream_internal *intern;
69 };
70
71 /* The opaque type for an estream.  */
72 typedef struct es__stream *estream_t;
73
74 \f
75 typedef ssize_t (*es_cookie_read_function_t) (void *cookie,
76                                               void *buffer, size_t size);
77 typedef ssize_t (*es_cookie_write_function_t) (void *cookie,
78                                                const void *buffer,
79                                                size_t size);
80 typedef int (*es_cookie_seek_function_t) (void *cookie,
81                                           off_t *pos, int whence);
82 typedef int (*es_cookie_close_function_t) (void *cookie);
83
84 typedef struct es_cookie_io_functions
85 {
86   es_cookie_read_function_t func_read;
87   es_cookie_write_function_t func_write;
88   es_cookie_seek_function_t func_seek;
89   es_cookie_close_function_t func_close;
90 } es_cookie_io_functions_t;
91
92 \f
93 #ifndef ES__RESTRICT
94 #  if defined __GNUC__ && defined __GNUC_MINOR__
95 #    if  (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 92))
96 #      define ES__RESTRICT __restrict__
97 #    endif
98 #  endif
99 #endif
100 #ifndef ES__RESTRICT
101 #  define ES__RESTRICT
102 #endif
103
104 int es_init (void);
105
106 estream_t es_fopen (const char *ES__RESTRICT path,
107                     const char *ES__RESTRICT mode);
108 estream_t es_mopen (unsigned char *ES__RESTRICT data,
109                     size_t data_n, size_t data_len,
110                     unsigned int grow,
111                     void *(*func_realloc) (void *mem, size_t size),
112                     void (*func_free) (void *mem),
113                     const char *ES__RESTRICT mode);
114 estream_t es_open_memstream (char **ptr, size_t *size);
115 estream_t es_fdopen (int filedes, const char *mode);
116 estream_t es_freopen (const char *ES__RESTRICT path,
117                       const char *ES__RESTRICT mode,
118                       estream_t ES__RESTRICT stream);
119 estream_t es_fopencookie (void *ES__RESTRICT cookie,
120                           const char *ES__RESTRICT mode,
121                           es_cookie_io_functions_t functions);
122 int es_fclose (estream_t stream);
123 int es_fileno (estream_t stream);
124 int es_fileno_unlocked (estream_t stream);
125
126 void es_flockfile (estream_t stream);
127 int es_ftrylockfile (estream_t stream);
128 void es_funlockfile (estream_t stream);
129
130 int es_feof (estream_t stream);
131 int es_feof_unlocked (estream_t stream);
132 int es_ferror (estream_t stream);
133 int es_ferror_unlocked (estream_t stream);
134 void es_clearerr (estream_t stream);
135 void es_clearerr_unlocked (estream_t stream);
136
137 int es_fflush (estream_t stream);
138 int es_fseek (estream_t stream, long int offset, int whence);
139 int es_fseeko (estream_t stream, off_t offset, int whence);
140 long int es_ftell (estream_t stream);
141 off_t es_ftello (estream_t stream);
142 void es_rewind (estream_t stream);
143
144 int es_fgetc (estream_t stream);
145 int es_fputc (int c, estream_t stream);
146
147 int _es_getc_underflow (estream_t stream);
148 int _es_putc_overflow (int c, estream_t stream);
149
150 #define es_getc_unlocked(stream)                                \
151   (((! ((stream)->flags & 1))                                   \
152     && ((stream)->data_offset < (stream)->data_len)             \
153     && (! (stream)->unread_data_len))                           \
154   ? ((int) (stream)->buffer[((stream)->data_offset)++])         \
155   : _es_getc_underflow ((stream)))
156
157 #define es_putc_unlocked(c, stream)                             \
158   ((((stream)->flags & 1)                                       \
159     && ((stream)->data_offset < (stream)->buffer_size)          \
160     && (c != '\n'))                                             \
161   ? ((int) ((stream)->buffer[((stream)->data_offset)++] = (c))) \
162   : _es_putc_overflow ((c), (stream)))
163
164 #define es_getc(stream)    es_fgetc (stream)
165 #define es_putc(c, stream) es_fputc (c, stream)
166
167 int es_ungetc (int c, estream_t stream);
168
169 int es_read (estream_t ES__RESTRICT stream,
170              void *ES__RESTRICT buffer, size_t bytes_to_read,
171              size_t *ES__RESTRICT bytes_read);
172 int es_write (estream_t ES__RESTRICT stream,
173               const void *ES__RESTRICT buffer, size_t bytes_to_write,
174               size_t *ES__RESTRICT bytes_written);
175 int es_write_sanitized (estream_t ES__RESTRICT stream,
176                         const void *ES__RESTRICT buffer, size_t length,
177                         const char *delimiters,
178                         size_t *ES__RESTRICT bytes_written);
179 int es_write_hexstring (estream_t ES__RESTRICT stream,
180                         const void *ES__RESTRICT buffer, size_t length,
181                         int reserved, size_t *ES__RESTRICT bytes_written);
182
183 size_t es_fread (void *ES__RESTRICT ptr, size_t size, size_t nitems,
184                  estream_t ES__RESTRICT stream);
185 size_t es_fwrite (const void *ES__RESTRICT ptr, size_t size, size_t memb,
186                   estream_t ES__RESTRICT stream);
187
188 char *es_fgets (char *ES__RESTRICT s, int n, estream_t ES__RESTRICT stream);
189 int es_fputs (const char *ES__RESTRICT s, estream_t ES__RESTRICT stream);
190
191 ssize_t es_getline (char *ES__RESTRICT *ES__RESTRICT lineptr,
192                     size_t *ES__RESTRICT n,
193                     estream_t stream);
194 ssize_t es_read_line (estream_t stream, 
195                       char **addr_of_buffer, size_t *length_of_buffer,
196                       size_t *max_length);
197 void es_free (void *a);
198
199 int es_fprintf (estream_t ES__RESTRICT stream,
200                 const char *ES__RESTRICT format, ...);
201 int es_vfprintf (estream_t ES__RESTRICT stream,
202                  const char *ES__RESTRICT format, va_list ap);
203
204 int es_setvbuf (estream_t ES__RESTRICT stream,
205                 char *ES__RESTRICT buf, int mode, size_t size);
206 void es_setbuf (estream_t ES__RESTRICT stream, char *ES__RESTRICT buf);
207
208 estream_t es_tmpfile (void);
209
210 void es_opaque_set (estream_t ES__RESTRICT stream, void *ES__RESTRICT opaque);
211 void *es_opaque_get (estream_t stream);
212
213
214
215 #ifdef GNUPG_MAJOR_VERSION
216 int es_write_sanitized_utf8_buffer (estream_t stream,
217                                     const void *buffer, size_t length, 
218                                     const char *delimiters,
219                                     size_t *bytes_written);
220 #endif /*GNUPG_MAJOR_VERSION*/
221
222
223 #endif /*ESTREAM_H*/
224