Got Mirror

Blob

Date:: Fri Jul 13 08:51:34 2018 UTC
Message:: fix more memleaks
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
3  *
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.
7  *
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.
15  */
16 
17 #include <sys/queue.h>
18 
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <sha1.h>
23 #include <zlib.h>
24 #include <time.h>
25 
26 #include "got_error.h"
27 #include "got_object.h"
28 
29 #include "got_lib_path.h"
30 #include "got_lib_inflate.h"
31 
32 #ifndef MIN
33 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
34 #endif
35 
36 const struct got_error *
37 got_inflate_init(struct got_zstream_buf *zb, uint8_t *outbuf, size_t bufsize)
38 {
39 	const struct got_error *err = NULL;
40 
41 	memset(&zb->z, 0, sizeof(zb->z));
42 
43 	zb->z.zalloc = Z_NULL;
44 	zb->z.zfree = Z_NULL;
45 	if (inflateInit(&zb->z) != Z_OK) {
46 		err = got_error(GOT_ERR_IO);
47 		goto done;
48 	}
49 
50 	zb->inlen = zb->outlen = bufsize;
51 
52 	zb->inbuf = calloc(1, zb->inlen);
53 	if (zb->inbuf == NULL) {
54 		err = got_error_from_errno();
55 		goto done;
56 	}
57 
58 	zb->flags = 0;
59 	if (outbuf == NULL) {
60 		zb->outbuf = calloc(1, zb->outlen);
61 		if (zb->outbuf == NULL) {
62 			err = got_error_from_errno();
63 			goto done;
64 		}
65 		zb->flags |= GOT_ZSTREAM_F_OWN_OUTBUF;
66 	} else
67 		zb->outbuf = outbuf;
68 
69 done:
70 	if (err)
71 		got_inflate_end(zb);
72 	return err;
73 }
74 
75 const struct got_error *
76 got_inflate_read(struct got_zstream_buf *zb, FILE *f, size_t *outlenp)
77 {
78 	size_t last_total_out = zb->z.total_out;
79 	z_stream *z = &zb->z;
80 	int ret = Z_ERRNO;
81 
82 	z->next_out = zb->outbuf;
83 	z->avail_out = zb->outlen;
84 
85 	*outlenp = 0;
86 	do {
87 		if (z->avail_in == 0) {
88 			size_t n = fread(zb->inbuf, 1, zb->inlen, f);
89 			if (n == 0) {
90 				if (ferror(f))
91 					return got_ferror(f, GOT_ERR_IO);
92 				/* EOF */
93 				ret = Z_STREAM_END;
94 				break;
95 			}
96 			z->next_in = zb->inbuf;
97 			z->avail_in = n;
98 		}
99 		ret = inflate(z, Z_SYNC_FLUSH);
100 	} while (ret == Z_OK && z->avail_out > 0);
101 
102 	if (ret == Z_OK) {
103 		zb->flags |= GOT_ZSTREAM_F_HAVE_MORE;
104 	} else {
105 		if (ret != Z_STREAM_END)
106 			return got_error(GOT_ERR_DECOMPRESSION);
107 		zb->flags &= ~GOT_ZSTREAM_F_HAVE_MORE;
108 	}
109 
110 	*outlenp = z->total_out - last_total_out;
111 	return NULL;
112 }
113 
114 const struct got_error *
115 got_inflate_read_fd(struct got_zstream_buf *zb, int fd, size_t *outlenp)
116 {
117 	size_t last_total_out = zb->z.total_out;
118 	z_stream *z = &zb->z;
119 	int ret = Z_ERRNO;
120 
121 	z->next_out = zb->outbuf;
122 	z->avail_out = zb->outlen;
123 
124 	*outlenp = 0;
125 	do {
126 		if (z->avail_in == 0) {
127 			ssize_t n = read(fd, zb->inbuf, zb->inlen);
128 			if (n < 0)
129 				return got_error_from_errno();
130 			else if (n == 0) {
131 				/* EOF */
132 				ret = Z_STREAM_END;
133 				break;
134 			}
135 			z->next_in = zb->inbuf;
136 			z->avail_in = n;
137 		}
138 		ret = inflate(z, Z_SYNC_FLUSH);
139 	} while (ret == Z_OK && z->avail_out > 0);
140 
141 	if (ret == Z_OK) {
142 		zb->flags |= GOT_ZSTREAM_F_HAVE_MORE;
143 	} else {
144 		if (ret != Z_STREAM_END)
145 			return got_error(GOT_ERR_DECOMPRESSION);
146 		zb->flags &= ~GOT_ZSTREAM_F_HAVE_MORE;
147 	}
148 
149 	*outlenp = z->total_out - last_total_out;
150 	return NULL;
151 }
152 
153 const struct got_error *
154 got_inflate_read_mmap(struct got_zstream_buf *zb, uint8_t *map, size_t offset,
155     size_t len, size_t *outlenp, size_t *consumed)
156 {
157 	size_t last_total_out = zb->z.total_out;
158 	z_stream *z = &zb->z;
159 	int ret = Z_ERRNO;
160 
161 	z->next_out = zb->outbuf;
162 	z->avail_out = zb->outlen;
163 
164 	*outlenp = 0;
165 	*consumed = 0;
166 
167 	do {
168 		if (z->avail_in == 0) {
169 			if (len == 0) {
170 				/* EOF */
171 				ret = Z_STREAM_END;
172 				break;
173 			}
174 			z->next_in = map + offset;
175 			z->avail_in = MIN(zb->inlen, len);
176 			*consumed += z->avail_in;
177 			offset += z->avail_in;
178 			len -= z->avail_in;
179 		}
180 		ret = inflate(z, Z_SYNC_FLUSH);
181 	} while (ret == Z_OK && z->avail_out > 0);
182 
183 	if (ret == Z_OK) {
184 		zb->flags |= GOT_ZSTREAM_F_HAVE_MORE;
185 	} else {
186 		if (ret != Z_STREAM_END)
187 			return got_error(GOT_ERR_DECOMPRESSION);
188 		zb->flags &= ~GOT_ZSTREAM_F_HAVE_MORE;
189 	}
190 
191 	*outlenp = z->total_out - last_total_out;
192 	return NULL;
193 }
194 
195 void
196 got_inflate_end(struct got_zstream_buf *zb)
197 {
198 	free(zb->inbuf);
199 	if (zb->flags & GOT_ZSTREAM_F_OWN_OUTBUF)
200 		free(zb->outbuf);
201 	inflateEnd(&zb->z);
202 }
203 
204 const struct got_error *
205 got_inflate_to_mem(uint8_t **outbuf, size_t *outlen, FILE *f)
206 {
207 	const struct got_error *err;
208 	size_t avail;
209 	struct got_zstream_buf zb;
210 	void *newbuf;
211 
212 	*outbuf = calloc(1, GOT_ZSTREAM_BUFSIZE);
213 	if (*outbuf == NULL)
214 		return got_error_from_errno();
215 	err = got_inflate_init(&zb, *outbuf, GOT_ZSTREAM_BUFSIZE);
216 	if (err)
217 		return err;
218 
219 	*outlen = 0;
220 
221 	do {
222 		err = got_inflate_read(&zb, f, &avail);
223 		if (err)
224 			return err;
225 		*outlen += avail;
226 		if (zb.flags & GOT_ZSTREAM_F_HAVE_MORE) {
227 			newbuf = reallocarray(*outbuf, 1,
228 			    *outlen + GOT_ZSTREAM_BUFSIZE);
229 			if (newbuf == NULL) {
230 				err = got_error_from_errno();
231 				free(*outbuf);
232 				*outbuf = NULL;
233 				*outlen = 0;
234 				goto done;
235 			}
236 			*outbuf = newbuf;
237 			zb.outbuf = newbuf + *outlen;
238 			zb.outlen = GOT_ZSTREAM_BUFSIZE;
239 		}
240 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
241 
242 done:
243 	got_inflate_end(&zb);
244 	return err;
245 }
246 
247 const struct got_error *
248 got_inflate_to_mem_fd(uint8_t **outbuf, size_t *outlen, int infd)
249 {
250 	const struct got_error *err;
251 	size_t avail;
252 	struct got_zstream_buf zb;
253 	void *newbuf;
254 
255 	*outbuf = calloc(1, GOT_ZSTREAM_BUFSIZE);
256 	if (*outbuf == NULL)
257 		return got_error_from_errno();
258 	err = got_inflate_init(&zb, *outbuf, GOT_ZSTREAM_BUFSIZE);
259 	if (err)
260 		return err;
261 
262 	*outlen = 0;
263 
264 	do {
265 		err = got_inflate_read_fd(&zb, infd, &avail);
266 		if (err)
267 			return err;
268 		*outlen += avail;
269 		if (zb.flags & GOT_ZSTREAM_F_HAVE_MORE) {
270 			newbuf = reallocarray(*outbuf, 1,
271 			    *outlen + GOT_ZSTREAM_BUFSIZE);
272 			if (newbuf == NULL) {
273 				err = got_error_from_errno();
274 				free(*outbuf);
275 				*outbuf = NULL;
276 				*outlen = 0;
277 				goto done;
278 			}
279 			*outbuf = newbuf;
280 			zb.outbuf = newbuf + *outlen;
281 			zb.outlen = GOT_ZSTREAM_BUFSIZE;
282 		}
283 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
284 
285 done:
286 	got_inflate_end(&zb);
287 	return err;
288 }
289 
290 const struct got_error *
291 got_inflate_to_mem_mmap(uint8_t **outbuf, size_t *outlen, uint8_t *map,
292     size_t offset, size_t len)
293 {
294 	const struct got_error *err;
295 	size_t avail;
296 	struct got_zstream_buf zb;
297 	void *newbuf;
298 	size_t consumed;
299 
300 	*outbuf = calloc(1, GOT_ZSTREAM_BUFSIZE);
301 	if (*outbuf == NULL)
302 		return got_error_from_errno();
303 	err = got_inflate_init(&zb, *outbuf, GOT_ZSTREAM_BUFSIZE);
304 	if (err)
305 		return err;
306 
307 	*outlen = 0;
308 
309 	do {
310 		err = got_inflate_read_mmap(&zb, map, offset, len, &avail,
311 		    &consumed);
312 		if (err)
313 			goto done;
314 		offset += consumed;
315 		len -= consumed;
316 		*outlen += avail;
317 		if (len == 0)
318 			break;
319 		if (zb.flags & GOT_ZSTREAM_F_HAVE_MORE) {
320 			newbuf = reallocarray(*outbuf, 1,
321 			    *outlen + GOT_ZSTREAM_BUFSIZE);
322 			if (newbuf == NULL) {
323 				err = got_error_from_errno();
324 				free(*outbuf);
325 				*outbuf = NULL;
326 				*outlen = 0;
327 				goto done;
328 			}
329 			*outbuf = newbuf;
330 			zb.outbuf = newbuf + *outlen;
331 			zb.outlen = GOT_ZSTREAM_BUFSIZE;
332 		}
333 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
334 
335 done:
336 	got_inflate_end(&zb);
337 	return err;
338 }
339 
340 const struct got_error *
341 got_inflate_to_fd(size_t *outlen, FILE *infile, int outfd)
342 {
343 	const struct got_error *err = NULL;
344 	size_t avail;
345 	struct got_zstream_buf zb;
346 
347 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
348 	if (err)
349 		goto done;
350 
351 	*outlen = 0;
352 
353 	do {
354 		err = got_inflate_read(&zb, infile, &avail);
355 		if (err)
356 			return err;
357 		if (avail > 0) {
358 			ssize_t n;
359 			n = write(outfd, zb.outbuf, avail);
360 			if (n != avail) {
361 				err = got_error_from_errno();
362 				goto done;
363 			}
364 			*outlen += avail;
365 		}
366 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
367 
368 done:
369 	if (err == NULL) {
370 		if (lseek(outfd, SEEK_SET, 0) == -1)
371 			err = got_error_from_errno();
372 	}
373 	got_inflate_end(&zb);
374 	return err;
375 }
376 
377 const struct got_error *
378 got_inflate_to_file(size_t *outlen, FILE *infile, FILE *outfile)
379 {
380 	const struct got_error *err;
381 	size_t avail;
382 	struct got_zstream_buf zb;
383 
384 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
385 	if (err)
386 		goto done;
387 
388 	*outlen = 0;
389 
390 	do {
391 		err = got_inflate_read(&zb, infile, &avail);
392 		if (err)
393 			return err;
394 		if (avail > 0) {
395 			size_t n;
396 			n = fwrite(zb.outbuf, avail, 1, outfile);
397 			if (n != 1) {
398 				err = got_ferror(outfile, GOT_ERR_IO);
399 				goto done;
400 			}
401 			*outlen += avail;
402 		}
403 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
404 
405 done:
406 	if (err == NULL)
407 		rewind(outfile);
408 	got_inflate_end(&zb);
409 	return err;
410 }
411 
412 const struct got_error *
413 got_inflate_to_file_fd(size_t *outlen, int infd, FILE *outfile)
414 {
415 	const struct got_error *err;
416 	size_t avail;
417 	struct got_zstream_buf zb;
418 
419 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
420 	if (err)
421 		goto done;
422 
423 	*outlen = 0;
424 
425 	do {
426 		err = got_inflate_read_fd(&zb, infd, &avail);
427 		if (err)
428 			return err;
429 		if (avail > 0) {
430 			size_t n;
431 			n = fwrite(zb.outbuf, avail, 1, outfile);
432 			if (n != 1) {
433 				err = got_ferror(outfile, GOT_ERR_IO);
434 				goto done;
435 			}
436 			*outlen += avail;
437 		}
438 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
439 
440 done:
441 	if (err == NULL)
442 		rewind(outfile);
443 	got_inflate_end(&zb);
444 	return err;
445 }
446 
447 const struct got_error *
448 got_inflate_to_file_mmap(size_t *outlen, uint8_t *map, size_t offset,
449     size_t len, FILE *outfile)
450 {
451 	const struct got_error *err;
452 	size_t avail;
453 	struct got_zstream_buf zb;
454 	size_t consumed;
455 
456 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
457 	if (err)
458 		goto done;
459 
460 	*outlen = 0;
461 
462 	do {
463 		err = got_inflate_read_mmap(&zb, map, offset, len, &avail,
464 		    &consumed);
465 		if (err)
466 			return err;
467 		offset += consumed;
468 		len -= consumed;
469 		if (avail > 0) {
470 			size_t n;
471 			n = fwrite(zb.outbuf, avail, 1, outfile);
472 			if (n != 1) {
473 				err = got_ferror(outfile, GOT_ERR_IO);
474 				goto done;
475 			}
476 			*outlen += avail;
477 		}
478 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
479 
480 done:
481 	if (err == NULL)
482 		rewind(outfile);
483 	got_inflate_end(&zb);
484 	return err;
485 }