2 * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <sys/types.h>
19 #include <sys/queue.h>
32 #include "got_error.h"
33 #include "got_object.h"
34 #include "got_repository.h"
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))
53 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
56 static const struct got_error *
57 verify_fanout_table(uint32_t *fanout_table)
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);
69 static const struct got_error *
70 get_packfile_size(size_t *size, const char *path_idx)
74 char base_path[PATH_MAX];
77 if (strlcpy(base_path, path_idx, PATH_MAX) > PATH_MAX)
78 return got_error(GOT_ERR_NO_SPACE);
80 dot = strrchr(base_path, '.');
82 return got_error(GOT_ERR_BAD_PATH);
84 if (asprintf(&path_pack, "%s.pack", base_path) == -1)
85 return got_error(GOT_ERR_NO_MEM);
87 if (stat(path_pack, &sb) != 0) {
89 return got_error_from_errno();
97 const struct got_error *
98 got_packidx_open(struct got_packidx_v2_hdr **packidx, const char *path)
100 struct got_packidx_v2_hdr *p;
102 const struct got_error *err = NULL;
103 size_t n, nobj, packfile_size;
105 uint8_t sha1[SHA1_DIGEST_LENGTH];
109 f = fopen(path, "rb");
111 return got_error(GOT_ERR_BAD_PATH);
113 err = get_packfile_size(&packfile_size, path);
117 p = calloc(1, sizeof(*p));
119 err = got_error(GOT_ERR_NO_MEM);
123 n = fread(&p->magic, sizeof(p->magic), 1, f);
125 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
129 if (betoh32(p->magic) != GOT_PACKIDX_V2_MAGIC) {
130 err = got_error(GOT_ERR_BAD_PACKIDX);
134 SHA1Update(&ctx, (uint8_t *)&p->magic, sizeof(p->magic));
136 n = fread(&p->version, sizeof(p->version), 1, f);
138 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
142 if (betoh32(p->version) != GOT_PACKIDX_VERSION) {
143 err = got_error(GOT_ERR_BAD_PACKIDX);
147 SHA1Update(&ctx, (uint8_t *)&p->version, sizeof(p->version));
149 n = fread(&p->fanout_table, sizeof(p->fanout_table), 1, f);
151 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
155 err = verify_fanout_table(p->fanout_table);
159 SHA1Update(&ctx, (uint8_t *)p->fanout_table, sizeof(p->fanout_table));
161 nobj = betoh32(p->fanout_table[0xff]);
163 p->sorted_ids = calloc(nobj, sizeof(*p->sorted_ids));
164 if (p->sorted_ids == NULL) {
165 err = got_error(GOT_ERR_NO_MEM);
169 n = fread(p->sorted_ids, sizeof(*p->sorted_ids), nobj, f);
171 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
175 SHA1Update(&ctx, (uint8_t *)p->sorted_ids,
176 nobj * sizeof(*p->sorted_ids));
178 p->crc32 = calloc(nobj, sizeof(*p->crc32));
179 if (p->crc32 == NULL) {
180 err = got_error(GOT_ERR_NO_MEM);
184 n = fread(p->crc32, sizeof(*p->crc32), nobj, f);
186 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
190 SHA1Update(&ctx, (uint8_t *)p->crc32, nobj * sizeof(*p->crc32));
192 p->offsets = calloc(nobj, sizeof(*p->offsets));
193 if (p->offsets == NULL) {
194 err = got_error(GOT_ERR_NO_MEM);
198 n = fread(p->offsets, sizeof(*p->offsets), nobj, f);
200 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
204 SHA1Update(&ctx, (uint8_t *)p->offsets, nobj * sizeof(*p->offsets));
206 /* Large file offsets are contained only in files > 2GB. */
207 if (packfile_size <= 0x80000000)
210 p->large_offsets = calloc(nobj, sizeof(*p->large_offsets));
211 if (p->large_offsets == NULL) {
212 err = got_error(GOT_ERR_NO_MEM);
216 n = fread(p->large_offsets, sizeof(*p->large_offsets), nobj, f);
218 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
222 SHA1Update(&ctx, (uint8_t*)p->large_offsets,
223 nobj * sizeof(*p->large_offsets));
226 n = fread(&p->trailer, sizeof(p->trailer), 1, f);
228 err = got_ferror(f, GOT_ERR_BAD_PACKIDX);
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);
239 got_packidx_close(p);
246 got_packidx_close(struct got_packidx_v2_hdr *packidx)
248 free(packidx->sorted_ids);
249 free(packidx->offsets);
250 free(packidx->crc32);
251 free(packidx->large_offsets);
256 is_packidx_filename(const char *name, size_t len)
258 if (len != GOT_PACKIDX_NAMELEN)
261 if (strncmp(name, GOT_PACK_PREFIX, strlen(GOT_PACK_PREFIX)) != 0)
264 if (strcmp(name + strlen(GOT_PACK_PREFIX) +
265 SHA1_DIGEST_STRING_LENGTH - 1, GOT_PACKIDX_SUFFIX) != 0)
272 get_object_offset(struct got_packidx_v2_hdr *packidx, int idx)
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) {
278 idx = offset & GOT_PACKIDX_OFFSET_VAL_MASK;
279 if (idx < 0 || idx > totobj || packidx->large_offsets == NULL)
281 loffset = betoh64(packidx->large_offsets[idx]);
282 return (loffset > INT64_MAX ? -1 : (off_t)loffset);
284 return (off_t)(offset & GOT_PACKIDX_OFFSET_VAL_MASK);
288 get_object_idx(struct got_packidx_v2_hdr *packidx, struct got_object_id *id)
290 u_int8_t id0 = id->sha1[0];
291 uint32_t totobj = betoh32(packidx->fanout_table[0xff]);
295 i = betoh32(packidx->fanout_table[id0 - 1]);
298 struct got_object_id *oid = &packidx->sorted_ids[i];
300 int cmp = got_object_id_cmp(id, oid);
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)
314 const struct got_error *err;
320 path_packdir = got_repo_get_path_objects_pack(repo);
321 if (path_packdir == NULL)
322 return got_error(GOT_ERR_NO_MEM);
324 packdir = opendir(path_packdir);
325 if (packdir == NULL) {
326 err = got_error_from_errno();
330 while ((dent = readdir(packdir)) != NULL) {
331 if (!is_packidx_filename(dent->d_name, dent->d_namlen))
334 if (asprintf(&path_packidx, "%s/%s", path_packdir,
335 dent->d_name) == -1) {
336 err = got_error(GOT_ERR_NO_MEM);
340 err = got_packidx_open(packidx, path_packidx);
345 *idx = get_object_idx(*packidx, id);
347 err = NULL; /* found the object */
351 got_packidx_close(*packidx);
355 err = got_error(GOT_ERR_NO_OBJ);
358 if (packdir && closedir(packdir) != 0 && err == 0)
359 err = got_error_from_errno();
363 static const struct got_error *
364 get_packfile_path(char **path_packfile, struct got_repository *repo,
365 struct got_packidx_v2_hdr *packidx)
368 char hex[SHA1_DIGEST_STRING_LENGTH];
372 *path_packfile = NULL;
374 path_packdir = got_repo_get_path_objects_pack(repo);
375 if (path_packdir == NULL)
376 return got_error(GOT_ERR_NO_MEM);
378 sha1str = got_sha1_digest_to_str(packidx->trailer.packfile_sha1,
381 return got_error(GOT_ERR_PACKIDX_CSUM);
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);
392 const struct got_error *
393 read_packfile_hdr(FILE *f, struct got_packidx_v2_hdr *packidx)
395 const struct got_error *err = NULL;
396 uint32_t totobj = betoh32(packidx->fanout_table[0xff]);
397 struct got_packfile_hdr hdr;
400 n = fread(&hdr, sizeof(hdr), 1, f);
402 return got_ferror(f, GOT_ERR_BAD_PACKIDX);
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);
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)
416 const struct got_error *err;
420 err = get_packfile_path(path_packfile, repo, packidx);
424 *packfile = fopen(*path_packfile, "rb");
425 if (*packfile == NULL) {
426 err = got_error_from_errno();
427 free(*path_packfile);
431 err = read_packfile_hdr(*packfile, packidx);
439 static const struct got_error *
440 parse_object_type_and_size(uint8_t *type, uint64_t *size, size_t *len,
450 /* We do not support size values which don't fit in 64 bit. */
452 return got_error(GOT_ERR_NO_SPACE);
454 n = fread(&sizeN, sizeof(sizeN), 1, packfile);
456 return got_ferror(packfile, GOT_ERR_BAD_PACKIDX);
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);
463 size_t shift = 4 + 7 * (i - 1);
464 s |= ((sizeN & GOT_PACK_OBJ_SIZE_VAL_MASK) << shift);
467 } while (sizeN & GOT_PACK_OBJ_SIZE_MORE);
471 *len = i * sizeof(sizeN);
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)
479 *obj = calloc(1, sizeof(**obj));
481 return got_error(GOT_ERR_NO_MEM);
483 (*obj)->path_packfile = strdup(path_packfile);
484 if ((*obj)->path_packfile == NULL) {
487 return got_error(GOT_ERR_NO_MEM);
491 (*obj)->flags = GOT_OBJ_FLAG_PACKED;
494 memcpy(&(*obj)->id, id, sizeof((*obj)->id));
495 (*obj)->pack_offset = offset;
500 static const struct got_error *
501 parse_negative_offset(int64_t *offset, size_t *len, FILE *packfile)
509 /* We do not support offset values which don't fit in 64 bit. */
511 return got_error(GOT_ERR_NO_SPACE);
513 n = fread(&offN, sizeof(offN), 1, packfile);
515 return got_ferror(packfile, GOT_ERR_BAD_PACKIDX);
518 o = (offN & GOT_PACK_OBJ_DELTA_OFF_VAL_MASK);
522 o += (offN & GOT_PACK_OBJ_DELTA_OFF_VAL_MASK);
525 } while (offN & GOT_PACK_OBJ_DELTA_OFF_MORE);
528 *len = i * sizeof(offN);
532 static const struct got_error *
533 parse_offset_delta(off_t *base_offset, FILE *packfile, off_t offset)
535 const struct got_error *err;
539 err = parse_negative_offset(&negoffset, &negofflen, packfile);
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);
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);
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)
560 struct got_delta *delta;
562 delta = got_delta_open(path_packfile, delta_offset, tslen,
563 delta_type, delta_size, delta_data_offset);
565 return got_error(GOT_ERR_NO_MEM);
566 /* delta is freed in got_object_close() */
568 SIMPLEQ_INSERT_HEAD(&deltas->entries, delta, entry);
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)
578 const struct got_error *err;
583 off_t delta_data_offset;
585 err = parse_offset_delta(&base_offset, packfile, delta_offset);
589 delta_data_offset = ftello(packfile);
590 if (delta_data_offset == -1)
591 return got_error_from_errno();
593 err = add_delta(deltas, path_packfile, delta_offset, tslen,
594 delta_type, delta_size, delta_data_offset);
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();
602 err = parse_object_type_and_size(&base_type, &base_size, &base_tslen,
607 return resolve_delta_chain(deltas, repo, packfile, path_packfile,
608 base_offset, base_tslen, base_type, base_size);
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)
616 const struct got_error *err;
617 struct got_object_id id;
618 struct got_packidx_v2_hdr *packidx;
626 char *path_base_packfile;
627 off_t delta_data_offset;
629 n = fread(&id, sizeof(id), 1, packfile);
631 return got_ferror(packfile, GOT_ERR_IO);
633 delta_data_offset = ftello(packfile);
634 if (delta_data_offset == -1)
635 return got_error_from_errno();
637 err = add_delta(deltas, path_packfile, delta_offset, tslen,
638 delta_type, delta_size, delta_data_offset);
642 err = search_packidx(&packidx, &idx, repo, &id);
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);
652 err = open_packfile(&base_packfile, &path_base_packfile, repo, packidx);
653 got_packidx_close(packidx);
657 if (fseeko(base_packfile, base_offset, SEEK_SET) != 0) {
658 err = got_error_from_errno();
662 err = parse_object_type_and_size(&base_type, &base_size, &base_tslen,
667 err = resolve_delta_chain(deltas, repo, base_packfile,
668 path_base_packfile, base_offset, base_tslen, base_type,
671 free(path_base_packfile);
672 if (base_packfile && fclose(base_packfile) == -1 && err == 0)
673 err = got_error_from_errno();
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)
682 const struct got_error *err = NULL;
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);
693 case GOT_OBJ_TYPE_OFFSET_DELTA:
694 err = resolve_offset_delta(deltas, repo, packfile,
695 path_packfile, delta_offset, tslen, delta_type,
698 case GOT_OBJ_TYPE_REF_DELTA:
699 err = resolve_ref_delta(deltas, repo, packfile,
700 path_packfile, delta_offset, tslen, delta_type,
704 return got_error(GOT_ERR_NOT_IMPL);
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)
716 const struct got_error *err = NULL;
717 struct got_object_id base_id;
723 *obj = calloc(1, sizeof(**obj));
725 return got_error(GOT_ERR_NO_MEM);
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;
733 (*obj)->path_packfile = strdup(path_packfile);
734 if ((*obj)->path_packfile == NULL) {
735 err = got_error(GOT_ERR_NO_MEM);
738 (*obj)->flags |= GOT_OBJ_FLAG_PACKED;
740 SIMPLEQ_INIT(&(*obj)->deltas.entries);
741 (*obj)->flags |= GOT_OBJ_FLAG_DELTIFIED;
743 err = resolve_delta_chain(&(*obj)->deltas, repo, packfile,
744 path_packfile, offset, tslen, delta_type, delta_size);
748 err = got_delta_chain_get_base_type(&resolved_type, &(*obj)->deltas);
751 (*obj)->type = resolved_type;
755 got_object_close(*obj);
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)
765 const struct got_error *err = NULL;
775 offset = get_object_offset(packidx, idx);
776 if (offset == (uint64_t)-1)
777 return got_error(GOT_ERR_BAD_PACKIDX);
779 err = open_packfile(&packfile, &path_packfile, repo, packidx);
783 if (fseeko(packfile, offset, SEEK_SET) != 0) {
784 err = got_error_from_errno();
788 err = parse_object_type_and_size(&type, &size, &tslen, packfile);
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);
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);
808 err = got_error(GOT_ERR_NOT_IMPL);
813 if (packfile && fclose(packfile) == -1 && err == 0)
814 err = got_error_from_errno();
818 const struct got_error *
819 got_packfile_open_object(struct got_object **obj, struct got_object_id *id,
820 struct got_repository *repo)
822 const struct got_error *err = NULL;
823 struct got_packidx_v2_hdr *packidx = NULL;
826 err = search_packidx(&packidx, &idx, repo, id);
830 err = open_packed_object(obj, repo, packidx, idx, id);
831 got_packidx_close(packidx);
835 static const struct got_error *
836 dump_delta_chain(struct got_delta_chain *deltas, FILE *outfile)
838 const struct got_error *err = NULL;
839 struct got_delta *delta;
840 FILE *base_file, *accum_file;
843 if (SIMPLEQ_EMPTY(&deltas->entries))
844 return got_error(GOT_ERR_BAD_DELTA_CHAIN);
846 base_file = got_opentemp();
847 if (base_file == NULL)
848 return got_error_from_errno();
850 accum_file = got_opentemp();
851 if (accum_file == NULL) {
852 err = got_error_from_errno();
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;
863 delta_file = fopen(delta->path_packfile, "rb");
864 if (delta_file == NULL) {
865 err = got_error_from_errno();
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);
880 if (fseeko(delta_file, delta->offset + delta->tslen,
883 err = got_error_from_errno();
886 err = got_inflate_to_file(&delta_len, delta_file,
896 if (fseeko(delta_file, delta->data_offset, SEEK_CUR) != 0) {
898 err = got_error_from_errno();
902 /* Delta streams should always fit in memory. */
903 err = got_inflate_to_mem(&delta_buf, &delta_len, delta_file);
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);
915 if (n < deltas->nentries) {
916 /* Accumulated delta becomes the new base. */
917 FILE *tmp = accum_file;
918 accum_file = base_file;
932 const struct got_error *
933 got_packfile_extract_object(FILE **f, struct got_object *obj,
934 struct got_repository *repo)
936 const struct got_error *err = NULL;
937 FILE *packfile = NULL;
939 if ((obj->flags & GOT_OBJ_FLAG_PACKED) == 0)
940 return got_error(GOT_ERR_OBJ_NOT_PACKED);
944 err = got_error(GOT_ERR_FILE_OPEN);
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();
955 if (fseeko(packfile, obj->pack_offset, SEEK_SET) != 0) {
956 err = got_error_from_errno();
960 err = got_inflate_to_file(&obj->size, packfile, *f);
962 err = dump_delta_chain(&obj->deltas, *f);