op public repos

Blob

Date:: Mon Feb 12 20:29:08 2018 UTC
Message:: move struct got_zstream_buf to private header zb.h
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/types.h>
18 #include <sys/stat.h>
19 #include <sys/queue.h>
20 
21 #include <dirent.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdint.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <limits.h>
28 #include <sha1.h>
29 #include <endian.h>
30 #include <zlib.h>
31 
32 #include "got_error.h"
33 #include "got_object.h"
34 #include "got_repository.h"
35 #include "got_sha1.h"
36 #include "pack.h"
37 #include "path.h"
38 #include "delta.h"
39 #include "zb.h"
40 #include "object.h"
41 
42 #define GOT_PACK_PREFIX		"pack-"
43 #define GOT_PACKFILE_SUFFIX	".pack"
44 #define GOT_PACKIDX_SUFFIX		".idx"
45 #define GOT_PACKFILE_NAMELEN	(strlen(GOT_PACK_PREFIX) + \
46 				SHA1_DIGEST_STRING_LENGTH - 1 + \
47 				strlen(GOT_PACKFILE_SUFFIX))
48 #define GOT_PACKIDX_NAMELEN	(strlen(GOT_PACK_PREFIX) + \
49 				SHA1_DIGEST_STRING_LENGTH - 1 + \
50 				strlen(GOT_PACKIDX_SUFFIX))
51 
52 #ifndef MIN
53 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
54 #endif
55 
56 static const struct got_error *
57 verify_fanout_table(uint32_t *fanout_table)
58 {
59 	int i;
60 
61 	for (i = 0; i < 0xff - 1; i++) {
62 		if (be32toh(fanout_table[i]) > be32toh(fanout_table[i + 1]))
63 			return got_error(GOT_ERR_BAD_PACKIDX);
64 	}
65 
66 	return NULL;
67 }
68 
69 static const struct got_error *
70 get_packfile_size(size_t *size, const char *path_idx)
71 {
72 	struct stat sb;
73 	char *path_pack;
74 	char base_path[PATH_MAX];
75 	char *dot;
76 
77 	if (strlcpy(base_path, path_idx, PATH_MAX) > PATH_MAX)
78 		return got_error(GOT_ERR_NO_SPACE);
79 
80 	dot = strrchr(base_path, '.');
81 	if (dot == NULL)
82 		return got_error(GOT_ERR_BAD_PATH);
83 	*dot = '\0';
84 	if (asprintf(&path_pack, "%s.pack", base_path) == -1)
85 		return got_error(GOT_ERR_NO_MEM);
86 
87 	if (stat(path_pack, &sb) != 0) {
88 		free(path_pack);
89 		return got_error_from_errno();
90 	}
91 
92 	free(path_pack);
93 	*size = sb.st_size;
94 	return 0;
95 }
96 
97 const struct got_error *
98 got_packidx_open(struct got_packidx_v2_hdr **packidx, const char *path)
99 {
100 	struct got_packidx_v2_hdr *p;
101 	FILE *f;
102 	const struct got_error *err = NULL;
103 	size_t n, nobj, packfile_size;
104 	SHA1_CTX ctx;
105 	uint8_t sha1[SHA1_DIGEST_LENGTH];
106 
107 	SHA1Init(&ctx);
108 
109 	f = fopen(path, "rb");
110 	if (f == NULL)
111 		return got_error(GOT_ERR_BAD_PATH);
112 
113 	err = get_packfile_size(&packfile_size, path);
114 	if (err)
115 		return err;
116 
117 	p = calloc(1, sizeof(*p));
118 	if (p == NULL) {
119 		err = got_error(GOT_ERR_NO_MEM);
120 		goto done;
121 	}
122 
123 	n = fread(&p->magic, sizeof(p->magic), 1, f);
124 	if (n != 1) {
125 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
126 		goto done;
127 	}
128 
129 	if (betoh32(p->magic) != GOT_PACKIDX_V2_MAGIC) {
130 		err = got_error(GOT_ERR_BAD_PACKIDX);
131 		goto done;
132 	}
133 
134 	SHA1Update(&ctx, (uint8_t *)&p->magic, sizeof(p->magic));
135 
136 	n = fread(&p->version, sizeof(p->version), 1, f);
137 	if (n != 1) {
138 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
139 		goto done;
140 	}
141 
142 	if (betoh32(p->version) != GOT_PACKIDX_VERSION) {
143 		err = got_error(GOT_ERR_BAD_PACKIDX);
144 		goto done;
145 	}
146 
147 	SHA1Update(&ctx, (uint8_t *)&p->version, sizeof(p->version));
148 
149 	n = fread(&p->fanout_table, sizeof(p->fanout_table), 1, f);
150 	if (n != 1) {
151 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
152 		goto done;
153 	}
154 
155 	err = verify_fanout_table(p->fanout_table);
156 	if (err)
157 		goto done;
158 
159 	SHA1Update(&ctx, (uint8_t *)p->fanout_table, sizeof(p->fanout_table));
160 
161 	nobj = betoh32(p->fanout_table[0xff]);
162 
163 	p->sorted_ids = calloc(nobj, sizeof(*p->sorted_ids));
164 	if (p->sorted_ids == NULL) {
165 		err = got_error(GOT_ERR_NO_MEM);
166 		goto done;
167 	}
168 
169 	n = fread(p->sorted_ids, sizeof(*p->sorted_ids), nobj, f);
170 	if (n != nobj) {
171 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
172 		goto done;
173 	}
174 
175 	SHA1Update(&ctx, (uint8_t *)p->sorted_ids,
176 	    nobj * sizeof(*p->sorted_ids));
177 
178 	p->crc32 = calloc(nobj, sizeof(*p->crc32));
179 	if (p->crc32 == NULL) {
180 		err = got_error(GOT_ERR_NO_MEM);
181 		goto done;
182 	}
183 
184 	n = fread(p->crc32, sizeof(*p->crc32), nobj, f);
185 	if (n != nobj) {
186 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
187 		goto done;
188 	}
189 
190 	SHA1Update(&ctx, (uint8_t *)p->crc32, nobj * sizeof(*p->crc32));
191 
192 	p->offsets = calloc(nobj, sizeof(*p->offsets));
193 	if (p->offsets == NULL) {
194 		err = got_error(GOT_ERR_NO_MEM);
195 		goto done;
196 	}
197 
198 	n = fread(p->offsets, sizeof(*p->offsets), nobj, f);
199 	if (n != nobj) {
200 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
201 		goto done;
202 	}
203 
204 	SHA1Update(&ctx, (uint8_t *)p->offsets, nobj * sizeof(*p->offsets));
205 
206 	/* Large file offsets are contained only in files > 2GB. */
207 	if (packfile_size <= 0x80000000)
208 		goto checksum;
209 
210 	p->large_offsets = calloc(nobj, sizeof(*p->large_offsets));
211 	if (p->large_offsets == NULL) {
212 		err = got_error(GOT_ERR_NO_MEM);
213 		goto done;
214 	}
215 
216 	n = fread(p->large_offsets, sizeof(*p->large_offsets), nobj, f);
217 	if (n != nobj) {
218 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
219 		goto done;
220 	}
221 
222 	SHA1Update(&ctx, (uint8_t*)p->large_offsets,
223 	    nobj * sizeof(*p->large_offsets));
224 
225 checksum:
226 	n = fread(&p->trailer, sizeof(p->trailer), 1, f);
227 	if (n != 1) {
228 		err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
229 		goto done;
230 	}
231 
232 	SHA1Update(&ctx, p->trailer.packfile_sha1, SHA1_DIGEST_LENGTH);
233 	SHA1Final(sha1, &ctx);
234 	if (memcmp(p->trailer.packidx_sha1, sha1, SHA1_DIGEST_LENGTH) != 0)
235 		err = got_error(GOT_ERR_PACKIDX_CSUM);
236 done:
237 	fclose(f);
238 	if (err)
239 		got_packidx_close(p);
240 	else
241 		*packidx = p;
242 	return err;
243 }
244 
245 void
246 got_packidx_close(struct got_packidx_v2_hdr *packidx)
247 {
248 	free(packidx->sorted_ids);
249 	free(packidx->offsets);
250 	free(packidx->crc32);
251 	free(packidx->large_offsets);
252 	free(packidx);
253 }
254 
255 static int
256 is_packidx_filename(const char *name, size_t len)
257 {
258 	if (len != GOT_PACKIDX_NAMELEN)
259 		return 0;
260 
261 	if (strncmp(name, GOT_PACK_PREFIX, strlen(GOT_PACK_PREFIX)) != 0)
262 		return 0;
263 
264 	if (strcmp(name + strlen(GOT_PACK_PREFIX) +
265 	    SHA1_DIGEST_STRING_LENGTH - 1, GOT_PACKIDX_SUFFIX) != 0)
266 		return 0;
267 
268 	return 1;
269 }
270 
271 static off_t
272 get_object_offset(struct got_packidx_v2_hdr *packidx, int idx)
273 {
274 	uint32_t totobj = betoh32(packidx->fanout_table[0xff]);
275 	uint32_t offset = betoh32(packidx->offsets[idx]);
276 	if (offset & GOT_PACKIDX_OFFSET_VAL_IS_LARGE_IDX) {
277 		uint64_t loffset;
278 		idx = offset & GOT_PACKIDX_OFFSET_VAL_MASK;
279 		if (idx < 0 || idx > totobj || packidx->large_offsets == NULL)
280 			return -1;
281 		loffset = betoh64(packidx->large_offsets[idx]);
282 		return (loffset > INT64_MAX ? -1 : (off_t)loffset);
283 	}
284 	return (off_t)(offset & GOT_PACKIDX_OFFSET_VAL_MASK);
285 }
286 
287 static int
288 get_object_idx(struct got_packidx_v2_hdr *packidx, struct got_object_id *id)
289 {
290 	u_int8_t id0 = id->sha1[0];
291 	uint32_t totobj = betoh32(packidx->fanout_table[0xff]);
292 	int i = 0;
293 
294 	if (id0 > 0)
295 		i = betoh32(packidx->fanout_table[id0 - 1]);
296 
297 	while (i < totobj) {
298 		struct got_object_id *oid = &packidx->sorted_ids[i];
299 		uint32_t offset;
300 		int cmp = got_object_id_cmp(id, oid);
301 
302 		if (cmp == 0)
303 			return i;
304 		i++;
305 	}
306 
307 	return -1;
308 }
309 
310 static const struct got_error *
311 search_packidx(struct got_packidx_v2_hdr **packidx, int *idx,
312     struct got_repository *repo, struct got_object_id *id)
313 {
314 	const struct got_error *err;
315 	char *path_packdir;
316 	DIR *packdir;
317 	struct dirent *dent;
318 	char *path_packidx;
319 
320 	path_packdir = got_repo_get_path_objects_pack(repo);
321 	if (path_packdir == NULL)
322 		return got_error(GOT_ERR_NO_MEM);
323 
324 	packdir = opendir(path_packdir);
325 	if (packdir == NULL) {
326 		err = got_error_from_errno();
327 		goto done;
328 	}
329 
330 	while ((dent = readdir(packdir)) != NULL) {
331 		if (!is_packidx_filename(dent->d_name, dent->d_namlen))
332 			continue;
333 
334 		if (asprintf(&path_packidx, "%s/%s", path_packdir,
335 		    dent->d_name) == -1) {
336 			err = got_error(GOT_ERR_NO_MEM);
337 			goto done;
338 		}
339 
340 		err = got_packidx_open(packidx, path_packidx);
341 		free(path_packidx);
342 		if (err)
343 			goto done;
344 
345 		*idx = get_object_idx(*packidx, id);
346 		if (*idx != -1) {
347 			err = NULL; /* found the object */
348 			goto done;
349 		}
350 
351 		got_packidx_close(*packidx);
352 		*packidx = NULL;
353 	}
354 
355 	err = got_error(GOT_ERR_NO_OBJ);
356 done:
357 	free(path_packdir);
358 	if (packdir && closedir(packdir) != 0 && err == 0)
359 		err = got_error_from_errno();
360 	return err;
361 }
362 
363 static const struct got_error *
364 get_packfile_path(char **path_packfile, struct got_repository *repo,
365     struct got_packidx_v2_hdr *packidx)
366 {
367 	char *path_packdir;
368 	char hex[SHA1_DIGEST_STRING_LENGTH];
369 	char *sha1str;
370 	char *path_packidx;
371 
372 	*path_packfile = NULL;
373 
374 	path_packdir = got_repo_get_path_objects_pack(repo);
375 	if (path_packdir == NULL)
376 		return got_error(GOT_ERR_NO_MEM);
377 
378 	sha1str = got_sha1_digest_to_str(packidx->trailer.packfile_sha1,
379 	    hex, sizeof(hex));
380 	if (sha1str == NULL)
381 		return got_error(GOT_ERR_PACKIDX_CSUM);
382 
383 	if (asprintf(path_packfile, "%s/%s%s%s", path_packdir,
384 	    GOT_PACK_PREFIX, sha1str, GOT_PACKFILE_SUFFIX) == -1) {
385 		*path_packfile = NULL;
386 		return got_error(GOT_ERR_NO_MEM);
387 	}
388 
389 	return NULL;
390 }
391 
392 const struct got_error *
393 read_packfile_hdr(FILE *f, struct got_packidx_v2_hdr *packidx)
394 {
395 	const struct got_error *err = NULL;
396 	uint32_t totobj = betoh32(packidx->fanout_table[0xff]);
397 	struct got_packfile_hdr hdr;
398 	size_t n;
399 
400 	n = fread(&hdr, sizeof(hdr), 1, f);
401 	if (n != 1)
402 		return got_ferror(f, GOT_ERR_BAD_PACKIDX);
403 
404 	if (betoh32(hdr.signature) != GOT_PACKFILE_SIGNATURE ||
405 	    betoh32(hdr.version) != GOT_PACKFILE_VERSION ||
406 	    betoh32(hdr.nobjects) != totobj)
407 		err = got_error(GOT_ERR_BAD_PACKFILE);
408 
409 	return err;
410 }
411 
412 static const struct got_error *
413 open_packfile(FILE **packfile, char **path_packfile,
414     struct got_repository *repo, struct got_packidx_v2_hdr *packidx)
415 {
416 	const struct got_error *err;
417 
418 	*packfile = NULL;
419 
420 	err = get_packfile_path(path_packfile, repo, packidx);
421 	if (err)
422 		return err;
423 
424 	*packfile = fopen(*path_packfile, "rb");
425 	if (*packfile == NULL) {
426 		err = got_error_from_errno();
427 		free(*path_packfile);
428 		return err;
429 	}
430 
431 	err = read_packfile_hdr(*packfile, packidx);
432 	if (err) {
433 		fclose(*packfile);
434 		*packfile = NULL;
435 	}
436 	return err;
437 }
438 
439 static const struct got_error *
440 parse_object_type_and_size(uint8_t *type, uint64_t *size, size_t *len,
441     FILE *packfile)
442 {
443 	uint8_t t = 0;
444 	uint64_t s = 0;
445 	uint8_t sizeN;
446 	size_t n;
447 	int i = 0;
448 
449 	do {
450 		/* We do not support size values which don't fit in 64 bit. */
451 		if (i > 9)
452 			return got_error(GOT_ERR_NO_SPACE);
453 
454 		n = fread(&sizeN, sizeof(sizeN), 1, packfile);
455 		if (n != 1)
456 			return got_ferror(packfile, GOT_ERR_BAD_PACKIDX);
457 
458 		if (i == 0) {
459 			t = (sizeN & GOT_PACK_OBJ_SIZE0_TYPE_MASK) >>
460 			    GOT_PACK_OBJ_SIZE0_TYPE_MASK_SHIFT;
461 			s = (sizeN & GOT_PACK_OBJ_SIZE0_VAL_MASK);
462 		} else {
463 			size_t shift = 4 + 7 * (i - 1);
464 			s |= ((sizeN & GOT_PACK_OBJ_SIZE_VAL_MASK) << shift);
465 		}
466 		i++;
467 	} while (sizeN & GOT_PACK_OBJ_SIZE_MORE);
468 
469 	*type = t;
470 	*size = s;
471 	*len = i * sizeof(sizeN);
472 	return NULL;
473 }
474 
475 static const struct got_error *
476 open_plain_object(struct got_object **obj, const char *path_packfile,
477     struct got_object_id *id, uint8_t type, off_t offset, size_t size)
478 {
479 	*obj = calloc(1, sizeof(**obj));
480 	if (*obj == NULL)
481 		return got_error(GOT_ERR_NO_MEM);
482 
483 	(*obj)->path_packfile = strdup(path_packfile);
484 	if ((*obj)->path_packfile == NULL) {
485 		free(*obj);
486 		*obj = NULL;
487 		return got_error(GOT_ERR_NO_MEM);
488 	}
489 
490 	(*obj)->type = type;
491 	(*obj)->flags = GOT_OBJ_FLAG_PACKED;
492 	(*obj)->hdrlen = 0;
493 	(*obj)->size = size;
494 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
495 	(*obj)->pack_offset = offset;
496 
497 	return NULL;
498 }
499 
500 static const struct got_error *
501 parse_negative_offset(int64_t *offset, size_t *len, FILE *packfile)
502 {
503 	int64_t o = 0;
504 	uint8_t offN;
505 	size_t n;
506 	int i = 0;
507 
508 	do {
509 		/* We do not support offset values which don't fit in 64 bit. */
510 		if (i > 8)
511 			return got_error(GOT_ERR_NO_SPACE);
512 
513 		n = fread(&offN, sizeof(offN), 1, packfile);
514 		if (n != 1)
515 			return got_ferror(packfile, GOT_ERR_BAD_PACKIDX);
516 
517 		if (i == 0)
518 			o = (offN & GOT_PACK_OBJ_DELTA_OFF_VAL_MASK);
519 		else {
520 			o++;
521 			o <<= 7;
522 			o += (offN & GOT_PACK_OBJ_DELTA_OFF_VAL_MASK);
523 		}
524 		i++;
525 	} while (offN & GOT_PACK_OBJ_DELTA_OFF_MORE);
526 
527 	*offset = o;
528 	*len = i * sizeof(offN);
529 	return NULL;
530 }
531 
532 static const struct got_error *
533 parse_offset_delta(off_t *base_offset, FILE *packfile, off_t offset)
534 {
535 	const struct got_error *err;
536 	int64_t negoffset;
537 	size_t negofflen;
538 
539 	err = parse_negative_offset(&negoffset, &negofflen, packfile);
540 	if (err)
541 		return err;
542 
543 	/* Compute the base object's offset (must be in the same pack file). */
544 	*base_offset = (offset - negoffset);
545 	if (*base_offset <= 0)
546 		return got_error(GOT_ERR_BAD_PACKFILE);
547 
548 	return NULL;
549 }
550 
551 static const struct got_error *
552 resolve_delta_chain(struct got_delta_chain *, struct got_repository *,
553     FILE *, const char *, off_t, size_t, int, size_t);
554 
555 static const struct got_error *
556 add_delta(struct got_delta_chain *deltas, const char *path_packfile,
557     off_t delta_offset, size_t tslen, int delta_type, size_t delta_size,
558     size_t delta_data_offset)
559 {
560 	struct got_delta *delta;
561 
562 	delta = got_delta_open(path_packfile, delta_offset, tslen,
563 	    delta_type, delta_size, delta_data_offset);
564 	if (delta == NULL)
565 		return got_error(GOT_ERR_NO_MEM);
566 	/* delta is freed in got_object_close() */
567 	deltas->nentries++;
568 	SIMPLEQ_INSERT_HEAD(&deltas->entries, delta, entry);
569 	return NULL;
570 }
571 
572 static const struct got_error *
573 resolve_offset_delta(struct got_delta_chain *deltas,
574     struct got_repository *repo, FILE *packfile, const char *path_packfile,
575     off_t delta_offset,size_t tslen, int delta_type, size_t delta_size)
576 
577 {
578 	const struct got_error *err;
579 	off_t base_offset;
580 	uint8_t base_type;
581 	uint64_t base_size;
582 	size_t base_tslen;
583 	off_t delta_data_offset;
584 
585 	err = parse_offset_delta(&base_offset, packfile, delta_offset);
586 	if (err)
587 		return err;
588 
589 	delta_data_offset = ftello(packfile);
590 	if (delta_data_offset == -1)
591 		return got_error_from_errno();
592 
593 	err = add_delta(deltas, path_packfile, delta_offset, tslen,
594 	    delta_type, delta_size, delta_data_offset);
595 	if (err)
596 		return err;
597 
598 	/* An offset delta must be in the same packfile. */
599 	if (fseeko(packfile, base_offset, SEEK_SET) != 0)
600 		return got_error_from_errno();
601 
602 	err = parse_object_type_and_size(&base_type, &base_size, &base_tslen,
603 	    packfile);
604 	if (err)
605 		return err;
606 
607 	return resolve_delta_chain(deltas, repo, packfile, path_packfile,
608 	    base_offset, base_tslen, base_type, base_size);
609 }
610 
611 static const struct got_error *
612 resolve_ref_delta(struct got_delta_chain *deltas, struct got_repository *repo,
613     FILE *packfile, const char *path_packfile, off_t delta_offset,
614     size_t tslen, int delta_type, size_t delta_size)
615 {
616 	const struct got_error *err;
617 	struct got_object_id id;
618 	struct got_packidx_v2_hdr *packidx;
619 	int idx;
620 	off_t base_offset;
621 	uint8_t base_type;
622 	uint64_t base_size;
623 	size_t base_tslen;
624 	size_t n;
625 	FILE *base_packfile;
626 	char *path_base_packfile;
627 	off_t delta_data_offset;
628 
629 	n = fread(&id, sizeof(id), 1, packfile);
630 	if (n != 1)
631 		return got_ferror(packfile, GOT_ERR_IO);
632 
633 	delta_data_offset = ftello(packfile);
634 	if (delta_data_offset == -1)
635 		return got_error_from_errno();
636 
637 	err = add_delta(deltas, path_packfile, delta_offset, tslen,
638 	    delta_type, delta_size, delta_data_offset);
639 	if (err)
640 		return err;
641 
642 	err = search_packidx(&packidx, &idx, repo, &id);
643 	if (err)
644 		return err;
645 
646 	base_offset = get_object_offset(packidx, idx);
647 	if (base_offset == (uint64_t)-1) {
648 		got_packidx_close(packidx);
649 		return got_error(GOT_ERR_BAD_PACKIDX);
650 	}
651 
652 	err = open_packfile(&base_packfile, &path_base_packfile, repo, packidx);
653 	got_packidx_close(packidx);
654 	if (err)
655 		return err;
656 
657 	if (fseeko(base_packfile, base_offset, SEEK_SET) != 0) {
658 		err = got_error_from_errno();
659 		goto done;
660 	}
661 
662 	err = parse_object_type_and_size(&base_type, &base_size, &base_tslen,
663 	    base_packfile);
664 	if (err)
665 		goto done;
666 
667 	err = resolve_delta_chain(deltas, repo, base_packfile,
668 	    path_base_packfile, base_offset, base_tslen, base_type,
669 	    base_size);
670 done:
671 	free(path_base_packfile);
672 	if (base_packfile && fclose(base_packfile) == -1 && err == 0)
673 		err = got_error_from_errno();
674 	return err;
675 }
676 
677 static const struct got_error *
678 resolve_delta_chain(struct got_delta_chain *deltas, struct got_repository *repo,
679     FILE *packfile, const char *path_packfile, off_t delta_offset, size_t tslen,
680     int delta_type, size_t delta_size)
681 {
682 	const struct got_error *err = NULL;
683 
684 	switch (delta_type) {
685 	case GOT_OBJ_TYPE_COMMIT:
686 	case GOT_OBJ_TYPE_TREE:
687 	case GOT_OBJ_TYPE_BLOB:
688 	case GOT_OBJ_TYPE_TAG:
689 		/* Plain types are the final delta base. Recursion ends. */
690 		err = add_delta(deltas, path_packfile, delta_offset, tslen,
691 		    delta_type, delta_size, 0);
692 		break;
693 	case GOT_OBJ_TYPE_OFFSET_DELTA:
694 		err = resolve_offset_delta(deltas, repo, packfile,
695 		    path_packfile, delta_offset, tslen, delta_type,
696 		    delta_size);
697 		break;
698 	case GOT_OBJ_TYPE_REF_DELTA:
699 		err = resolve_ref_delta(deltas, repo, packfile,
700 		    path_packfile, delta_offset, tslen, delta_type,
701 		    delta_size);
702 		break;
703 	default:
704 		return got_error(GOT_ERR_NOT_IMPL);
705 	}
706 
707 	return err;
708 }
709 
710 static const struct got_error *
711 open_delta_object(struct got_object **obj, struct got_repository *repo,
712     struct got_packidx_v2_hdr *packidx, const char *path_packfile,
713     FILE *packfile, struct got_object_id *id, off_t offset, size_t tslen,
714     int delta_type, size_t delta_size)
715 {
716 	const struct got_error *err = NULL;
717 	struct got_object_id base_id;
718 	uint8_t base_type;
719 	int resolved_type;
720 	uint64_t base_size;
721 	size_t base_tslen;
722 
723 	*obj = calloc(1, sizeof(**obj));
724 	if (*obj == NULL)
725 		return got_error(GOT_ERR_NO_MEM);
726 
727 	(*obj)->flags = 0;
728 	(*obj)->hdrlen = 0;
729 	(*obj)->size = 0; /* Not yet known because deltas aren't combined. */
730 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
731 	(*obj)->pack_offset = offset + tslen;
732 
733 	(*obj)->path_packfile = strdup(path_packfile);
734 	if ((*obj)->path_packfile == NULL) {
735 		err = got_error(GOT_ERR_NO_MEM);
736 		goto done;
737 	}
738 	(*obj)->flags |= GOT_OBJ_FLAG_PACKED;
739 
740 	SIMPLEQ_INIT(&(*obj)->deltas.entries);
741 	(*obj)->flags |= GOT_OBJ_FLAG_DELTIFIED;
742 
743 	err = resolve_delta_chain(&(*obj)->deltas, repo, packfile,
744 	    path_packfile, offset, tslen, delta_type, delta_size);
745 	if (err)
746 		goto done;
747 
748 	err = got_delta_chain_get_base_type(&resolved_type, &(*obj)->deltas);
749 	if (err)
750 		goto done;
751 	(*obj)->type = resolved_type;
752 
753 done:
754 	if (err) {
755 		got_object_close(*obj);
756 		*obj = NULL;
757 	}
758 	return err;
759 }
760 
761 static const struct got_error *
762 open_packed_object(struct got_object **obj, struct got_repository *repo,
763     struct got_packidx_v2_hdr *packidx, int idx, struct got_object_id *id)
764 {
765 	const struct got_error *err = NULL;
766 	off_t offset;
767 	char *path_packfile;
768 	FILE *packfile;
769 	uint8_t type;
770 	uint64_t size;
771 	size_t tslen;
772 
773 	*obj = NULL;
774 
775 	offset = get_object_offset(packidx, idx);
776 	if (offset == (uint64_t)-1)
777 		return got_error(GOT_ERR_BAD_PACKIDX);
778 
779 	err = open_packfile(&packfile, &path_packfile, repo, packidx);
780 	if (err)
781 		return err;
782 
783 	if (fseeko(packfile, offset, SEEK_SET) != 0) {
784 		err = got_error_from_errno();
785 		goto done;
786 	}
787 
788 	err = parse_object_type_and_size(&type, &size, &tslen, packfile);
789 	if (err)
790 		goto done;
791 
792 	switch (type) {
793 	case GOT_OBJ_TYPE_COMMIT:
794 	case GOT_OBJ_TYPE_TREE:
795 	case GOT_OBJ_TYPE_BLOB:
796 	case GOT_OBJ_TYPE_TAG:
797 		err = open_plain_object(obj, path_packfile, id, type,
798 		    offset + tslen, size);
799 		break;
800 
801 	case GOT_OBJ_TYPE_OFFSET_DELTA:
802 	case GOT_OBJ_TYPE_REF_DELTA:
803 		err = open_delta_object(obj, repo, packidx, path_packfile,
804 		    packfile, id, offset, tslen, type, size);
805 		break;
806 
807 	default:
808 		err = got_error(GOT_ERR_NOT_IMPL);
809 		goto done;
810 	}
811 done:
812 	free(path_packfile);
813 	if (packfile && fclose(packfile) == -1 && err == 0)
814 		err = got_error_from_errno();
815 	return err;
816 }
817 
818 const struct got_error *
819 got_packfile_open_object(struct got_object **obj, struct got_object_id *id,
820     struct got_repository *repo)
821 {
822 	const struct got_error *err = NULL;
823 	struct got_packidx_v2_hdr *packidx = NULL;
824 	int idx;
825 
826 	err = search_packidx(&packidx, &idx, repo, id);
827 	if (err)
828 		return err;
829 
830 	err = open_packed_object(obj, repo, packidx, idx, id);
831 	got_packidx_close(packidx);
832 	return err;
833 }
834 
835 static const struct got_error *
836 dump_delta_chain(struct got_delta_chain *deltas, FILE *outfile)
837 {
838 	const struct got_error *err = NULL;
839 	struct got_delta *delta;
840 	FILE *base_file, *accum_file;
841 	int n = 0;
842 
843 	if (SIMPLEQ_EMPTY(&deltas->entries))
844 		return got_error(GOT_ERR_BAD_DELTA_CHAIN);
845 
846 	base_file = got_opentemp();
847 	if (base_file == NULL)
848 		return got_error_from_errno();
849 
850 	accum_file = got_opentemp();
851 	if (accum_file == NULL) {
852 		err = got_error_from_errno();
853 		fclose(base_file);
854 		return err;
855 	}
856 
857 	/* Deltas are ordered in ascending order. */
858 	SIMPLEQ_FOREACH(delta, &deltas->entries, entry) {
859 		uint8_t *delta_buf = NULL;
860 		size_t delta_len = 0;
861 		FILE *delta_file;
862 
863 		delta_file = fopen(delta->path_packfile, "rb");
864 		if (delta_file == NULL) {
865 			err = got_error_from_errno();
866 			goto done;
867 		}
868 
869 
870 		if (n == 0) {
871 			/* Plain object types are the delta base. */
872 			if (delta->type != GOT_OBJ_TYPE_COMMIT &&
873 			    delta->type != GOT_OBJ_TYPE_TREE &&
874 			    delta->type != GOT_OBJ_TYPE_BLOB &&
875 			    delta->type != GOT_OBJ_TYPE_TAG) {
876 				err = got_error(GOT_ERR_BAD_DELTA_CHAIN);
877 				goto done;
878 			}
879 
880 			if (fseeko(delta_file, delta->offset + delta->tslen,
881 			    SEEK_SET) != 0) {
882 				fclose(delta_file);
883 				err = got_error_from_errno();
884 				goto done;
885 			}
886 			err = got_inflate_to_file(&delta_len, delta_file,
887 			    base_file);
888 			fclose(delta_file);
889 			if (err)
890 				goto done;
891 			n++;
892 			rewind(base_file);
893 			continue;
894 		}
895 
896 		if (fseeko(delta_file, delta->data_offset, SEEK_CUR) != 0) {
897 			fclose(delta_file);
898 			err = got_error_from_errno();
899 			goto done;
900 		}
901 
902 		/* Delta streams should always fit in memory. */
903 		err = got_inflate_to_mem(&delta_buf, &delta_len, delta_file);
904 		fclose(delta_file);
905 		if (err)
906 			goto done;
907 
908 		err = got_delta_apply(base_file, delta_buf, delta_len,
909 		    /* Final delta application writes to the output file. */
910 		    ++n < deltas->nentries ? accum_file : outfile);
911 		free(delta_buf);
912 		if (err)
913 			goto done;
914 
915 		if (n < deltas->nentries) {
916 			/* Accumulated delta becomes the new base. */
917 			FILE *tmp = accum_file;
918 			accum_file = base_file;
919 			base_file = tmp;
920 			rewind(base_file);
921 			rewind(accum_file);
922 		}
923 	}
924 
925 done:
926 	fclose(base_file);
927 	fclose(accum_file);
928 	rewind(outfile);
929 	return err;
930 }
931 
932 const struct got_error *
933 got_packfile_extract_object(FILE **f, struct got_object *obj,
934     struct got_repository *repo)
935 {
936 	const struct got_error *err = NULL;
937 	FILE *packfile = NULL;
938 
939 	if ((obj->flags & GOT_OBJ_FLAG_PACKED) == 0)
940 		return got_error(GOT_ERR_OBJ_NOT_PACKED);
941 
942 	*f = got_opentemp();
943 	if (*f == NULL) {
944 		err = got_error(GOT_ERR_FILE_OPEN);
945 		goto done;
946 	}
947 
948 	if ((obj->flags & GOT_OBJ_FLAG_DELTIFIED) == 0) {
949 		packfile = fopen(obj->path_packfile, "rb");
950 		if (packfile == NULL) {
951 			err = got_error_from_errno();
952 			goto done;
953 		}
954 
955 		if (fseeko(packfile, obj->pack_offset, SEEK_SET) != 0) {
956 			err = got_error_from_errno();
957 			goto done;
958 		}
959 
960 		err = got_inflate_to_file(&obj->size, packfile, *f);
961 	} else
962 		err = dump_delta_chain(&obj->deltas, *f);
963 done:
964 	if (packfile)
965 		fclose(packfile);
966 	if (err && *f)
967 		fclose(*f);
968 	return err;
969 }