2 * Copyright (c) 2019 Stefan Sperling <stsp@openbsd.org>
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <sys/queue.h>
28 #include "got_error.h"
29 #include "got_object.h"
32 #include "got_lib_deflate.h"
33 #include "got_lib_hash.h"
34 #include "got_lib_poll.h"
37 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
40 const struct got_error *
41 got_deflate_init(struct got_deflate_buf *zb, uint8_t *outbuf, size_t bufsize)
43 const struct got_error *err = NULL;
46 memset(zb, 0, sizeof(*zb));
48 zb->z.zalloc = Z_NULL;
50 zerr = deflateInit(&zb->z, Z_DEFAULT_COMPRESSION);
53 return got_error_from_errno("deflateInit");
54 if (zerr == Z_MEM_ERROR) {
56 return got_error_from_errno("deflateInit");
58 return got_error(GOT_ERR_COMPRESSION);
61 zb->inlen = zb->outlen = bufsize;
63 zb->inbuf = calloc(1, zb->inlen);
64 if (zb->inbuf == NULL) {
65 err = got_error_from_errno("calloc");
71 zb->outbuf = calloc(1, zb->outlen);
72 if (zb->outbuf == NULL) {
73 err = got_error_from_errno("calloc");
76 zb->flags |= GOT_DEFLATE_F_OWN_OUTBUF;
86 csum_output(struct got_deflate_checksum *csum, const uint8_t *buf, size_t len)
89 *csum->output_crc = crc32(*csum->output_crc, buf, len);
91 if (csum->output_sha1)
92 SHA1Update(csum->output_sha1, buf, len);
95 got_hash_update(csum->output_ctx, buf, len);
98 const struct got_error *
99 got_deflate_read(struct got_deflate_buf *zb, FILE *f, off_t len,
100 size_t *outlenp, off_t *consumed)
102 size_t last_total_out = zb->z.total_out;
103 z_stream *z = &zb->z;
106 z->next_out = zb->outbuf;
107 z->avail_out = zb->outlen;
112 size_t last_total_in = z->total_in;
113 if (z->avail_in == 0) {
115 if (*consumed < len) {
116 n = fread(zb->inbuf, 1,
117 MIN(zb->inlen, len - *consumed), f);
121 return got_ferror(f, GOT_ERR_IO);
123 ret = deflate(z, Z_FINISH);
126 z->next_in = zb->inbuf;
129 ret = deflate(z, Z_NO_FLUSH);
130 *consumed += z->total_in - last_total_in;
131 } while (ret == Z_OK && z->avail_out > 0);
134 zb->flags |= GOT_DEFLATE_F_HAVE_MORE;
136 if (ret != Z_STREAM_END)
137 return got_error(GOT_ERR_COMPRESSION);
138 zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
141 *outlenp = z->total_out - last_total_out;
145 static const struct got_error *
146 deflate_read_mmap(struct got_deflate_buf *zb, uint8_t *map, size_t offset,
147 size_t len, size_t *outlenp, size_t *consumed, int flush_on_eof)
149 z_stream *z = &zb->z;
150 size_t last_total_out = z->total_out;
153 z->next_out = zb->outbuf;
154 z->avail_out = zb->outlen;
159 size_t last_total_in = z->total_in;
160 if (z->avail_in == 0) {
161 z->next_in = map + offset + *consumed;
162 if (len - *consumed > UINT_MAX)
163 z->avail_in = UINT_MAX;
165 z->avail_in = len - *consumed;
166 if (z->avail_in == 0) {
169 ret = deflate(z, Z_FINISH);
173 ret = deflate(z, Z_NO_FLUSH);
174 *consumed += z->total_in - last_total_in;
175 } while (ret == Z_OK && z->avail_out > 0);
178 zb->flags |= GOT_DEFLATE_F_HAVE_MORE;
180 if (ret != Z_STREAM_END)
181 return got_error(GOT_ERR_COMPRESSION);
182 zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
185 *outlenp = z->total_out - last_total_out;
189 const struct got_error *
190 got_deflate_read_mmap(struct got_deflate_buf *zb, uint8_t *map, size_t offset,
191 size_t len, size_t *outlenp, size_t *consumed)
193 return deflate_read_mmap(zb, map, offset, len, outlenp, consumed, 1);
196 const struct got_error *
197 got_deflate_flush(struct got_deflate_buf *zb, FILE *outfile,
198 struct got_deflate_checksum *csum, off_t *outlenp)
202 z_stream *z = &zb->z;
204 if (z->avail_in != 0)
205 return got_error_msg(GOT_ERR_COMPRESSION,
206 "cannot flush zb with pending input data");
209 size_t avail, last_total_out = zb->z.total_out;
211 z->next_out = zb->outbuf;
212 z->avail_out = zb->outlen;
214 ret = deflate(z, Z_FINISH);
215 if (ret != Z_STREAM_END && ret != Z_OK)
216 return got_error(GOT_ERR_COMPRESSION);
218 avail = z->total_out - last_total_out;
220 n = fwrite(zb->outbuf, avail, 1, outfile);
222 return got_ferror(outfile, GOT_ERR_IO);
224 csum_output(csum, zb->outbuf, avail);
228 } while (ret != Z_STREAM_END);
230 zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
235 got_deflate_end(struct got_deflate_buf *zb)
238 if (zb->flags & GOT_DEFLATE_F_OWN_OUTBUF)
243 const struct got_error *
244 got_deflate_to_fd(off_t *outlen, FILE *infile, off_t len, int outfd,
245 struct got_deflate_checksum *csum)
247 const struct got_error *err;
250 struct got_deflate_buf zb;
252 err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
259 err = got_deflate_read(&zb, infile, len, &avail, &consumed);
264 err = got_poll_write_full(outfd, zb.outbuf, avail);
268 csum_output(csum, zb.outbuf, avail);
271 } while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
274 got_deflate_end(&zb);
278 const struct got_error *
279 got_deflate_to_fd_mmap(off_t *outlen, uint8_t *map, size_t offset,
280 size_t len, int outfd, struct got_deflate_checksum *csum)
282 const struct got_error *err;
283 size_t avail, consumed;
284 struct got_deflate_buf zb;
286 err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
292 err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
299 err = got_poll_write_full(outfd, zb.outbuf, avail);
303 csum_output(csum, zb.outbuf, avail);
306 } while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
309 got_deflate_end(&zb);
313 const struct got_error *
314 got_deflate_to_file(off_t *outlen, FILE *infile, off_t len,
315 FILE *outfile, struct got_deflate_checksum *csum)
317 const struct got_error *err;
320 struct got_deflate_buf zb;
322 err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
329 err = got_deflate_read(&zb, infile, len, &avail, &consumed);
335 n = fwrite(zb.outbuf, avail, 1, outfile);
337 err = got_ferror(outfile, GOT_ERR_IO);
341 csum_output(csum, zb.outbuf, avail);
344 } while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
347 got_deflate_end(&zb);
351 const struct got_error *
352 got_deflate_to_file_mmap(off_t *outlen, uint8_t *map, size_t offset,
353 size_t len, FILE *outfile, struct got_deflate_checksum *csum)
355 const struct got_error *err;
356 size_t avail, consumed;
357 struct got_deflate_buf zb;
359 err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
365 err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
373 n = fwrite(zb.outbuf, avail, 1, outfile);
375 err = got_ferror(outfile, GOT_ERR_IO);
379 csum_output(csum, zb.outbuf, avail);
382 } while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
385 got_deflate_end(&zb);
389 const struct got_error *
390 got_deflate_append_to_file_mmap(struct got_deflate_buf *zb, off_t *outlen,
391 uint8_t *map, size_t offset, size_t len, FILE *outfile,
392 struct got_deflate_checksum *csum)
394 const struct got_error *err;
395 size_t avail, consumed;
398 err = deflate_read_mmap(zb, map, offset, len, &avail,
406 n = fwrite(zb->outbuf, avail, 1, outfile);
408 err = got_ferror(outfile, GOT_ERR_IO);
412 csum_output(csum, zb->outbuf, avail);
416 } while ((zb->flags & GOT_DEFLATE_F_HAVE_MORE) && len > 0);
421 const struct got_error *
422 got_deflate_to_mem_mmap(uint8_t **outbuf, size_t *outlen,
423 size_t *consumed_total, struct got_deflate_checksum *csum, uint8_t *map,
424 size_t offset, size_t len)
426 const struct got_error *err;
427 size_t avail, consumed;
428 struct got_deflate_buf zb;
433 *outbuf = malloc(GOT_DEFLATE_BUFSIZE);
435 return got_error_from_errno("malloc");
436 err = got_deflate_init(&zb, *outbuf, GOT_DEFLATE_BUFSIZE);
443 err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
452 err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
458 *consumed_total += consumed;
460 if (avail > 0 && csum)
461 csum_output(csum, zb.outbuf, avail);
463 if ((zb.flags & GOT_DEFLATE_F_HAVE_MORE) && outbuf != NULL) {
464 newbuf = reallocarray(*outbuf, ++nbuf,
465 GOT_DEFLATE_BUFSIZE);
466 if (newbuf == NULL) {
467 err = got_error_from_errno("reallocarray");
474 zb.outbuf = newbuf + *outlen;
475 zb.outlen = (nbuf * GOT_DEFLATE_BUFSIZE) - *outlen;
477 } while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
479 got_deflate_end(&zb);