Branch data Line data Source code
1 : : /*
2 : : * mbuf.c
3 : : * Memory buffer operations.
4 : : *
5 : : * Copyright (c) 2005 Marko Kreen
6 : : * All rights reserved.
7 : : *
8 : : * Redistribution and use in source and binary forms, with or without
9 : : * modification, are permitted provided that the following conditions
10 : : * are met:
11 : : * 1. Redistributions of source code must retain the above copyright
12 : : * notice, this list of conditions and the following disclaimer.
13 : : * 2. Redistributions in binary form must reproduce the above copyright
14 : : * notice, this list of conditions and the following disclaimer in the
15 : : * documentation and/or other materials provided with the distribution.
16 : : *
17 : : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 : : * SUCH DAMAGE.
28 : : *
29 : : * contrib/pgcrypto/mbuf.c
30 : : */
31 : :
32 : : #include "postgres.h"
33 : :
34 : : #include "mbuf.h"
35 : : #include "px.h"
36 : :
37 : : #define STEP (16*1024)
38 : :
39 : : struct MBuf
40 : : {
41 : : uint8 *data;
42 : : uint8 *data_end;
43 : : uint8 *read_pos;
44 : : uint8 *buf_end;
45 : : bool no_write;
46 : : bool own_data;
47 : : };
48 : :
49 : : int
50 : 2882 : mbuf_avail(MBuf *mbuf)
51 : : {
52 : 2882 : return mbuf->data_end - mbuf->read_pos;
53 : : }
54 : :
55 : : int
56 : 100 : mbuf_size(MBuf *mbuf)
57 : : {
58 : 100 : return mbuf->data_end - mbuf->data;
59 : : }
60 : :
61 : : int
62 : 278 : mbuf_free(MBuf *mbuf)
63 : : {
64 [ + + ]: 278 : if (mbuf->own_data)
65 : : {
66 : 17 : px_memset(mbuf->data, 0, mbuf->buf_end - mbuf->data);
67 : 17 : pfree(mbuf->data);
68 : : }
69 : 278 : pfree(mbuf);
70 : 278 : return 0;
71 : : }
72 : :
73 : : static void
74 : 404 : prepare_room(MBuf *mbuf, int block_len)
75 : : {
76 : : uint8 *newbuf;
77 : : unsigned newlen;
78 : :
79 [ + + ]: 404 : if (mbuf->data_end + block_len <= mbuf->buf_end)
80 : 398 : return;
81 : :
82 : 6 : newlen = (mbuf->buf_end - mbuf->data)
83 : 6 : + ((block_len + STEP + STEP - 1) & -STEP);
84 : :
85 : 6 : newbuf = repalloc(mbuf->data, newlen);
86 : :
87 : 6 : mbuf->buf_end = newbuf + newlen;
88 : 6 : mbuf->data_end = newbuf + (mbuf->data_end - mbuf->data);
89 : 6 : mbuf->read_pos = newbuf + (mbuf->read_pos - mbuf->data);
90 : 6 : mbuf->data = newbuf;
91 : : }
92 : :
93 : : int
94 : 404 : mbuf_append(MBuf *dst, const uint8 *buf, int len)
95 : : {
96 [ - + ]: 404 : if (dst->no_write)
97 : : {
98 : 0 : px_debug("mbuf_append: no_write");
99 : 0 : return PXE_BUG;
100 : : }
101 : :
102 : 404 : prepare_room(dst, len);
103 : :
104 : 404 : memcpy(dst->data_end, buf, len);
105 : 404 : dst->data_end += len;
106 : :
107 : 404 : return 0;
108 : : }
109 : :
110 : : MBuf *
111 : 117 : mbuf_create(int len)
112 : : {
113 : : MBuf *mbuf;
114 : :
115 [ - + ]: 117 : if (!len)
116 : 0 : len = 8192;
117 : :
118 : 117 : mbuf = palloc_object(MBuf);
119 : 117 : mbuf->data = palloc(len);
120 : 117 : mbuf->buf_end = mbuf->data + len;
121 : 117 : mbuf->data_end = mbuf->data;
122 : 117 : mbuf->read_pos = mbuf->data;
123 : :
124 : 117 : mbuf->no_write = false;
125 : 117 : mbuf->own_data = true;
126 : :
127 : 117 : return mbuf;
128 : : }
129 : :
130 : : MBuf *
131 : 161 : mbuf_create_from_data(uint8 *data, int len)
132 : : {
133 : : MBuf *mbuf;
134 : :
135 : 161 : mbuf = palloc_object(MBuf);
136 : 161 : mbuf->data = data;
137 : 161 : mbuf->buf_end = mbuf->data + len;
138 : 161 : mbuf->data_end = mbuf->data + len;
139 : 161 : mbuf->read_pos = mbuf->data;
140 : :
141 : 161 : mbuf->no_write = true;
142 : 161 : mbuf->own_data = false;
143 : :
144 : 161 : return mbuf;
145 : : }
146 : :
147 : :
148 : : int
149 : 2743 : mbuf_grab(MBuf *mbuf, int len, uint8 **data_p)
150 : : {
151 [ + + ]: 2743 : if (len > mbuf_avail(mbuf))
152 : 103 : len = mbuf_avail(mbuf);
153 : :
154 : 2743 : mbuf->no_write = true;
155 : :
156 : 2743 : *data_p = mbuf->read_pos;
157 : 2743 : mbuf->read_pos += len;
158 : 2743 : return len;
159 : : }
160 : :
161 : : int
162 : 100 : mbuf_steal_data(MBuf *mbuf, uint8 **data_p)
163 : : {
164 : 100 : int len = mbuf_size(mbuf);
165 : :
166 : 100 : mbuf->no_write = true;
167 : 100 : mbuf->own_data = false;
168 : :
169 : 100 : *data_p = mbuf->data;
170 : :
171 : 100 : mbuf->data = mbuf->data_end = mbuf->read_pos = mbuf->buf_end = NULL;
172 : :
173 : 100 : return len;
174 : : }
175 : :
176 : : /*
177 : : * PullFilter
178 : : */
179 : :
180 : : struct PullFilter
181 : : {
182 : : PullFilter *src;
183 : : const PullFilterOps *op;
184 : : int buflen;
185 : : uint8 *buf;
186 : : int pos;
187 : : void *priv;
188 : : };
189 : :
190 : : int
191 : 821 : pullf_create(PullFilter **pf_p, const PullFilterOps *op, void *init_arg, PullFilter *src)
192 : : {
193 : : PullFilter *pf;
194 : : void *priv;
195 : : int res;
196 : :
197 [ + + ]: 821 : if (op->init != NULL)
198 : : {
199 : 228 : res = op->init(&priv, init_arg, src);
200 [ - + ]: 228 : if (res < 0)
201 : 0 : return res;
202 : : }
203 : : else
204 : : {
205 : 593 : priv = init_arg;
206 : 593 : res = 0;
207 : : }
208 : :
209 : 821 : pf = palloc0_object(PullFilter);
210 : 821 : pf->buflen = res;
211 : 821 : pf->op = op;
212 : 821 : pf->priv = priv;
213 : 821 : pf->src = src;
214 [ + + ]: 821 : if (pf->buflen > 0)
215 : : {
216 : 77 : pf->buf = palloc(pf->buflen);
217 : 77 : pf->pos = 0;
218 : : }
219 : : else
220 : : {
221 : 744 : pf->buf = NULL;
222 : 744 : pf->pos = 0;
223 : : }
224 : 821 : *pf_p = pf;
225 : 821 : return 0;
226 : : }
227 : :
228 : : void
229 : 821 : pullf_free(PullFilter *pf)
230 : : {
231 [ + + ]: 821 : if (pf->op->free)
232 : 552 : pf->op->free(pf->priv);
233 : :
234 [ + + ]: 821 : if (pf->buf)
235 : : {
236 : 77 : px_memset(pf->buf, 0, pf->buflen);
237 : 77 : pfree(pf->buf);
238 : : }
239 : :
240 : 821 : px_memset(pf, 0, sizeof(*pf));
241 : 821 : pfree(pf);
242 : 821 : }
243 : :
244 : : /* may return less data than asked, 0 means eof */
245 : : int
246 : 7653 : pullf_read(PullFilter *pf, int len, uint8 **data_p)
247 : : {
248 : : int res;
249 : :
250 [ + + ]: 7653 : if (pf->op->pull)
251 : : {
252 [ + + + + ]: 6934 : if (pf->buflen && len > pf->buflen)
253 : 23 : len = pf->buflen;
254 : 6934 : res = pf->op->pull(pf->priv, pf->src, len, data_p,
255 : : pf->buf, pf->buflen);
256 : : }
257 : : else
258 : 719 : res = pullf_read(pf->src, len, data_p);
259 : 7653 : return res;
260 : : }
261 : :
262 : : int
263 : 1941 : pullf_read_max(PullFilter *pf, int len, uint8 **data_p, uint8 *tmpbuf)
264 : : {
265 : : int res,
266 : : total;
267 : : uint8 *tmp;
268 : :
269 : 1941 : res = pullf_read(pf, len, data_p);
270 [ + + + + ]: 1941 : if (res <= 0 || res == len)
271 : 1934 : return res;
272 : :
273 : : /* read was shorter, use tmpbuf */
274 : 7 : memcpy(tmpbuf, *data_p, res);
275 : 7 : *data_p = tmpbuf;
276 : 7 : len -= res;
277 : 7 : total = res;
278 : :
279 [ + + ]: 8 : while (len > 0)
280 : : {
281 : 7 : res = pullf_read(pf, len, &tmp);
282 [ - + ]: 7 : if (res < 0)
283 : : {
284 : : /* so the caller must clear only on success */
285 : 0 : px_memset(tmpbuf, 0, total);
286 : 0 : return res;
287 : : }
288 [ + + ]: 7 : if (res == 0)
289 : 6 : break;
290 : 1 : memcpy(tmpbuf + total, tmp, res);
291 : 1 : total += res;
292 : 1 : len -= res;
293 : : }
294 : 7 : return total;
295 : : }
296 : :
297 : : /*
298 : : * caller wants exactly len bytes and don't bother with references
299 : : */
300 : : int
301 : 1675 : pullf_read_fixed(PullFilter *src, int len, uint8 *dst)
302 : : {
303 : : int res;
304 : : uint8 *p;
305 : :
306 : 1675 : res = pullf_read_max(src, len, &p, dst);
307 [ - + ]: 1675 : if (res < 0)
308 : 0 : return res;
309 [ + + ]: 1675 : if (res != len)
310 : : {
311 : 2 : px_debug("pullf_read_fixed: need=%d got=%d", len, res);
312 : 2 : return PXE_PGP_CORRUPT_DATA;
313 : : }
314 [ + - ]: 1673 : if (p != dst)
315 : 1673 : memcpy(dst, p, len);
316 : 1673 : return 0;
317 : : }
318 : :
319 : : /*
320 : : * read from MBuf
321 : : */
322 : : static int
323 : 2707 : pull_from_mbuf(void *arg, PullFilter *src, int len,
324 : : uint8 **data_p, uint8 *buf, int buflen)
325 : : {
326 : 2707 : MBuf *mbuf = arg;
327 : :
328 : 2707 : return mbuf_grab(mbuf, len, data_p);
329 : : }
330 : :
331 : : static const struct PullFilterOps mbuf_reader = {
332 : : NULL, pull_from_mbuf, NULL
333 : : };
334 : :
335 : : int
336 : 119 : pullf_create_mbuf_reader(PullFilter **mp_p, MBuf *src)
337 : : {
338 : 119 : return pullf_create(mp_p, &mbuf_reader, src, NULL);
339 : : }
340 : :
341 : :
342 : : /*
343 : : * PushFilter
344 : : */
345 : :
346 : : struct PushFilter
347 : : {
348 : : PushFilter *next;
349 : : const PushFilterOps *op;
350 : : int block_size;
351 : : uint8 *buf;
352 : : int pos;
353 : : void *priv;
354 : : };
355 : :
356 : : int
357 : 193 : pushf_create(PushFilter **mp_p, const PushFilterOps *op, void *init_arg, PushFilter *next)
358 : : {
359 : : PushFilter *mp;
360 : : void *priv;
361 : : int res;
362 : :
363 [ + + ]: 193 : if (op->init != NULL)
364 : : {
365 : 155 : res = op->init(next, init_arg, &priv);
366 [ - + ]: 155 : if (res < 0)
367 : 0 : return res;
368 : : }
369 : : else
370 : : {
371 : 38 : priv = init_arg;
372 : 38 : res = 0;
373 : : }
374 : :
375 : 193 : mp = palloc0_object(PushFilter);
376 : 193 : mp->block_size = res;
377 : 193 : mp->op = op;
378 : 193 : mp->priv = priv;
379 : 193 : mp->next = next;
380 [ + + ]: 193 : if (mp->block_size > 0)
381 : : {
382 : 120 : mp->buf = palloc(mp->block_size);
383 : 120 : mp->pos = 0;
384 : : }
385 : : else
386 : : {
387 : 73 : mp->buf = NULL;
388 : 73 : mp->pos = 0;
389 : : }
390 : 193 : *mp_p = mp;
391 : 193 : return 0;
392 : : }
393 : :
394 : : void
395 : 193 : pushf_free(PushFilter *mp)
396 : : {
397 [ + + ]: 193 : if (mp->op->free)
398 : 155 : mp->op->free(mp->priv);
399 : :
400 [ + + ]: 193 : if (mp->buf)
401 : : {
402 : 120 : px_memset(mp->buf, 0, mp->block_size);
403 : 120 : pfree(mp->buf);
404 : : }
405 : :
406 : 193 : px_memset(mp, 0, sizeof(*mp));
407 : 193 : pfree(mp);
408 : 193 : }
409 : :
410 : : void
411 : 36 : pushf_free_all(PushFilter *mp)
412 : : {
413 : : PushFilter *tmp;
414 : :
415 [ + + ]: 223 : while (mp)
416 : : {
417 : 187 : tmp = mp->next;
418 : 187 : pushf_free(mp);
419 : 187 : mp = tmp;
420 : : }
421 : 36 : }
422 : :
423 : : static int
424 : 487 : wrap_process(PushFilter *mp, const uint8 *data, int len)
425 : : {
426 : : int res;
427 : :
428 [ + - ]: 487 : if (mp->op->push != NULL)
429 : 487 : res = mp->op->push(mp->next, mp->priv, data, len);
430 : : else
431 : 0 : res = pushf_write(mp->next, data, len);
432 [ - + ]: 487 : if (res > 0)
433 : 0 : return PXE_BUG;
434 : 487 : return res;
435 : : }
436 : :
437 : : /* consumes all data, returns len on success */
438 : : int
439 : 757 : pushf_write(PushFilter *mp, const uint8 *data, int len)
440 : : {
441 : : int need,
442 : : res;
443 : :
444 : : /*
445 : : * no buffering
446 : : */
447 [ + + ]: 757 : if (mp->block_size <= 0)
448 : 347 : return wrap_process(mp, data, len);
449 : :
450 : : /*
451 : : * try to empty buffer
452 : : */
453 : 410 : need = mp->block_size - mp->pos;
454 [ + - ]: 410 : if (need > 0)
455 : : {
456 [ + + ]: 410 : if (len < need)
457 : : {
458 : 397 : memcpy(mp->buf + mp->pos, data, len);
459 : 397 : mp->pos += len;
460 : 397 : return 0;
461 : : }
462 : 13 : memcpy(mp->buf + mp->pos, data, need);
463 : 13 : len -= need;
464 : 13 : data += need;
465 : : }
466 : :
467 : : /*
468 : : * buffer full, process
469 : : */
470 : 13 : res = wrap_process(mp, mp->buf, mp->block_size);
471 [ - + ]: 13 : if (res < 0)
472 : 0 : return res;
473 : 13 : mp->pos = 0;
474 : :
475 : : /*
476 : : * now process directly from data
477 : : */
478 [ + + ]: 20 : while (len > 0)
479 : : {
480 [ + + ]: 19 : if (len > mp->block_size)
481 : : {
482 : 7 : res = wrap_process(mp, data, mp->block_size);
483 [ - + ]: 7 : if (res < 0)
484 : 0 : return res;
485 : 7 : data += mp->block_size;
486 : 7 : len -= mp->block_size;
487 : : }
488 : : else
489 : : {
490 : 12 : memcpy(mp->buf, data, len);
491 : 12 : mp->pos += len;
492 : 12 : break;
493 : : }
494 : : }
495 : 13 : return 0;
496 : : }
497 : :
498 : : int
499 : 42 : pushf_flush(PushFilter *mp)
500 : : {
501 : : int res;
502 : :
503 [ + + ]: 241 : while (mp)
504 : : {
505 [ + + ]: 199 : if (mp->block_size > 0)
506 : : {
507 : 120 : res = wrap_process(mp, mp->buf, mp->pos);
508 [ - + ]: 120 : if (res < 0)
509 : 0 : return res;
510 : : }
511 : :
512 [ + + ]: 199 : if (mp->op->flush)
513 : : {
514 : 119 : res = mp->op->flush(mp->next, mp->priv);
515 [ - + ]: 119 : if (res < 0)
516 : 0 : return res;
517 : : }
518 : :
519 : 199 : mp = mp->next;
520 : : }
521 : 42 : return 0;
522 : : }
523 : :
524 : :
525 : : /*
526 : : * write to MBuf
527 : : */
528 : : static int
529 : 196 : push_into_mbuf(PushFilter *next, void *arg, const uint8 *data, int len)
530 : : {
531 : 196 : int res = 0;
532 : 196 : MBuf *mbuf = arg;
533 : :
534 [ + - ]: 196 : if (len > 0)
535 : 196 : res = mbuf_append(mbuf, data, len);
536 : 196 : return res < 0 ? res : 0;
537 : : }
538 : :
539 : : static const struct PushFilterOps mbuf_filter = {
540 : : NULL, push_into_mbuf, NULL, NULL
541 : : };
542 : :
543 : : int
544 : 36 : pushf_create_mbuf_writer(PushFilter **res, MBuf *dst)
545 : : {
546 : 36 : return pushf_create(res, &mbuf_filter, dst, NULL);
547 : : }
|
