Branch data Line data Source code
1 : : /*
2 : : * pgp-encrypt.c
3 : : * OpenPGP encrypt.
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/pgp-encrypt.c
30 : : */
31 : :
32 : : #include "postgres.h"
33 : :
34 : : #include <time.h>
35 : :
36 : : #include "mbuf.h"
37 : : #include "pgp.h"
38 : : #include "px.h"
39 : :
40 : : #define MDC_DIGEST_LEN 20
41 : : #define STREAM_ID 0xE0
42 : : #define STREAM_BLOCK_SHIFT 14
43 : :
44 : : static uint8 *
45 : 111 : render_newlen(uint8 *h, int len)
46 : : {
47 [ + + ]: 111 : if (len <= 191)
48 : : {
49 : 104 : *h++ = len & 255;
50 : : }
51 [ + - + + ]: 7 : else if (len > 191 && len <= 8383)
52 : : {
53 : 6 : *h++ = ((len - 192) >> 8) + 192;
54 : 6 : *h++ = (len - 192) & 255;
55 : : }
56 : : else
57 : : {
58 : 1 : *h++ = 255;
59 : 1 : *h++ = (len >> 24) & 255;
60 : 1 : *h++ = (len >> 16) & 255;
61 : 1 : *h++ = (len >> 8) & 255;
62 : 1 : *h++ = len & 255;
63 : : }
64 : 111 : return h;
65 : : }
66 : :
67 : : static int
68 : 81 : write_tag_only(PushFilter *dst, int tag)
69 : : {
70 : 81 : uint8 hdr = 0xC0 | tag;
71 : :
72 : 81 : return pushf_write(dst, &hdr, 1);
73 : : }
74 : :
75 : : static int
76 : 30 : write_normal_header(PushFilter *dst, int tag, int len)
77 : : {
78 : : uint8 hdr[8];
79 : 30 : uint8 *h = hdr;
80 : :
81 : 30 : *h++ = 0xC0 | tag;
82 : 30 : h = render_newlen(h, len);
83 : 30 : return pushf_write(dst, hdr, h - hdr);
84 : : }
85 : :
86 : :
87 : : /*
88 : : * MAC writer
89 : : */
90 : :
91 : : static int
92 : 35 : mdc_init(PushFilter *dst, void *init_arg, void **priv_p)
93 : : {
94 : : int res;
95 : : PX_MD *md;
96 : :
97 : 35 : res = pgp_load_digest(PGP_DIGEST_SHA1, &md);
98 [ - + ]: 35 : if (res < 0)
99 : 0 : return res;
100 : :
101 : 35 : *priv_p = md;
102 : 35 : return 0;
103 : : }
104 : :
105 : : static int
106 : 149 : mdc_write(PushFilter *dst, void *priv, const uint8 *data, int len)
107 : : {
108 : 149 : PX_MD *md = priv;
109 : :
110 : 149 : px_md_update(md, data, len);
111 : 149 : return pushf_write(dst, data, len);
112 : : }
113 : :
114 : : static int
115 : 35 : mdc_flush(PushFilter *dst, void *priv)
116 : : {
117 : : int res;
118 : : uint8 pkt[2 + MDC_DIGEST_LEN];
119 : 35 : PX_MD *md = priv;
120 : :
121 : : /*
122 : : * create mdc pkt
123 : : */
124 : 35 : pkt[0] = 0xD3;
125 : 35 : pkt[1] = 0x14; /* MDC_DIGEST_LEN */
126 : 35 : px_md_update(md, pkt, 2);
127 : 35 : px_md_finish(md, pkt + 2);
128 : :
129 : 35 : res = pushf_write(dst, pkt, 2 + MDC_DIGEST_LEN);
130 : 35 : px_memset(pkt, 0, 2 + MDC_DIGEST_LEN);
131 : 35 : return res;
132 : : }
133 : :
134 : : static void
135 : 35 : mdc_free(void *priv)
136 : : {
137 : 35 : PX_MD *md = priv;
138 : :
139 : 35 : px_md_free(md);
140 : 35 : }
141 : :
142 : : static const PushFilterOps mdc_filter = {
143 : : mdc_init, mdc_write, mdc_flush, mdc_free
144 : : };
145 : :
146 : :
147 : : /*
148 : : * Encrypted pkt writer
149 : : */
150 : : #define ENCBUF 8192
151 : : struct EncStat
152 : : {
153 : : PGP_CFB *ciph;
154 : : uint8 buf[ENCBUF];
155 : : };
156 : :
157 : : static int
158 : 36 : encrypt_init(PushFilter *next, void *init_arg, void **priv_p)
159 : : {
160 : : struct EncStat *st;
161 : 36 : PGP_Context *ctx = init_arg;
162 : : PGP_CFB *ciph;
163 : 36 : int resync = 1;
164 : : int res;
165 : :
166 : : /* should we use newer packet format? */
167 [ + + ]: 36 : if (ctx->disable_mdc == 0)
168 : : {
169 : 35 : uint8 ver = 1;
170 : :
171 : 35 : resync = 0;
172 : 35 : res = pushf_write(next, &ver, 1);
173 [ - + ]: 35 : if (res < 0)
174 : 0 : return res;
175 : : }
176 : 36 : res = pgp_cfb_create(&ciph, ctx->cipher_algo,
177 : 36 : ctx->sess_key, ctx->sess_key_len, resync, NULL);
178 [ - + ]: 36 : if (res < 0)
179 : 0 : return res;
180 : :
181 : 36 : st = palloc0_object(struct EncStat);
182 : 36 : st->ciph = ciph;
183 : :
184 : 36 : *priv_p = st;
185 : 36 : return ENCBUF;
186 : : }
187 : :
188 : : static int
189 : 46 : encrypt_process(PushFilter *next, void *priv, const uint8 *data, int len)
190 : : {
191 : : int res;
192 : 46 : struct EncStat *st = priv;
193 : 46 : int avail = len;
194 : :
195 [ + + ]: 92 : while (avail > 0)
196 : : {
197 : 46 : int tmplen = avail > ENCBUF ? ENCBUF : avail;
198 : :
199 : 46 : res = pgp_cfb_encrypt(st->ciph, data, tmplen, st->buf);
200 [ - + ]: 46 : if (res < 0)
201 : 0 : return res;
202 : :
203 : 46 : res = pushf_write(next, st->buf, tmplen);
204 [ - + ]: 46 : if (res < 0)
205 : 0 : return res;
206 : :
207 : 46 : data += tmplen;
208 : 46 : avail -= tmplen;
209 : : }
210 : 46 : return 0;
211 : : }
212 : :
213 : : static void
214 : 36 : encrypt_free(void *priv)
215 : : {
216 : 36 : struct EncStat *st = priv;
217 : :
218 [ + - ]: 36 : if (st->ciph)
219 : 36 : pgp_cfb_free(st->ciph);
220 : 36 : px_memset(st, 0, sizeof(*st));
221 : 36 : pfree(st);
222 : 36 : }
223 : :
224 : : static const PushFilterOps encrypt_filter = {
225 : : encrypt_init, encrypt_process, NULL, encrypt_free
226 : : };
227 : :
228 : : /*
229 : : * Write Streamable pkts
230 : : */
231 : :
232 : : struct PktStreamStat
233 : : {
234 : : int final_done;
235 : : int pkt_block;
236 : : };
237 : :
238 : : static int
239 : 81 : pkt_stream_init(PushFilter *next, void *init_arg, void **priv_p)
240 : : {
241 : : struct PktStreamStat *st;
242 : :
243 : 81 : st = palloc_object(struct PktStreamStat);
244 : 81 : st->final_done = 0;
245 : 81 : st->pkt_block = 1 << STREAM_BLOCK_SHIFT;
246 : 81 : *priv_p = st;
247 : :
248 : 81 : return st->pkt_block;
249 : : }
250 : :
251 : : static int
252 : 90 : pkt_stream_process(PushFilter *next, void *priv, const uint8 *data, int len)
253 : : {
254 : : int res;
255 : : uint8 hdr[8];
256 : 90 : uint8 *h = hdr;
257 : 90 : struct PktStreamStat *st = priv;
258 : :
259 [ - + ]: 90 : if (st->final_done)
260 : 0 : return PXE_BUG;
261 : :
262 [ + + ]: 90 : if (len == st->pkt_block)
263 : 10 : *h++ = STREAM_ID | STREAM_BLOCK_SHIFT;
264 : : else
265 : : {
266 : 80 : h = render_newlen(h, len);
267 : 80 : st->final_done = 1;
268 : : }
269 : :
270 : 90 : res = pushf_write(next, hdr, h - hdr);
271 [ - + ]: 90 : if (res < 0)
272 : 0 : return res;
273 : :
274 : 90 : return pushf_write(next, data, len);
275 : : }
276 : :
277 : : static int
278 : 81 : pkt_stream_flush(PushFilter *next, void *priv)
279 : : {
280 : : int res;
281 : : uint8 hdr[8];
282 : 81 : uint8 *h = hdr;
283 : 81 : struct PktStreamStat *st = priv;
284 : :
285 : : /* stream MUST end with normal packet. */
286 [ + + ]: 81 : if (!st->final_done)
287 : : {
288 : 1 : h = render_newlen(h, 0);
289 : 1 : res = pushf_write(next, hdr, h - hdr);
290 [ - + ]: 1 : if (res < 0)
291 : 0 : return res;
292 : 1 : st->final_done = 1;
293 : : }
294 : 81 : return 0;
295 : : }
296 : :
297 : : static void
298 : 81 : pkt_stream_free(void *priv)
299 : : {
300 : 81 : struct PktStreamStat *st = priv;
301 : :
302 : 81 : px_memset(st, 0, sizeof(*st));
303 : 81 : pfree(st);
304 : 81 : }
305 : :
306 : : static const PushFilterOps pkt_stream_filter = {
307 : : pkt_stream_init, pkt_stream_process, pkt_stream_flush, pkt_stream_free
308 : : };
309 : :
310 : : int
311 : 6 : pgp_create_pkt_writer(PushFilter *dst, int tag, PushFilter **res_p)
312 : : {
313 : : int res;
314 : :
315 : 6 : res = write_tag_only(dst, tag);
316 [ - + ]: 6 : if (res < 0)
317 : 0 : return res;
318 : :
319 : 6 : return pushf_create(res_p, &pkt_stream_filter, NULL, dst);
320 : : }
321 : :
322 : : /*
323 : : * Text conversion filter
324 : : */
325 : :
326 : : static int
327 : 2 : crlf_process(PushFilter *dst, void *priv, const uint8 *data, int len)
328 : : {
329 : 2 : const uint8 *data_end = data + len;
330 : : const uint8 *p2,
331 : 2 : *p1 = data;
332 : : int line_len;
333 : : static const uint8 crlf[] = {'\r', '\n'};
334 : 2 : int res = 0;
335 : :
336 [ + + ]: 9 : while (p1 < data_end)
337 : : {
338 : 7 : p2 = memchr(p1, '\n', data_end - p1);
339 [ + + ]: 7 : if (p2 == NULL)
340 : 1 : p2 = data_end;
341 : :
342 : 7 : line_len = p2 - p1;
343 : :
344 : : /* write data */
345 : 7 : res = 0;
346 [ + - ]: 7 : if (line_len > 0)
347 : : {
348 : 7 : res = pushf_write(dst, p1, line_len);
349 [ - + ]: 7 : if (res < 0)
350 : 0 : break;
351 : 7 : p1 += line_len;
352 : : }
353 : :
354 : : /* write crlf */
355 [ + + + + ]: 14 : while (p1 < data_end && *p1 == '\n')
356 : : {
357 : 7 : res = pushf_write(dst, crlf, 2);
358 [ - + ]: 7 : if (res < 0)
359 : 0 : break;
360 : 7 : p1++;
361 : : }
362 : : }
363 : 2 : return res;
364 : : }
365 : :
366 : : static const PushFilterOps crlf_filter = {
367 : : NULL, crlf_process, NULL, NULL
368 : : };
369 : :
370 : : /*
371 : : * Initialize literal data packet
372 : : */
373 : : static int
374 : 36 : init_litdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
375 : : {
376 : : int res;
377 : : int hdrlen;
378 : : uint8 hdr[6];
379 : : uint32 t;
380 : : PushFilter *pkt;
381 : : int type;
382 : :
383 : : /*
384 : : * Create header
385 : : */
386 : :
387 [ + + ]: 36 : if (ctx->text_mode)
388 [ - + ]: 32 : type = ctx->unicode_mode ? 'u' : 't';
389 : : else
390 : 4 : type = 'b';
391 : :
392 : : /*
393 : : * Store the creation time into packet. The goal is to have as few known
394 : : * bytes as possible.
395 : : */
396 : 36 : t = (uint32) time(NULL);
397 : :
398 : 36 : hdr[0] = type;
399 : 36 : hdr[1] = 0;
400 : 36 : hdr[2] = (t >> 24) & 255;
401 : 36 : hdr[3] = (t >> 16) & 255;
402 : 36 : hdr[4] = (t >> 8) & 255;
403 : 36 : hdr[5] = t & 255;
404 : 36 : hdrlen = 6;
405 : :
406 : 36 : res = write_tag_only(dst, PGP_PKT_LITERAL_DATA);
407 [ - + ]: 36 : if (res < 0)
408 : 0 : return res;
409 : :
410 : 36 : res = pushf_create(&pkt, &pkt_stream_filter, ctx, dst);
411 [ - + ]: 36 : if (res < 0)
412 : 0 : return res;
413 : :
414 : 36 : res = pushf_write(pkt, hdr, hdrlen);
415 [ - + ]: 36 : if (res < 0)
416 : : {
417 : 0 : pushf_free(pkt);
418 : 0 : return res;
419 : : }
420 : :
421 : 36 : *pf_res = pkt;
422 : 36 : return 0;
423 : : }
424 : :
425 : : /*
426 : : * Initialize compression filter
427 : : */
428 : : static int
429 : 3 : init_compress(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
430 : : {
431 : : int res;
432 : 3 : uint8 type = ctx->compress_algo;
433 : : PushFilter *pkt;
434 : :
435 : 3 : res = write_tag_only(dst, PGP_PKT_COMPRESSED_DATA);
436 [ - + ]: 3 : if (res < 0)
437 : 0 : return res;
438 : :
439 : 3 : res = pushf_create(&pkt, &pkt_stream_filter, ctx, dst);
440 [ - + ]: 3 : if (res < 0)
441 : 0 : return res;
442 : :
443 : 3 : res = pushf_write(pkt, &type, 1);
444 [ + - ]: 3 : if (res >= 0)
445 : 3 : res = pgp_compress_filter(pf_res, ctx, pkt);
446 : :
447 [ - + ]: 3 : if (res < 0)
448 : 0 : pushf_free(pkt);
449 : :
450 : 3 : return res;
451 : : }
452 : :
453 : : /*
454 : : * Initialize encdata packet
455 : : */
456 : : static int
457 : 36 : init_encdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
458 : : {
459 : : int res;
460 : : int tag;
461 : :
462 [ + + ]: 36 : if (ctx->disable_mdc)
463 : 1 : tag = PGP_PKT_SYMENCRYPTED_DATA;
464 : : else
465 : 35 : tag = PGP_PKT_SYMENCRYPTED_DATA_MDC;
466 : :
467 : 36 : res = write_tag_only(dst, tag);
468 [ - + ]: 36 : if (res < 0)
469 : 0 : return res;
470 : :
471 : 36 : return pushf_create(pf_res, &pkt_stream_filter, ctx, dst);
472 : : }
473 : :
474 : : /*
475 : : * write prefix
476 : : */
477 : : static int
478 : 36 : write_prefix(PGP_Context *ctx, PushFilter *dst)
479 : : {
480 : : uint8 prefix[PGP_MAX_BLOCK + 2];
481 : : int res,
482 : : bs;
483 : :
484 : 36 : bs = pgp_get_cipher_block_size(ctx->cipher_algo);
485 [ - + ]: 36 : if (!pg_strong_random(prefix, bs))
486 : 0 : return PXE_NO_RANDOM;
487 : :
488 : 36 : prefix[bs + 0] = prefix[bs - 2];
489 : 36 : prefix[bs + 1] = prefix[bs - 1];
490 : :
491 : 36 : res = pushf_write(dst, prefix, bs + 2);
492 : 36 : px_memset(prefix, 0, bs + 2);
493 : 36 : return res < 0 ? res : 0;
494 : : }
495 : :
496 : : /*
497 : : * write symmetrically encrypted session key packet
498 : : */
499 : :
500 : : static int
501 : 4 : symencrypt_sesskey(PGP_Context *ctx, uint8 *dst)
502 : : {
503 : : int res;
504 : : PGP_CFB *cfb;
505 : 4 : uint8 algo = ctx->cipher_algo;
506 : :
507 : 4 : res = pgp_cfb_create(&cfb, ctx->s2k_cipher_algo,
508 : 4 : ctx->s2k.key, ctx->s2k.key_len, 0, NULL);
509 [ - + ]: 4 : if (res < 0)
510 : 0 : return res;
511 : :
512 : 4 : pgp_cfb_encrypt(cfb, &algo, 1, dst);
513 : 4 : pgp_cfb_encrypt(cfb, ctx->sess_key, ctx->sess_key_len, dst + 1);
514 : :
515 : 4 : pgp_cfb_free(cfb);
516 : 4 : return ctx->sess_key_len + 1;
517 : : }
518 : :
519 : : /* 5.3: Symmetric-Key Encrypted Session-Key */
520 : : static int
521 : 30 : write_symenc_sesskey(PGP_Context *ctx, PushFilter *dst)
522 : : {
523 : : uint8 pkt[256];
524 : : int pktlen;
525 : : int res;
526 : 30 : uint8 *p = pkt;
527 : :
528 : 30 : *p++ = 4; /* 5.3 - version number */
529 : 30 : *p++ = ctx->s2k_cipher_algo;
530 : :
531 : 30 : *p++ = ctx->s2k.mode;
532 : 30 : *p++ = ctx->s2k.digest_algo;
533 [ + + ]: 30 : if (ctx->s2k.mode > 0)
534 : : {
535 : 29 : memcpy(p, ctx->s2k.salt, 8);
536 : 29 : p += 8;
537 : : }
538 [ + + ]: 30 : if (ctx->s2k.mode == 3)
539 : 28 : *p++ = ctx->s2k.iter;
540 : :
541 [ + + ]: 30 : if (ctx->use_sess_key)
542 : : {
543 : 4 : res = symencrypt_sesskey(ctx, p);
544 [ - + ]: 4 : if (res < 0)
545 : 0 : return res;
546 : 4 : p += res;
547 : : }
548 : :
549 : 30 : pktlen = p - pkt;
550 : 30 : res = write_normal_header(dst, PGP_PKT_SYMENCRYPTED_SESSKEY, pktlen);
551 [ + - ]: 30 : if (res >= 0)
552 : 30 : res = pushf_write(dst, pkt, pktlen);
553 : :
554 : 30 : px_memset(pkt, 0, pktlen);
555 : 30 : return res;
556 : : }
557 : :
558 : : /*
559 : : * key setup
560 : : */
561 : : static int
562 : 30 : init_s2k_key(PGP_Context *ctx)
563 : : {
564 : : int res;
565 : :
566 [ + - ]: 30 : if (ctx->s2k_cipher_algo < 0)
567 : 30 : ctx->s2k_cipher_algo = ctx->cipher_algo;
568 : :
569 : 30 : res = pgp_s2k_fill(&ctx->s2k, ctx->s2k_mode, ctx->s2k_digest_algo, ctx->s2k_count);
570 [ - + ]: 30 : if (res < 0)
571 : 0 : return res;
572 : :
573 : 30 : return pgp_s2k_process(&ctx->s2k, ctx->s2k_cipher_algo,
574 : : ctx->sym_key, ctx->sym_key_len);
575 : : }
576 : :
577 : : static int
578 : 36 : init_sess_key(PGP_Context *ctx)
579 : : {
580 [ + + + + ]: 36 : if (ctx->use_sess_key || ctx->pub_key)
581 : : {
582 : 10 : ctx->sess_key_len = pgp_get_cipher_key_size(ctx->cipher_algo);
583 [ - + ]: 10 : if (!pg_strong_random(ctx->sess_key, ctx->sess_key_len))
584 : 0 : return PXE_NO_RANDOM;
585 : : }
586 : : else
587 : : {
588 : 26 : ctx->sess_key_len = ctx->s2k.key_len;
589 : 26 : memcpy(ctx->sess_key, ctx->s2k.key, ctx->s2k.key_len);
590 : : }
591 : :
592 : 36 : return 0;
593 : : }
594 : :
595 : : /*
596 : : * combine
597 : : */
598 : : int
599 : 36 : pgp_encrypt(PGP_Context *ctx, MBuf *src, MBuf *dst)
600 : : {
601 : : int res;
602 : : int len;
603 : : uint8 *buf;
604 : : PushFilter *pf,
605 : : *pf_tmp;
606 : :
607 : : /*
608 : : * do we have any key
609 : : */
610 [ + + - + ]: 36 : if (!ctx->sym_key && !ctx->pub_key)
611 : 0 : return PXE_ARGUMENT_ERROR;
612 : :
613 : : /* MBuf writer */
614 : 36 : res = pushf_create_mbuf_writer(&pf, dst);
615 [ - + ]: 36 : if (res < 0)
616 : 0 : goto out;
617 : :
618 : : /*
619 : : * initialize sym_key
620 : : */
621 [ + + ]: 36 : if (ctx->sym_key)
622 : : {
623 : 30 : res = init_s2k_key(ctx);
624 [ - + ]: 30 : if (res < 0)
625 : 0 : goto out;
626 : : }
627 : :
628 : 36 : res = init_sess_key(ctx);
629 [ - + ]: 36 : if (res < 0)
630 : 0 : goto out;
631 : :
632 : : /*
633 : : * write keypkt
634 : : */
635 [ + + ]: 36 : if (ctx->pub_key)
636 : 6 : res = pgp_write_pubenc_sesskey(ctx, pf);
637 : : else
638 : 30 : res = write_symenc_sesskey(ctx, pf);
639 [ - + ]: 36 : if (res < 0)
640 : 0 : goto out;
641 : :
642 : : /* encrypted data pkt */
643 : 36 : res = init_encdata_packet(&pf_tmp, ctx, pf);
644 [ - + ]: 36 : if (res < 0)
645 : 0 : goto out;
646 : 36 : pf = pf_tmp;
647 : :
648 : : /* encrypter */
649 : 36 : res = pushf_create(&pf_tmp, &encrypt_filter, ctx, pf);
650 [ - + ]: 36 : if (res < 0)
651 : 0 : goto out;
652 : 36 : pf = pf_tmp;
653 : :
654 : : /* hasher */
655 [ + + ]: 36 : if (ctx->disable_mdc == 0)
656 : : {
657 : 35 : res = pushf_create(&pf_tmp, &mdc_filter, ctx, pf);
658 [ - + ]: 35 : if (res < 0)
659 : 0 : goto out;
660 : 35 : pf = pf_tmp;
661 : : }
662 : :
663 : : /* prefix */
664 : 36 : res = write_prefix(ctx, pf);
665 [ - + ]: 36 : if (res < 0)
666 : 0 : goto out;
667 : :
668 : : /* compressor */
669 [ + + + + ]: 36 : if (ctx->compress_algo > 0 && ctx->compress_level > 0)
670 : : {
671 : 3 : res = init_compress(&pf_tmp, ctx, pf);
672 [ - + ]: 3 : if (res < 0)
673 : 0 : goto out;
674 : 3 : pf = pf_tmp;
675 : : }
676 : :
677 : : /* data streamer */
678 : 36 : res = init_litdata_packet(&pf_tmp, ctx, pf);
679 [ - + ]: 36 : if (res < 0)
680 : 0 : goto out;
681 : 36 : pf = pf_tmp;
682 : :
683 : :
684 : : /* text conversion? */
685 [ + + + + ]: 36 : if (ctx->text_mode && ctx->convert_crlf)
686 : : {
687 : 2 : res = pushf_create(&pf_tmp, &crlf_filter, ctx, pf);
688 [ - + ]: 2 : if (res < 0)
689 : 0 : goto out;
690 : 2 : pf = pf_tmp;
691 : : }
692 : :
693 : : /*
694 : : * chain complete
695 : : */
696 : :
697 : 36 : len = mbuf_grab(src, mbuf_avail(src), &buf);
698 : 36 : res = pushf_write(pf, buf, len);
699 [ - + ]: 36 : if (res >= 0)
700 : 36 : res = pushf_flush(pf);
701 : 0 : out:
702 : 36 : pushf_free_all(pf);
703 : 36 : return res;
704 : : }
|
