Dolda2000 GitWeb / ashd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
accesslog: Use bufio for filtering instead of stdio.
[ashd.git] / lib / bufio.c
CommitLineData
4930589b
FT		 1/*
2 ashd - A Sane HTTP Daemon
3 Copyright (C) 2008 Fredrik Tolf <fredrik@dolda2000.com>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17*/
18
19#ifdef HAVE_CONFIG_H
20#include <config.h>
21#endif
22#include <stdlib.h>
23#include <string.h>
24#include <errno.h>
25
26#include <utils.h>
27#include <bufio.h>
28
29struct bufio *bioopen(void *pdata, struct bufioops *ops)
30{
31 struct bufio *bio;
32
33 omalloc(bio);
34 bio->pdata = pdata;
35 bio->ops = ops;
36 bio->bufhint = 4096;
37 return(bio);
38}
39
40int bioclose(struct bufio *bio)
41{
42 int rv;
43
44 bioflush(bio);
45 if(bio->ops->close)
46 rv = bio->ops->close(bio->pdata);
47 else
48 rv = 0;
49 buffree(bio->rbuf);
50 buffree(bio->wbuf);
51 free(bio);
52 return(rv);
53}
54
55size_t biordata(struct bufio *bio)
56{
57 return(bio->rbuf.d - bio->rh);
58}
59
60size_t biorspace(struct bufio *bio)
61{
62 if((bio->rbuf.d - bio->rh) >= bio->bufhint)
63 return(0);
64 return(bio->bufhint - (bio->rbuf.d - bio->rh));
65}
66
67int bioeof(struct bufio *bio)
68{
69 return(bio->eof && (bio->rh >= bio->rbuf.d));
70}
71
72static ssize_t biofill(struct bufio *bio)
73{
74 size_t ns;
75 ssize_t ret;
76
77 if(!bio->ops->read) {
78 bio->eof = 1;
79 return(0);
80 }
81 if(bio->eof)
82 return(0);
83 if(bio->rh == bio->rbuf.d)
84 bio->rh = bio->rbuf.d = 0;
85 if(bio->rbuf.d == bio->rbuf.s) {
86 if(bio->rh > 0) {
87 memmove(bio->rbuf.b, bio->rbuf.b + bio->rh, bio->rbuf.d -= bio->rh);
88 bio->rh = 0;
89 } else {
90 if((ns = bio->rbuf.s * 2) < bio->bufhint)
91 ns = bio->bufhint;
92 sizebuf(bio->rbuf, ns);
93 }
94 }
95 if((bio->rbuf.s > bio->bufhint) && (bio->rbuf.d < bio->bufhint))
96 bio->rbuf.b = srealloc(bio->rbuf.b, bio->rbuf.s = bio->bufhint);
97 ret = bio->ops->read(bio->pdata, bio->rbuf.b + bio->rbuf.d, bio->rbuf.s - bio->rbuf.d);
98 if(ret < 0) {
99 bio->err = errno;
100 return(-1);
101 } else if(ret == 0) {
102 bio->eof = 1;
103 return(0);
104 }
105 bio->rbuf.d += ret;
106 return(bio->rbuf.d - bio->rh);
107}
108
109ssize_t biorensure(struct bufio *bio, size_t bytes)
110{
111 ssize_t ret;
112
113 while(bio->rbuf.d - bio->rh < bytes) {
114 if((ret = biofill(bio)) <= 0)
115 return(ret);
116 }
117 return(bio->rbuf.d - bio->rh);
118}
119
120ssize_t biofillsome(struct bufio *bio)
121{
122 return(biofill(bio));
123}
124
125int biogetc(struct bufio *bio)
126{
127 ssize_t ret;
128
129 while(bio->rbuf.d <= bio->rh) {
130 if((ret = biofill(bio)) <= 0)
131 return(EOF);
132 }
133 return((unsigned char)bio->rbuf.b[bio->rh++]);
134}
135
136ssize_t bioreadsome(struct bufio *bio, void *buf, size_t len)
137{
138 ssize_t ret;
139
140 if((bio->rh >= bio->rbuf.d) && ((ret = biofill(bio)) <= 0))
141 return(ret);
142 ret = min(len, bio->rbuf.d - bio->rh);
143 memcpy(buf, bio->rbuf.b + bio->rh, ret);
144 bio->rh += ret;
145 return(ret);
146}
147
148size_t biowdata(struct bufio *bio)
149{
150 return(bio->wbuf.d - bio->wh);
151}
152
153size_t biowspace(struct bufio *bio)
154{
155 if((bio->wbuf.d - bio->wh) >= bio->bufhint)
156 return(0);
157 return(bio->bufhint - (bio->wbuf.d - bio->wh));
158}
159
160int bioflush(struct bufio *bio)
161{
162 ssize_t ret;
163
164 while(bio->wh < bio->wbuf.d) {
165 ret = bio->ops->write(bio->pdata, bio->wbuf.b + bio->wh, bio->wbuf.d - bio->wh);
166 if(ret < 0) {
167 bio->err = errno;
168 return(-1);
169 }
170 bio->wh += ret;
171 }
172 return(0);
173}
174
175int bioflushsome(struct bufio *bio)
176{
177 ssize_t ret;
178
179 if(bio->wh < bio->wbuf.d) {
180 ret = bio->ops->write(bio->pdata, bio->wbuf.b + bio->wh, bio->wbuf.d - bio->wh);
181 if(ret < 0) {
182 bio->err = errno;
183 return(-1);
184 }
185 bio->wh += ret;
186 return(1);
187 } else {
188 return(0);
189 }
190}
191
192ssize_t biowensure(struct bufio *bio, size_t bytes)
193{
194 if(bio->wbuf.s - bio->wbuf.d < bytes) {
195 if(!bio->ops->write) {
196 errno = bio->err = EPIPE;
197 return(-1);
198 }
199 if(bioflush(bio) < 0)
200 return(-1);
201 bio->wh = bio->wbuf.d = 0;
202 if((bio->wbuf.s > bio->bufhint) && (bytes <= bio->bufhint))
203 bio->wbuf.b = srealloc(bio->wbuf.b, bio->wbuf.s = bio->bufhint);
204 else
205 sizebuf(bio->wbuf, (bytes < bio->bufhint)?bio->bufhint:bytes);
206 }
207 return(0);
208}
209
210int bioputc(struct bufio *bio, int c)
211{
212 if(biowensure(bio, 1) < 0)
213 return(-1);
214 bio->wbuf.b[bio->wbuf.d++] = c;
215 return(0);
216}
217
218ssize_t biowrite(struct bufio *bio, const void *data, size_t len)
219{
220 ssize_t wb, ret;
221
222 wb = 0;
223 while(len > 0) {
224 if(biowensure(bio, min(len, bio->bufhint)) < 0) {
225 if(wb > 0)
226 return(wb);
227 return(-1);
228 }
229 if(len < bio->wbuf.s - bio->wbuf.d) {
230 memcpy(bio->wbuf.b + bio->wbuf.d, data, len);
231 wb += len;
232 len = 0;
233 } else {
234 if(bioflush(bio) < 0) {
235 if(wb > 0)
236 return(wb);
237 return(-1);
238 }
239 bio->wh = bio->wbuf.d = 0;
240 ret = bio->ops->write(bio->pdata, data, len);
241 if(ret < 0) {
242 if(wb > 0)
243 return(wb);
244 bio->err = errno;
245 return(-1);
246 }
247 data += ret; len -= ret; wb += ret;
248 }
249 }
250 return(0);
251}
252
253ssize_t biowritesome(struct bufio *bio, const void *data, size_t len)
254{
255 ssize_t ret;
256
257 sizebuf(bio->wbuf, bio->bufhint);
258 if(bio->wh == bio->wbuf.d)
259 bio->wh = bio->wbuf.d = 0;
260 if(bio->wbuf.d == bio->wbuf.s) {
261 if(bio->wh > 0)
262 memmove(bio->wbuf.b, bio->wbuf.b + bio->wh, bio->wbuf.d -= bio->wh);
263 }
264 ret = min(len, bio->wbuf.s - bio->wbuf.d);
265 memcpy(bio->wbuf.b + bio->wbuf.d, data, ret);
266 bio->wbuf.d += ret;
267 if((bioflushsome(bio) < 0) && (ret == 0))
268 return(-1);
269 return(ret);
270}
271
272int bioprintf(struct bufio *bio, const char *format, ...)
273{
274 va_list args;
275 int ret;
276
277 if(biowensure(bio, strlen(format)) < 0)
278 return(-1);
279 while(1) {
280 va_start(args, format);
281 ret = vsnprintf(bio->wbuf.b + bio->wbuf.d, bio->wbuf.s - bio->wbuf.d, format, args);
282 va_end(args);
283 if(ret <= bio->wbuf.s - bio->wbuf.d) {
284 bio->wbuf.d += ret;
285 return(0);
286 }
287 if(biowensure(bio, ret) < 0)
288 return(-1);
289 }
290}
291
292ssize_t biocopysome(struct bufio *dst, struct bufio *src)
293{
294 ssize_t ret;
295
296 if(src->rh >= src->rbuf.d)
297 return(0);
298 if((ret = biowritesome(dst, src->rbuf.b + src->rh, src->rbuf.d - src->rh)) < 0)
299 return(-1);
300 src->rh += ret;
301 return(ret);
302}
A Sane HTTP Daemon