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/types.h>
18 #include <sys/stat.h>
19 #include <sys/queue.h>
20 
21 #include <dirent.h>
22 #include <fcntl.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdint.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <limits.h>
29 #include <sha1.h>
30 #include <endian.h>
31 #include <zlib.h>
32 
33 #include "got_error.h"
34 #include "got_object.h"
35 #include "got_repository.h"
36 #include "got_opentemp.h"
37 
38 #include "got_lib_sha1.h"
39 #include "got_lib_pack.h"
40 #include "got_lib_path.h"
41 #include "got_lib_delta.h"
42 #include "got_lib_zbuf.h"
43 #include "got_lib_object.h"
44 #include "got_lib_repository.h"
45 
46 #ifndef nitems
47 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
48 #endif
49 
50 #define GOT_PACK_PREFIX		"pack-"
51 #define GOT_PACKFILE_SUFFIX	".pack"
52 #define GOT_PACKIDX_SUFFIX		".idx"
53 #define GOT_PACKFILE_NAMELEN	(strlen(GOT_PACK_PREFIX) + \
54 				SHA1_DIGEST_STRING_LENGTH - 1 + \
55 				strlen(GOT_PACKFILE_SUFFIX))
56 #define GOT_PACKIDX_NAMELEN	(strlen(GOT_PACK_PREFIX) + \
57 				SHA1_DIGEST_STRING_LENGTH - 1 + \
58 				strlen(GOT_PACKIDX_SUFFIX))
59 
60 #ifndef MIN
61 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
62 #endif
63 
64 static const struct got_error *
65 verify_fanout_table(uint32_t *fanout_table)
66 {
67 	int i;
68 
69 	for (i = 0; i < 0xff - 1; i++) {
70 		if (be32toh(fanout_table[i]) > be32toh(fanout_table[i + 1]))
71 			return got_error(GOT_ERR_BAD_PACKIDX);
72 	}
73 
74 	return NULL;
75 }
76 
77 static const struct got_error *
78 get_packfile_size(size_t *size, const char *path)
79 {
80 	struct stat sb;
81 	char *dot;
82 
83 	*size = 0;
84 
85 	dot = strrchr(path, '.');
86 	if (dot == NULL)
87 		return got_error(GOT_ERR_BAD_PATH);
88 
89 	/* Path must point to a pack index or to a pack file. */
90 	if (strcmp(dot, ".idx") == 0) {
91 		const struct got_error *err = NULL;
92 		char *path_pack;
93 		char base_path[PATH_MAX];
94 
95 		/* Convert pack index path to pack file path. */
96 		if (strlcpy(base_path, path, PATH_MAX) > PATH_MAX)
97 			return got_error(GOT_ERR_NO_SPACE);
98 		dot = strrchr(base_path, '.');
99 		if (dot == NULL)
100 			return got_error(GOT_ERR_BAD_PATH);
101 		*dot = '\0';
102 		if (asprintf(&path_pack, "%s.pack", base_path) == -1)
103 			return got_error_from_errno();
104 
105 		if (stat(path_pack, &sb) != 0)
106 			err = got_error_from_errno();
107 		free(path_pack);
108 		if (err)
109 			return err;
110 	} else if (strcmp(dot, ".pack") == 0) {
111 		if (stat(path, &sb) != 0)
112 			return got_error_from_errno();
113 	} else
114 		return got_error(GOT_ERR_BAD_PATH);
115 
116 	*size = sb.st_size;
117 	return 0;
118 }
119 
120 const struct got_error *
121 got_packidx_open(struct got_packidx **packidx, const char *path)
122 {
123 	struct got_packidx *p;
124 	FILE *f;
125 	const struct got_error *err = NULL;
126 	size_t n, nobj, packfile_size;
127 	SHA1_CTX ctx;
128 	uint8_t sha1[SHA1_DIGEST_LENGTH];
129 
130 	*packidx = NULL;
131 
132 	SHA1Init(&ctx);
133 
134 	f = fopen(path, "rb");
135 	if (f == NULL)
136 		return got_error_from_errno();
137 
138 	err = get_packfile_size(&packfile_size, path);
139 	if (err)
140 		return err;
141 
142 	p = calloc(1, sizeof(*p));
143 	if (p == NULL)
144 		return got_error_from_errno();
145 	p->path_packidx = strdup(path);
146 	if (p->path_packidx == NULL) {
147 		err = got_error_from_errno();
148 		free(p->path_packidx);
149 		free(p);
150 		return err;
151 	}
152 
153 	n = fread(&p->hdr.magic, sizeof(p->hdr.magic), 1, f);
154 	if (n != 1) {
155 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
156 		goto done;
157 	}
158 
159 	if (betoh32(p->hdr.magic) != GOT_PACKIDX_V2_MAGIC) {
160 		err = got_error(GOT_ERR_BAD_PACKIDX);
161 		goto done;
162 	}
163 
164 	SHA1Update(&ctx, (uint8_t *)&p->hdr.magic, sizeof(p->hdr.magic));
165 
166 	n = fread(&p->hdr.version, sizeof(p->hdr.version), 1, f);
167 	if (n != 1) {
168 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
169 		goto done;
170 	}
171 
172 	if (betoh32(p->hdr.version) != GOT_PACKIDX_VERSION) {
173 		err = got_error(GOT_ERR_BAD_PACKIDX);
174 		goto done;
175 	}
176 
177 	SHA1Update(&ctx, (uint8_t *)&p->hdr.version, sizeof(p->hdr.version));
178 
179 	n = fread(&p->hdr.fanout_table, sizeof(p->hdr.fanout_table), 1, f);
180 	if (n != 1) {
181 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
182 		goto done;
183 	}
184 
185 	err = verify_fanout_table(p->hdr.fanout_table);
186 	if (err)
187 		goto done;
188 
189 	SHA1Update(&ctx, (uint8_t *)p->hdr.fanout_table, sizeof(p->hdr.fanout_table));
190 
191 	nobj = betoh32(p->hdr.fanout_table[0xff]);
192 
193 	p->hdr.sorted_ids = calloc(nobj, sizeof(*p->hdr.sorted_ids));
194 	if (p->hdr.sorted_ids == NULL) {
195 		err = got_error_from_errno();
196 		goto done;
197 	}
198 
199 	n = fread(p->hdr.sorted_ids, sizeof(*p->hdr.sorted_ids), nobj, f);
200 	if (n != nobj) {
201 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
202 		goto done;
203 	}
204 
205 	SHA1Update(&ctx, (uint8_t *)p->hdr.sorted_ids,
206 	    nobj * sizeof(*p->hdr.sorted_ids));
207 
208 	p->hdr.crc32 = calloc(nobj, sizeof(*p->hdr.crc32));
209 	if (p->hdr.crc32 == NULL) {
210 		err = got_error_from_errno();
211 		goto done;
212 	}
213 
214 	n = fread(p->hdr.crc32, sizeof(*p->hdr.crc32), nobj, f);
215 	if (n != nobj) {
216 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
217 		goto done;
218 	}
219 
220 	SHA1Update(&ctx, (uint8_t *)p->hdr.crc32, nobj * sizeof(*p->hdr.crc32));
221 
222 	p->hdr.offsets = calloc(nobj, sizeof(*p->hdr.offsets));
223 	if (p->hdr.offsets == NULL) {
224 		err = got_error_from_errno();
225 		goto done;
226 	}
227 
228 	n = fread(p->hdr.offsets, sizeof(*p->hdr.offsets), nobj, f);
229 	if (n != nobj) {
230 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
231 		goto done;
232 	}
233 
234 	SHA1Update(&ctx, (uint8_t *)p->hdr.offsets, nobj * sizeof(*p->hdr.offsets));
235 
236 	/* Large file offsets are contained only in files > 2GB. */
237 	if (packfile_size <= 0x80000000)
238 		goto checksum;
239 
240 	p->hdr.large_offsets = calloc(nobj, sizeof(*p->hdr.large_offsets));
241 	if (p->hdr.large_offsets == NULL) {
242 		err = got_error_from_errno();
243 		goto done;
244 	}
245 
246 	n = fread(p->hdr.large_offsets, sizeof(*p->hdr.large_offsets), nobj, f);
247 	if (n != nobj) {
248 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
249 		goto done;
250 	}
251 
252 	SHA1Update(&ctx, (uint8_t*)p->hdr.large_offsets,
253 	    nobj * sizeof(*p->hdr.large_offsets));
254 
255 checksum:
256 	n = fread(&p->hdr.trailer, sizeof(p->hdr.trailer), 1, f);
257 	if (n != 1) {
258 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
259 		goto done;
260 	}
261 
262 	SHA1Update(&ctx, p->hdr.trailer.packfile_sha1, SHA1_DIGEST_LENGTH);
263 	SHA1Final(sha1, &ctx);
264 	if (memcmp(p->hdr.trailer.packidx_sha1, sha1, SHA1_DIGEST_LENGTH) != 0)
265 		err = got_error(GOT_ERR_PACKIDX_CSUM);
266 done:
267 	fclose(f);
268 	if (err)
269 		got_packidx_close(p);
270 	else
271 		*packidx = p;
272 	return err;
273 }
274 
275 void
276 got_packidx_close(struct got_packidx *packidx)
277 {
278 	free(packidx->hdr.sorted_ids);
279 	free(packidx->hdr.offsets);
280 	free(packidx->hdr.crc32);
281 	free(packidx->hdr.large_offsets);
282 	free(packidx->path_packidx);
283 	free(packidx);
284 }
285 
286 static int
287 is_packidx_filename(const char *name, size_t len)
288 {
289 	if (len != GOT_PACKIDX_NAMELEN)
290 		return 0;
291 
292 	if (strncmp(name, GOT_PACK_PREFIX, strlen(GOT_PACK_PREFIX)) != 0)
293 		return 0;
294 
295 	if (strcmp(name + strlen(GOT_PACK_PREFIX) +
296 	    SHA1_DIGEST_STRING_LENGTH - 1, GOT_PACKIDX_SUFFIX) != 0)
297 		return 0;
298 
299 	return 1;
300 }
301 
302 static off_t
303 get_object_offset(struct got_packidx *packidx, int idx)
304 {
305 	uint32_t totobj = betoh32(packidx->hdr.fanout_table[0xff]);
306 	uint32_t offset = betoh32(packidx->hdr.offsets[idx]);
307 	if (offset & GOT_PACKIDX_OFFSET_VAL_IS_LARGE_IDX) {
308 		uint64_t loffset;
309 		idx = offset & GOT_PACKIDX_OFFSET_VAL_MASK;
310 		if (idx < 0 || idx > totobj ||
311 		    packidx->hdr.large_offsets == NULL)
312 			return -1;
313 		loffset = betoh64(packidx->hdr.large_offsets[idx]);
314 		return (loffset > INT64_MAX ? -1 : (off_t)loffset);
315 	}
316 	return (off_t)(offset & GOT_PACKIDX_OFFSET_VAL_MASK);
317 }
318 
319 static const struct got_error *
320 get_packfile_path(char **path_packfile, struct got_repository *repo,
321     struct got_packidx *packidx);
322 
323 static int
324 get_object_idx(struct got_packidx *packidx, struct got_object_id *id,
325     struct got_repository *repo)
326 {
327 	u_int8_t id0 = id->sha1[0];
328 	uint32_t totobj = betoh32(packidx->hdr.fanout_table[0xff]);
329 	int i = 0;
330 
331 	if (id0 > 0)
332 		i = betoh32(packidx->hdr.fanout_table[id0 - 1]);
333 
334 	while (i < totobj) {
335 		struct got_object_id *oid = &packidx->hdr.sorted_ids[i];
336 		int cmp = got_object_id_cmp(id, oid);
337 
338 		if (cmp == 0)
339 			return i;
340 		i++;
341 	}
342 
343 	return -1;
344 }
345 
346 static struct got_packidx *
347 dup_packidx(struct got_packidx *packidx)
348 {
349 	struct got_packidx *p;
350 	size_t nobj;
351 
352 	p = calloc(1, sizeof(*p));
353 	if (p == NULL)
354 		return NULL;
355 
356 	p->path_packidx = strdup(packidx->path_packidx);
357 	if (p->path_packidx == NULL) {
358 		free(p);
359 		return NULL;
360 	}
361 	memcpy(&p->hdr, &packidx->hdr, sizeof(p->hdr));
362 	p->hdr.sorted_ids = NULL;
363 	p->hdr.crc32 = NULL;
364 	p->hdr.offsets = NULL;
365 	p->hdr.large_offsets = NULL;
366 
367 	nobj = betoh32(p->hdr.fanout_table[0xff]);
368 
369 	p->hdr.sorted_ids = calloc(nobj, sizeof(*p->hdr.sorted_ids));
370 	if (p->hdr.sorted_ids == NULL)
371 		goto err;
372 	memcpy(p->hdr.sorted_ids, packidx->hdr.sorted_ids,
373 	    nobj * sizeof(*p->hdr.sorted_ids));
374 
375 	p->hdr.crc32 = calloc(nobj, sizeof(*p->hdr.crc32));
376 	if (p->hdr.crc32 == NULL)
377 		goto err;
378 	memcpy(p->hdr.crc32, packidx->hdr.crc32, nobj * sizeof(*p->hdr.crc32));
379 
380 	p->hdr.offsets = calloc(nobj, sizeof(*p->hdr.offsets));
381 	if (p->hdr.offsets == NULL)
382 		goto err;
383 	memcpy(p->hdr.offsets, packidx->hdr.offsets,
384 	    nobj * sizeof(*p->hdr.offsets));
385 
386 	if (p->hdr.large_offsets) {
387 		p->hdr.large_offsets = calloc(nobj, sizeof(*p->hdr.large_offsets));
388 		if (p->hdr.large_offsets == NULL)
389 			goto err;
390 		memcpy(p->hdr.large_offsets, packidx->hdr.large_offsets,
391 		    nobj * sizeof(*p->hdr.large_offsets));
392 	}
393 
394 	return p;
395 
396 err:
397 	free(p->hdr.large_offsets);
398 	free(p->hdr.offsets);
399 	free(p->hdr.crc32);
400 	free(p->hdr.sorted_ids);
401 	free(p->path_packidx);
402 	free(p);
403 	return NULL;
404 }
405 
406 static void
407 cache_packidx(struct got_packidx *packidx, struct got_repository *repo)
408 {
409 	int i;
410 
411 	for (i = 0; i < nitems(repo->packidx_cache); i++) {
412 		if (repo->packidx_cache[i] == NULL)
413 			break;
414 	}
415 
416 	if (i == nitems(repo->packidx_cache)) {
417 		got_packidx_close(repo->packidx_cache[i - 1]);
418 		memmove(&repo->packidx_cache[1], &repo->packidx_cache[0],
419 		    sizeof(repo->packidx_cache) -
420 		    sizeof(repo->packidx_cache[0]));
421 		i = 0;
422 	}
423 
424 	repo->packidx_cache[i] = dup_packidx(packidx);
425 }
426 
427 static const struct got_error *
428 search_packidx(struct got_packidx **packidx, int *idx,
429     struct got_repository *repo, struct got_object_id *id)
430 {
431 	const struct got_error *err;
432 	char *path_packdir;
433 	DIR *packdir;
434 	struct dirent *dent;
435 	char *path_packidx;
436 	int i;
437 
438 	/* Search pack index cache. */
439 	for (i = 0; i < nitems(repo->packidx_cache); i++) {
440 		if (repo->packidx_cache[i] == NULL)
441 			break;
442 		*idx = get_object_idx(repo->packidx_cache[i], id, repo);
443 		if (*idx != -1) {
444 			*packidx = repo->packidx_cache[i];
445 			return NULL;
446 		}
447 	}
448 	/* No luck. Search the filesystem. */
449 
450 	path_packdir = got_repo_get_path_objects_pack(repo);
451 	if (path_packdir == NULL)
452 		return got_error_from_errno();
453 
454 	packdir = opendir(path_packdir);
455 	if (packdir == NULL) {
456 		err = got_error_from_errno();
457 		goto done;
458 	}
459 
460 	while ((dent = readdir(packdir)) != NULL) {
461 		if (!is_packidx_filename(dent->d_name, dent->d_namlen))
462 			continue;
463 
464 		if (asprintf(&path_packidx, "%s/%s", path_packdir,
465 		    dent->d_name) == -1) {
466 			err = got_error_from_errno();
467 			goto done;
468 		}
469 
470 		err = got_packidx_open(packidx, path_packidx);
471 		free(path_packidx);
472 		if (err)
473 			goto done;
474 
475 		*idx = get_object_idx(*packidx, id, repo);
476 		if (*idx != -1) {
477 			err = NULL; /* found the object */
478 			cache_packidx(*packidx, repo);
479 			goto done;
480 		}
481 
482 		got_packidx_close(*packidx);
483 		*packidx = NULL;
484 	}
485 
486 	err = got_error(GOT_ERR_NO_OBJ);
487 done:
488 	free(path_packdir);
489 	if (packdir && closedir(packdir) != 0 && err == 0)
490 		err = got_error_from_errno();
491 	return err;
492 }
493 
494 static const struct got_error *
495 get_packfile_path(char **path_packfile, struct got_repository *repo,
496     struct got_packidx *packidx)
497 {
498 	size_t size;
499 
500 	/* Packfile path contains ".pack" instead of ".idx", so add one byte. */
501 	size = strlen(packidx->path_packidx) + 2;
502 	if (size < GOT_PACKFILE_NAMELEN + 1)
503 		return got_error(GOT_ERR_BAD_PATH);
504 
505 	*path_packfile = calloc(size, sizeof(**path_packfile));
506 	if (*path_packfile == NULL)
507 		return got_error_from_errno();
508 
509 	/* Copy up to and excluding ".idx". */
510 	strncpy(*path_packfile, packidx->path_packidx, size - strlen(".idx") - 2);
511 
512 	if (strlcat(*path_packfile, GOT_PACKFILE_SUFFIX, size) >= size)
513 		return got_error(GOT_ERR_NO_SPACE);
514 
515 	return NULL;
516 }
517 
518 const struct got_error *
519 read_packfile_hdr(int fd, struct got_packidx *packidx)
520 {
521 	const struct got_error *err = NULL;
522 	uint32_t totobj = betoh32(packidx->hdr.fanout_table[0xff]);
523 	struct got_packfile_hdr hdr;
524 	ssize_t n;
525 
526 	n = read(fd, &hdr, sizeof(hdr));
527 	if (n < 0)
528 		return got_error_from_errno();
529 	if (n != sizeof(hdr))
530 		return got_error(GOT_ERR_BAD_PACKFILE);
531 
532 	if (betoh32(hdr.signature) != GOT_PACKFILE_SIGNATURE ||
533 	    betoh32(hdr.version) != GOT_PACKFILE_VERSION ||
534 	    betoh32(hdr.nobjects) != totobj)
535 		err = got_error(GOT_ERR_BAD_PACKFILE);
536 
537 	return err;
538 }
539 
540 static const struct got_error *
541 open_packfile(int *fd, const char *path_packfile,
542     struct got_repository *repo, struct got_packidx *packidx)
543 {
544 	const struct got_error *err = NULL;
545 
546 	*fd = open(path_packfile, O_RDONLY | O_NOFOLLOW, GOT_DEFAULT_FILE_MODE);
547 	if (*fd == -1)
548 		return got_error_from_errno();
549 
550 	if (packidx) {
551 		err = read_packfile_hdr(*fd, packidx);
552 		if (err) {
553 			close(*fd);
554 			*fd = -1;
555 		}
556 	}
557 	return err;
558 }
559 
560 void
561 got_pack_close(struct got_pack *pack)
562 {
563 	close(pack->fd);
564 	pack->fd = -1;
565 	free(pack->path_packfile);
566 	pack->path_packfile = NULL;
567 	pack->filesize = 0;
568 }
569 
570 static const struct got_error *
571 cache_pack(struct got_pack **packp, const char *path_packfile,
572     struct got_packidx *packidx, struct got_repository *repo)
573 {
574 	const struct got_error *err = NULL;
575 	struct got_pack *pack = NULL;
576 	int i;
577 
578 	if (packp)
579 		*packp = NULL;
580 
581 	for (i = 0; i < nitems(repo->packs); i++) {
582 		pack = &repo->packs[i];
583 		if (pack->path_packfile == NULL)
584 			break;
585 		if (strcmp(pack->path_packfile, path_packfile) == 0)
586 			return NULL;
587 	}
588 
589 	if (i == nitems(repo->packs) - 1) {
590 		got_pack_close(&repo->packs[i - 1]);
591 		memmove(&repo->packs[1], &repo->packs[0],
592 		    sizeof(repo->packs) - sizeof(repo->packs[0]));
593 		i = 0;
594 	}
595 
596 	pack = &repo->packs[i];
597 
598 	pack->path_packfile = strdup(path_packfile);
599 	if (pack->path_packfile == NULL) {
600 		err = got_error_from_errno();
601 		goto done;
602 	}
603 
604 	err = open_packfile(&pack->fd, path_packfile, repo, packidx);
605 	if (err)
606 		goto done;
607 
608 	err = get_packfile_size(&pack->filesize, path_packfile);
609 done:
610 	if (err) {
611 		if (pack) {
612 			free(pack->path_packfile);
613 			memset(pack, 0, sizeof(*pack));
614 		}
615 	} else if (packp)
616 		*packp = pack;
617 	return err;
618 }
619 
620 struct got_pack *
621 get_cached_pack(const char *path_packfile, struct got_repository *repo)
622 {
623 	struct got_pack *pack = NULL;
624 	int i;
625 
626 	for (i = 0; i < nitems(repo->packs); i++) {
627 		pack = &repo->packs[i];
628 		if (pack->path_packfile == NULL)
629 			break;
630 		if (strcmp(pack->path_packfile, path_packfile) == 0)
631 			return pack;
632 	}
633 
634 	return NULL;
635 }
636 
637 static const struct got_error *
638 parse_object_type_and_size(uint8_t *type, uint64_t *size, size_t *len, int fd)
639 {
640 	uint8_t t = 0;
641 	uint64_t s = 0;
642 	uint8_t sizeN;
643 	ssize_t n;
644 	int i = 0;
645 
646 	do {
647 		/* We do not support size values which don't fit in 64 bit. */
648 		if (i > 9)
649 			return got_error(GOT_ERR_NO_SPACE);
650 
651 		n = read(fd, &sizeN, sizeof(sizeN));
652 		if (n < 0)
653 			return got_error_from_errno();
654 		if (n != sizeof(sizeN))
655 			return got_error(GOT_ERR_BAD_PACKFILE);
656 
657 		if (i == 0) {
658 			t = (sizeN & GOT_PACK_OBJ_SIZE0_TYPE_MASK) >>
659 			    GOT_PACK_OBJ_SIZE0_TYPE_MASK_SHIFT;
660 			s = (sizeN & GOT_PACK_OBJ_SIZE0_VAL_MASK);
661 		} else {
662 			size_t shift = 4 + 7 * (i - 1);
663 			s |= ((sizeN & GOT_PACK_OBJ_SIZE_VAL_MASK) << shift);
664 		}
665 		i++;
666 	} while (sizeN & GOT_PACK_OBJ_SIZE_MORE);
667 
668 	*type = t;
669 	*size = s;
670 	*len = i * sizeof(sizeN);
671 	return NULL;
672 }
673 
674 static const struct got_error *
675 open_plain_object(struct got_object **obj, const char *path_packfile,
676     struct got_object_id *id, uint8_t type, off_t offset, size_t size)
677 {
678 	*obj = calloc(1, sizeof(**obj));
679 	if (*obj == NULL)
680 		return got_error_from_errno();
681 
682 	(*obj)->path_packfile = strdup(path_packfile);
683 	if ((*obj)->path_packfile == NULL) {
684 		const struct got_error *err = got_error_from_errno();
685 		free(*obj);
686 		*obj = NULL;
687 		return err;
688 	}
689 
690 	(*obj)->type = type;
691 	(*obj)->flags = GOT_OBJ_FLAG_PACKED;
692 	(*obj)->hdrlen = 0;
693 	(*obj)->size = size;
694 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
695 	(*obj)->pack_offset = offset;
696 
697 	return NULL;
698 }
699 
700 static const struct got_error *
701 parse_negative_offset(int64_t *offset, size_t *len, int fd)
702 {
703 	int64_t o = 0;
704 	uint8_t offN;
705 	ssize_t n;
706 	int i = 0;
707 
708 	do {
709 		/* We do not support offset values which don't fit in 64 bit. */
710 		if (i > 8)
711 			return got_error(GOT_ERR_NO_SPACE);
712 
713 		n = read(fd, &offN, sizeof(offN));
714 		if (n < 0)
715 			return got_error_from_errno();
716 		if (n != sizeof(offN))
717 			return got_error(GOT_ERR_BAD_PACKFILE);
718 
719 		if (i == 0)
720 			o = (offN & GOT_PACK_OBJ_DELTA_OFF_VAL_MASK);
721 		else {
722 			o++;
723 			o <<= 7;
724 			o += (offN & GOT_PACK_OBJ_DELTA_OFF_VAL_MASK);
725 		}
726 		i++;
727 	} while (offN & GOT_PACK_OBJ_DELTA_OFF_MORE);
728 
729 	*offset = o;
730 	*len = i * sizeof(offN);
731 	return NULL;
732 }
733 
734 static const struct got_error *
735 parse_offset_delta(off_t *base_offset, int fd, off_t offset)
736 {
737 	const struct got_error *err;
738 	int64_t negoffset;
739 	size_t negofflen;
740 
741 	err = parse_negative_offset(&negoffset, &negofflen, fd);
742 	if (err)
743 		return err;
744 
745 	/* Compute the base object's offset (must be in the same pack file). */
746 	*base_offset = (offset - negoffset);
747 	if (*base_offset <= 0)
748 		return got_error(GOT_ERR_BAD_PACKFILE);
749 
750 	return NULL;
751 }
752 
753 static const struct got_error *
754 resolve_delta_chain(struct got_delta_chain *, struct got_repository *,
755     int, size_t, const char *, off_t, size_t, int, size_t, unsigned int);
756 
757 static const struct got_error *
758 add_delta(struct got_delta_chain *deltas, const char *path_packfile,
759     off_t delta_offset, size_t tslen, int delta_type, size_t delta_size,
760     size_t delta_data_offset, uint8_t *delta_buf, size_t delta_len)
761 {
762 	struct got_delta *delta;
763 
764 	delta = got_delta_open(path_packfile, delta_offset, tslen,
765 	    delta_type, delta_size, delta_data_offset, delta_buf,
766 	    delta_len);
767 	if (delta == NULL)
768 		return got_error_from_errno();
769 	/* delta is freed in got_object_close() */
770 	deltas->nentries++;
771 	SIMPLEQ_INSERT_HEAD(&deltas->entries, delta, entry);
772 	return NULL;
773 }
774 
775 static const struct got_error *
776 resolve_offset_delta(struct got_delta_chain *deltas,
777     struct got_repository *repo, int fd, size_t packfile_size,
778     const char *path_packfile, off_t delta_offset, size_t tslen,
779     int delta_type, size_t delta_size, unsigned int recursion)
780 
781 {
782 	const struct got_error *err;
783 	off_t base_offset;
784 	uint8_t base_type;
785 	uint64_t base_size;
786 	size_t base_tslen;
787 	off_t delta_data_offset;
788 	uint8_t *delta_buf;
789 	size_t delta_len;
790 
791 	err = parse_offset_delta(&base_offset, fd, delta_offset);
792 	if (err)
793 		return err;
794 
795 	delta_data_offset = lseek(fd, 0, SEEK_CUR);
796 	if (delta_data_offset == -1)
797 		return got_error_from_errno();
798 
799 	err = got_inflate_to_mem_fd(&delta_buf, &delta_len, fd);
800 	if (err)
801 		return err;
802 
803 	err = add_delta(deltas, path_packfile, delta_offset, tslen,
804 	    delta_type, delta_size, delta_data_offset, delta_buf, delta_len);
805 	if (err)
806 		return err;
807 
808 	/* An offset delta must be in the same packfile. */
809 	if (base_offset >= packfile_size)
810 		return got_error(GOT_ERR_PACK_OFFSET);
811 	if (lseek(fd, base_offset, SEEK_SET) == -1)
812 		return got_error_from_errno();
813 
814 	err = parse_object_type_and_size(&base_type, &base_size, &base_tslen,
815 	    fd);
816 	if (err)
817 		return err;
818 
819 	return resolve_delta_chain(deltas, repo, fd, packfile_size,
820 	    path_packfile, base_offset, base_tslen, base_type, base_size,
821 	    recursion - 1);
822 }
823 
824 static const struct got_error *
825 resolve_ref_delta(struct got_delta_chain *deltas, struct got_repository *repo,
826     int fd, const char *path_packfile, off_t delta_offset,
827     size_t tslen, int delta_type, size_t delta_size, unsigned int recursion)
828 {
829 	const struct got_error *err;
830 	struct got_object_id id;
831 	struct got_packidx *packidx;
832 	int idx;
833 	off_t base_offset;
834 	uint8_t base_type;
835 	uint64_t base_size;
836 	size_t base_tslen;
837 	ssize_t n;
838 	char *path_base_packfile;
839 	struct got_pack *base_pack;
840 	off_t delta_data_offset;
841 	uint8_t *delta_buf;
842 	size_t delta_len;
843 
844 	n = read(fd, &id, sizeof(id));
845 	if (n < 0)
846 		return got_error_from_errno();
847 	if (n != sizeof(id))
848 		return got_error(GOT_ERR_BAD_PACKFILE);
849 
850 	delta_data_offset = lseek(fd, 0, SEEK_CUR);
851 	if (delta_data_offset == -1)
852 		return got_error_from_errno();
853 
854 	err = got_inflate_to_mem_fd(&delta_buf, &delta_len, fd);
855 	if (err)
856 		return err;
857 
858 	err = add_delta(deltas, path_packfile, delta_offset, tslen,
859 	    delta_type, delta_size, delta_data_offset, delta_buf, delta_len);
860 	if (err)
861 		return err;
862 
863 	err = search_packidx(&packidx, &idx, repo, &id);
864 	if (err)
865 		return err;
866 
867 	base_offset = get_object_offset(packidx, idx);
868 	if (base_offset == (uint64_t)-1) {
869 		return got_error(GOT_ERR_BAD_PACKIDX);
870 	}
871 
872 	err = get_packfile_path(&path_base_packfile, repo, packidx);
873 	if (err)
874 		return err;
875 
876 	base_pack = get_cached_pack(path_base_packfile, repo);
877 	if (base_pack == NULL) {
878 		err = cache_pack(&base_pack, path_base_packfile, NULL, repo);
879 		if (err)
880 			goto done;
881 	}
882 
883 	if (base_offset >= base_pack->filesize) {
884 		err = got_error(GOT_ERR_PACK_OFFSET);
885 		goto done;
886 	}
887 	if (lseek(base_pack->fd, base_offset, SEEK_SET) == -1) {
888 		err = got_error_from_errno();
889 		goto done;
890 	}
891 
892 	err = parse_object_type_and_size(&base_type, &base_size, &base_tslen,
893 	    base_pack->fd);
894 	if (err)
895 		goto done;
896 
897 	err = resolve_delta_chain(deltas, repo, base_pack->fd,
898 	    base_pack->filesize, path_base_packfile, base_offset,
899 	    base_tslen, base_type, base_size, recursion - 1);
900 done:
901 	free(path_base_packfile);
902 	return err;
903 }
904 
905 static const struct got_error *
906 resolve_delta_chain(struct got_delta_chain *deltas, struct got_repository *repo,
907     int fd, size_t packfile_size, const char *path_packfile, off_t delta_offset,
908     size_t tslen, int delta_type, size_t delta_size, unsigned int recursion)
909 {
910 	const struct got_error *err = NULL;
911 
912 	if (--recursion == 0)
913 		return got_error(GOT_ERR_RECURSION);
914 
915 	switch (delta_type) {
916 	case GOT_OBJ_TYPE_COMMIT:
917 	case GOT_OBJ_TYPE_TREE:
918 	case GOT_OBJ_TYPE_BLOB:
919 	case GOT_OBJ_TYPE_TAG:
920 		/* Plain types are the final delta base. Recursion ends. */
921 		err = add_delta(deltas, path_packfile, delta_offset, tslen,
922 		    delta_type, delta_size, 0, NULL, 0);
923 		break;
924 	case GOT_OBJ_TYPE_OFFSET_DELTA:
925 		err = resolve_offset_delta(deltas, repo, fd, packfile_size,
926 		    path_packfile, delta_offset, tslen, delta_type, delta_size,
927 		    recursion - 1);
928 		break;
929 	case GOT_OBJ_TYPE_REF_DELTA:
930 		err = resolve_ref_delta(deltas, repo, fd, path_packfile,
931 		    delta_offset, tslen, delta_type, delta_size, recursion - 1);
932 		break;
933 	default:
934 		return got_error(GOT_ERR_OBJ_TYPE);
935 	}
936 
937 	return err;
938 }
939 
940 static const struct got_error *
941 open_delta_object(struct got_object **obj, struct got_repository *repo,
942     const char *path_packfile, int fd, size_t packfile_size,
943     struct got_object_id *id, off_t offset, size_t tslen,
944     int delta_type, size_t delta_size)
945 {
946 	const struct got_error *err = NULL;
947 	int resolved_type;
948 
949 	*obj = calloc(1, sizeof(**obj));
950 	if (*obj == NULL)
951 		return got_error_from_errno();
952 
953 	(*obj)->flags = 0;
954 	(*obj)->hdrlen = 0;
955 	(*obj)->size = 0; /* Not known because deltas aren't applied yet. */
956 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
957 	(*obj)->pack_offset = offset + tslen;
958 
959 	(*obj)->path_packfile = strdup(path_packfile);
960 	if ((*obj)->path_packfile == NULL) {
961 		err = got_error_from_errno();
962 		goto done;
963 	}
964 	(*obj)->flags |= GOT_OBJ_FLAG_PACKED;
965 
966 	SIMPLEQ_INIT(&(*obj)->deltas.entries);
967 	(*obj)->flags |= GOT_OBJ_FLAG_DELTIFIED;
968 
969 	err = resolve_delta_chain(&(*obj)->deltas, repo, fd, packfile_size,
970 	    path_packfile, offset, tslen, delta_type, delta_size,
971 	    GOT_DELTA_CHAIN_RECURSION_MAX);
972 	if (err)
973 		goto done;
974 
975 	err = got_delta_chain_get_base_type(&resolved_type, &(*obj)->deltas);
976 	if (err)
977 		goto done;
978 	(*obj)->type = resolved_type;
979 
980 done:
981 	if (err) {
982 		got_object_close(*obj);
983 		*obj = NULL;
984 	}
985 	return err;
986 }
987 
988 static const struct got_error *
989 open_packed_object(struct got_object **obj, struct got_repository *repo,
990     struct got_packidx *packidx, int idx, struct got_object_id *id)
991 {
992 	const struct got_error *err = NULL;
993 	off_t offset;
994 	char *path_packfile;
995 	struct got_pack *pack;
996 	uint8_t type;
997 	uint64_t size;
998 	size_t tslen;
999 
1000 	*obj = NULL;
1001 
1002 	offset = get_object_offset(packidx, idx);
1003 	if (offset == (uint64_t)-1)
1004 		return got_error(GOT_ERR_BAD_PACKIDX);
1005 
1006 	err = get_packfile_path(&path_packfile, repo, packidx);
1007 	if (err)
1008 		return err;
1009 
1010 	pack = get_cached_pack(path_packfile, repo);
1011 	if (pack == NULL) {
1012 		err = cache_pack(&pack, path_packfile, packidx, repo);
1013 		if (err)
1014 			goto done;
1015 	}
1016 
1017 	if (offset >= pack->filesize) {
1018 		err = got_error(GOT_ERR_PACK_OFFSET);
1019 		goto done;
1020 	}
1021 	if (lseek(pack->fd, offset, SEEK_SET) == -1) {
1022 		err = got_error_from_errno();
1023 		goto done;
1024 	}
1025 
1026 	err = parse_object_type_and_size(&type, &size, &tslen, pack->fd);
1027 	if (err)
1028 		goto done;
1029 
1030 	switch (type) {
1031 	case GOT_OBJ_TYPE_COMMIT:
1032 	case GOT_OBJ_TYPE_TREE:
1033 	case GOT_OBJ_TYPE_BLOB:
1034 	case GOT_OBJ_TYPE_TAG:
1035 		err = open_plain_object(obj, path_packfile, id, type,
1036 		    offset + tslen, size);
1037 		break;
1038 
1039 	case GOT_OBJ_TYPE_OFFSET_DELTA:
1040 	case GOT_OBJ_TYPE_REF_DELTA:
1041 		err = open_delta_object(obj, repo, path_packfile, pack->fd,
1042 		    pack->filesize, id, offset, tslen, type, size);
1043 		break;
1044 
1045 	default:
1046 		err = got_error(GOT_ERR_OBJ_TYPE);
1047 		goto done;
1048 	}
1049 done:
1050 	free(path_packfile);
1051 	return err;
1052 }
1053 
1054 const struct got_error *
1055 got_packfile_open_object(struct got_object **obj, struct got_object_id *id,
1056     struct got_repository *repo)
1057 {
1058 	const struct got_error *err = NULL;
1059 	struct got_packidx *packidx = NULL;
1060 	int idx;
1061 
1062 	err = search_packidx(&packidx, &idx, repo, id);
1063 	if (err)
1064 		return err;
1065 
1066 	err = open_packed_object(obj, repo, packidx, idx, id);
1067 	if (err)
1068 		return err;
1069 
1070 	err = cache_pack(NULL, (*obj)->path_packfile, packidx, repo);
1071 	return err;
1072 }
1073 
1074 static const struct got_error *
1075 get_delta_chain_max_size(uint64_t *max_size, struct got_delta_chain *deltas)
1076 {
1077 	struct got_delta *delta;
1078 	uint64_t base_size = 0, result_size = 0;
1079 
1080 	*max_size = 0;
1081 	SIMPLEQ_FOREACH(delta, &deltas->entries, entry) {
1082 		/* Plain object types are the delta base. */
1083 		if (delta->type != GOT_OBJ_TYPE_COMMIT &&
1084 		    delta->type != GOT_OBJ_TYPE_TREE &&
1085 		    delta->type != GOT_OBJ_TYPE_BLOB &&
1086 		    delta->type != GOT_OBJ_TYPE_TAG) {
1087 			const struct got_error *err;
1088 			err = got_delta_get_sizes(&base_size, &result_size,
1089 			    delta->delta_buf, delta->delta_len);
1090 			if (err)
1091 				return err;
1092 		} else
1093 			base_size = delta->size;
1094 		if (base_size > *max_size)
1095 			*max_size = base_size;
1096 		if (result_size > *max_size)
1097 			*max_size = result_size;
1098 	}
1099 
1100 	return NULL;
1101 }
1102 
1103 static const struct got_error *
1104 dump_delta_chain_to_file(size_t *result_size, struct got_delta_chain *deltas,
1105     FILE *outfile, struct got_repository *repo)
1106 {
1107 	const struct got_error *err = NULL;
1108 	struct got_delta *delta;
1109 	FILE *base_file = NULL, *accum_file = NULL;
1110 	uint8_t *base_buf = NULL, *accum_buf = NULL;
1111 	size_t accum_size = 0;
1112 	uint64_t max_size;
1113 	int n = 0;
1114 
1115 	*result_size = 0;
1116 
1117 	if (SIMPLEQ_EMPTY(&deltas->entries))
1118 		return got_error(GOT_ERR_BAD_DELTA_CHAIN);
1119 
1120 	/* We process small enough files entirely in memory for speed. */
1121 	err = get_delta_chain_max_size(&max_size, deltas);
1122 	if (err)
1123 		return err;
1124 	if (max_size < GOT_DELTA_RESULT_SIZE_CACHED_MAX) {
1125 		accum_buf = malloc(max_size);
1126 		if (accum_buf == NULL)
1127 			return got_error_from_errno();
1128 	} else {
1129 		base_file = got_opentemp();
1130 		if (base_file == NULL)
1131 			return got_error_from_errno();
1132 
1133 		accum_file = got_opentemp();
1134 		if (accum_file == NULL) {
1135 			err = got_error_from_errno();
1136 			fclose(base_file);
1137 			return err;
1138 		}
1139 	}
1140 
1141 	/* Deltas are ordered in ascending order. */
1142 	SIMPLEQ_FOREACH(delta, &deltas->entries, entry) {
1143 		if (n == 0) {
1144 			struct got_pack *pack;
1145 			size_t base_len;
1146 			off_t delta_data_offset;
1147 
1148 			/* Plain object types are the delta base. */
1149 			if (delta->type != GOT_OBJ_TYPE_COMMIT &&
1150 			    delta->type != GOT_OBJ_TYPE_TREE &&
1151 			    delta->type != GOT_OBJ_TYPE_BLOB &&
1152 			    delta->type != GOT_OBJ_TYPE_TAG) {
1153 				err = got_error(GOT_ERR_BAD_DELTA_CHAIN);
1154 				goto done;
1155 			}
1156 
1157 			pack = get_cached_pack(delta->path_packfile, repo);
1158 			if (pack == NULL) {
1159 				err = got_error(GOT_ERR_BAD_DELTA_CHAIN);
1160 				goto done;
1161 			}
1162 
1163 			delta_data_offset = delta->offset + delta->tslen;
1164 			if (delta_data_offset >= pack->filesize) {
1165 				err = got_error(GOT_ERR_PACK_OFFSET);
1166 				goto done;
1167 			}
1168 			if (lseek(pack->fd, delta_data_offset, SEEK_SET) == -1) {
1169 				err = got_error_from_errno();
1170 				goto done;
1171 			}
1172 			if (base_file)
1173 				err = got_inflate_to_file_fd(&base_len,
1174 				    pack->fd, base_file);
1175 			else {
1176 				err = got_inflate_to_mem_fd(&base_buf, &base_len,
1177 				    pack->fd);
1178 				if (base_len < max_size) {
1179 					uint8_t *p;
1180 					p = reallocarray(base_buf, 1, max_size);
1181 					if (p == NULL) {
1182 						err = got_error_from_errno();
1183 						goto done;
1184 					}
1185 					base_buf = p;
1186 				}
1187 			}
1188 			if (err)
1189 				goto done;
1190 			n++;
1191 			if (base_file)
1192 				rewind(base_file);
1193 			continue;
1194 		}
1195 
1196 		if (base_buf) {
1197 			err = got_delta_apply_in_mem(base_buf, delta->delta_buf,
1198 			    delta->delta_len, accum_buf, &accum_size);
1199 			n++;
1200 		} else {
1201 			err = got_delta_apply(base_file, delta->delta_buf,
1202 			    delta->delta_len,
1203 			    /* Final delta application writes to output file. */
1204 			    ++n < deltas->nentries ? accum_file : outfile,
1205 			    &accum_size);
1206 		}
1207 		if (err)
1208 			goto done;
1209 
1210 		if (n < deltas->nentries) {
1211 			/* Accumulated delta becomes the new base. */
1212 			if (base_buf) {
1213 				uint8_t *tmp = accum_buf;
1214 				accum_buf = base_buf;
1215 				base_buf = tmp;
1216 			} else {
1217 				FILE *tmp = accum_file;
1218 				accum_file = base_file;
1219 				base_file = tmp;
1220 				rewind(base_file);
1221 				rewind(accum_file);
1222 			}
1223 		}
1224 	}
1225 
1226 done:
1227 	free(base_buf);
1228 	if (accum_buf) {
1229 		size_t len = fwrite(accum_buf, 1, accum_size, outfile);
1230 		free(accum_buf);
1231 		if (len != accum_size)
1232 			return got_ferror(outfile, GOT_ERR_IO);
1233 	}
1234 	if (base_file)
1235 		fclose(base_file);
1236 	if (accum_file)
1237 		fclose(accum_file);
1238 	rewind(outfile);
1239 	if (err == NULL)
1240 		*result_size = accum_size;
1241 	return err;
1242 }
1243 
1244 static const struct got_error *
1245 dump_delta_chain_to_mem(uint8_t **outbuf, size_t *outlen,
1246     struct got_delta_chain *deltas, struct got_repository *repo)
1247 {
1248 	const struct got_error *err = NULL;
1249 	struct got_delta *delta;
1250 	uint8_t *base_buf = NULL, *accum_buf = NULL;
1251 	size_t accum_size;
1252 	uint64_t max_size;
1253 	int n = 0;
1254 
1255 	*outbuf = NULL;
1256 	*outlen = 0;
1257 
1258 	if (SIMPLEQ_EMPTY(&deltas->entries))
1259 		return got_error(GOT_ERR_BAD_DELTA_CHAIN);
1260 
1261 	err = get_delta_chain_max_size(&max_size, deltas);
1262 	if (err)
1263 		return err;
1264 	accum_buf = malloc(max_size);
1265 	if (accum_buf == NULL)
1266 		return got_error_from_errno();
1267 
1268 	/* Deltas are ordered in ascending order. */
1269 	SIMPLEQ_FOREACH(delta, &deltas->entries, entry) {
1270 		if (n == 0) {
1271 			struct got_pack *pack;
1272 			size_t base_len;
1273 			size_t delta_data_offset;
1274 
1275 			/* Plain object types are the delta base. */
1276 			if (delta->type != GOT_OBJ_TYPE_COMMIT &&
1277 			    delta->type != GOT_OBJ_TYPE_TREE &&
1278 			    delta->type != GOT_OBJ_TYPE_BLOB &&
1279 			    delta->type != GOT_OBJ_TYPE_TAG) {
1280 				err = got_error(GOT_ERR_BAD_DELTA_CHAIN);
1281 				goto done;
1282 			}
1283 
1284 			pack = get_cached_pack(delta->path_packfile, repo);
1285 			if (pack == NULL) {
1286 				err = got_error(GOT_ERR_BAD_DELTA_CHAIN);
1287 				goto done;
1288 			}
1289 
1290 			delta_data_offset = delta->offset + delta->tslen;
1291 			if (delta_data_offset >= pack->filesize) {
1292 				err = got_error(GOT_ERR_PACK_OFFSET);
1293 				goto done;
1294 			}
1295 			if (lseek(pack->fd, delta_data_offset, SEEK_SET) == -1) {
1296 				err = got_error_from_errno();
1297 				goto done;
1298 			}
1299 			err = got_inflate_to_mem_fd(&base_buf, &base_len,
1300 			    pack->fd);
1301 			if (base_len < max_size) {
1302 				uint8_t *p;
1303 				p = reallocarray(base_buf, 1, max_size);
1304 				if (p == NULL) {
1305 					err = got_error_from_errno();
1306 					goto done;
1307 				}
1308 				base_buf = p;
1309 			}
1310 			if (err)
1311 				goto done;
1312 			n++;
1313 			continue;
1314 		}
1315 
1316 		err = got_delta_apply_in_mem(base_buf, delta->delta_buf,
1317 		    delta->delta_len, accum_buf, &accum_size);
1318 		n++;
1319 		if (err)
1320 			goto done;
1321 
1322 		if (n < deltas->nentries) {
1323 			/* Accumulated delta becomes the new base. */
1324 			uint8_t *tmp = accum_buf;
1325 			accum_buf = base_buf;
1326 			base_buf = tmp;
1327 		}
1328 	}
1329 
1330 done:
1331 	free(base_buf);
1332 	if (err) {
1333 		free(accum_buf);
1334 		*outbuf = NULL;
1335 		*outlen = 0;
1336 	} else {
1337 		*outbuf = accum_buf;
1338 		*outlen = accum_size;
1339 	}
1340 	return err;
1341 }
1342 
1343 const struct got_error *
1344 got_packfile_extract_object(FILE **f, struct got_object *obj,
1345     struct got_repository *repo)
1346 {
1347 	const struct got_error *err = NULL;
1348 
1349 	*f = NULL;
1350 
1351 	if ((obj->flags & GOT_OBJ_FLAG_PACKED) == 0)
1352 		return got_error(GOT_ERR_OBJ_NOT_PACKED);
1353 
1354 	*f = got_opentemp();
1355 	if (*f == NULL) {
1356 		err = got_error_from_errno();
1357 		goto done;
1358 	}
1359 
1360 	if ((obj->flags & GOT_OBJ_FLAG_DELTIFIED) == 0) {
1361 		struct got_pack *pack;
1362 
1363 		pack = get_cached_pack(obj->path_packfile, repo);
1364 		if (pack == NULL) {
1365 			err = cache_pack(&pack, obj->path_packfile, NULL, repo);
1366 			if (err)
1367 				goto done;
1368 		}
1369 
1370 		if (obj->pack_offset >= pack->filesize) {
1371 			err = got_error(GOT_ERR_PACK_OFFSET);
1372 			goto done;
1373 		}
1374 		if (lseek(pack->fd, obj->pack_offset, SEEK_SET) == -1) {
1375 			err = got_error_from_errno();
1376 			goto done;
1377 		}
1378 
1379 		err = got_inflate_to_file_fd(&obj->size, pack->fd, *f);
1380 	} else
1381 		err = dump_delta_chain_to_file(&obj->size,
1382 		    &obj->deltas, *f, repo);
1383 done:
1384 	if (err && *f) {
1385 		fclose(*f);
1386 		*f = NULL;
1387 	}
1388 	return err;
1389 }
1390 
1391 const struct got_error *
1392 got_packfile_extract_object_to_mem(uint8_t **buf, size_t *len,
1393     struct got_object *obj, struct got_repository *repo)
1394 {
1395 	const struct got_error *err = NULL;
1396 
1397 	if ((obj->flags & GOT_OBJ_FLAG_PACKED) == 0)
1398 		return got_error(GOT_ERR_OBJ_NOT_PACKED);
1399 
1400 	if ((obj->flags & GOT_OBJ_FLAG_DELTIFIED) == 0) {
1401 		struct got_pack *pack;
1402 
1403 		pack = get_cached_pack(obj->path_packfile, repo);
1404 		if (pack == NULL) {
1405 			err = cache_pack(&pack, obj->path_packfile, NULL, repo);
1406 			if (err)
1407 				goto done;
1408 		}
1409 
1410 		if (obj->pack_offset >= pack->filesize) {
1411 			err = got_error(GOT_ERR_PACK_OFFSET);
1412 			goto done;
1413 		}
1414 		if (lseek(pack->fd, obj->pack_offset, SEEK_SET) == -1) {
1415 			err = got_error_from_errno();
1416 			goto done;
1417 		}
1418 
1419 		err = got_inflate_to_mem_fd(buf, len, pack->fd);
1420 	} else
1421 		err = dump_delta_chain_to_mem(buf, len, &obj->deltas, repo);
1422 done:
1423 	return err;
1424 }