op public repos

Blob

Date:: Fri Jul 13 09:26:37 2018 UTC
Message:: fix a leak in got_inflate_to_mem_mmap()
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 		free(*outbuf);
306 		*outbuf = NULL;
307 		return err;
308 	}
309 
310 	*outlen = 0;
311 
312 	do {
313 		err = got_inflate_read_mmap(&zb, map, offset, len, &avail,
314 		    &consumed);
315 		if (err)
316 			goto done;
317 		offset += consumed;
318 		len -= consumed;
319 		*outlen += avail;
320 		if (len == 0)
321 			break;
322 		if (zb.flags & GOT_ZSTREAM_F_HAVE_MORE) {
323 			newbuf = reallocarray(*outbuf, 1,
324 			    *outlen + GOT_ZSTREAM_BUFSIZE);
325 			if (newbuf == NULL) {
326 				err = got_error_from_errno();
327 				free(*outbuf);
328 				*outbuf = NULL;
329 				*outlen = 0;
330 				goto done;
331 			}
332 			*outbuf = newbuf;
333 			zb.outbuf = newbuf + *outlen;
334 			zb.outlen = GOT_ZSTREAM_BUFSIZE;
335 		}
336 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
337 
338 done:
339 	got_inflate_end(&zb);
340 	return err;
341 }
342 
343 const struct got_error *
344 got_inflate_to_fd(size_t *outlen, FILE *infile, int outfd)
345 {
346 	const struct got_error *err = NULL;
347 	size_t avail;
348 	struct got_zstream_buf zb;
349 
350 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
351 	if (err)
352 		goto done;
353 
354 	*outlen = 0;
355 
356 	do {
357 		err = got_inflate_read(&zb, infile, &avail);
358 		if (err)
359 			return err;
360 		if (avail > 0) {
361 			ssize_t n;
362 			n = write(outfd, zb.outbuf, avail);
363 			if (n != avail) {
364 				err = got_error_from_errno();
365 				goto done;
366 			}
367 			*outlen += avail;
368 		}
369 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
370 
371 done:
372 	if (err == NULL) {
373 		if (lseek(outfd, SEEK_SET, 0) == -1)
374 			err = got_error_from_errno();
375 	}
376 	got_inflate_end(&zb);
377 	return err;
378 }
379 
380 const struct got_error *
381 got_inflate_to_file(size_t *outlen, FILE *infile, FILE *outfile)
382 {
383 	const struct got_error *err;
384 	size_t avail;
385 	struct got_zstream_buf zb;
386 
387 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
388 	if (err)
389 		goto done;
390 
391 	*outlen = 0;
392 
393 	do {
394 		err = got_inflate_read(&zb, infile, &avail);
395 		if (err)
396 			return err;
397 		if (avail > 0) {
398 			size_t n;
399 			n = fwrite(zb.outbuf, avail, 1, outfile);
400 			if (n != 1) {
401 				err = got_ferror(outfile, GOT_ERR_IO);
402 				goto done;
403 			}
404 			*outlen += avail;
405 		}
406 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
407 
408 done:
409 	if (err == NULL)
410 		rewind(outfile);
411 	got_inflate_end(&zb);
412 	return err;
413 }
414 
415 const struct got_error *
416 got_inflate_to_file_fd(size_t *outlen, int infd, FILE *outfile)
417 {
418 	const struct got_error *err;
419 	size_t avail;
420 	struct got_zstream_buf zb;
421 
422 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
423 	if (err)
424 		goto done;
425 
426 	*outlen = 0;
427 
428 	do {
429 		err = got_inflate_read_fd(&zb, infd, &avail);
430 		if (err)
431 			return err;
432 		if (avail > 0) {
433 			size_t n;
434 			n = fwrite(zb.outbuf, avail, 1, outfile);
435 			if (n != 1) {
436 				err = got_ferror(outfile, GOT_ERR_IO);
437 				goto done;
438 			}
439 			*outlen += avail;
440 		}
441 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
442 
443 done:
444 	if (err == NULL)
445 		rewind(outfile);
446 	got_inflate_end(&zb);
447 	return err;
448 }
449 
450 const struct got_error *
451 got_inflate_to_file_mmap(size_t *outlen, uint8_t *map, size_t offset,
452     size_t len, FILE *outfile)
453 {
454 	const struct got_error *err;
455 	size_t avail;
456 	struct got_zstream_buf zb;
457 	size_t consumed;
458 
459 	err = got_inflate_init(&zb, NULL, GOT_ZSTREAM_BUFSIZE);
460 	if (err)
461 		goto done;
462 
463 	*outlen = 0;
464 
465 	do {
466 		err = got_inflate_read_mmap(&zb, map, offset, len, &avail,
467 		    &consumed);
468 		if (err)
469 			return err;
470 		offset += consumed;
471 		len -= consumed;
472 		if (avail > 0) {
473 			size_t n;
474 			n = fwrite(zb.outbuf, avail, 1, outfile);
475 			if (n != 1) {
476 				err = got_ferror(outfile, GOT_ERR_IO);
477 				goto done;
478 			}
479 			*outlen += avail;
480 		}
481 	} while (zb.flags & GOT_ZSTREAM_F_HAVE_MORE);
482 
483 done:
484 	if (err == NULL)
485 		rewind(outfile);
486 	got_inflate_end(&zb);
487 	return err;
488 }