1 /*
2  * Copyright (c) 2018, 2019, 2020 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/stat.h>
18 #include <sys/types.h>
19 #include <sys/queue.h>
20 #include <sys/uio.h>
21 #include <sys/time.h>
22 #include <sys/mman.h>
23 
24 #include <limits.h>
25 #include <signal.h>
26 #include <stdint.h>
27 #include <imsg.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sha1.h>
32 #include <unistd.h>
33 #include <zlib.h>
34 
35 #include "got_error.h"
36 #include "got_object.h"
37 #include "got_path.h"
38 
39 #include "got_lib_delta.h"
40 #include "got_lib_delta_cache.h"
41 #include "got_lib_object.h"
42 #include "got_lib_object_cache.h"
43 #include "got_lib_object_parse.h"
44 #include "got_lib_object_idset.h"
45 #include "got_lib_privsep.h"
46 #include "got_lib_pack.h"
47 
48 static volatile sig_atomic_t sigint_received;
49 
50 static void
51 catch_sigint(int signo)
52 {
53 	sigint_received = 1;
54 }
55 
56 static const struct got_error *
57 open_object(struct got_object **obj, struct got_pack *pack,
58     struct got_packidx *packidx, int idx, struct got_object_id *id,
59     struct got_object_cache *objcache)
60 {
61 	const struct got_error *err;
62 
63 	err = got_packfile_open_object(obj, pack, packidx, idx, id);
64 	if (err)
65 		return err;
66 	(*obj)->refcnt++;
67 
68 	err = got_object_cache_add(objcache, id, *obj);
69 	if (err) {
70 		if (err->code == GOT_ERR_OBJ_EXISTS ||
71 		    err->code == GOT_ERR_OBJ_TOO_LARGE)
72 			err = NULL;
73 		return err;
74 	}
75 	(*obj)->refcnt++;
76 	return NULL;
77 }
78 
79 static const struct got_error *
80 object_request(struct imsg *imsg, struct imsgbuf *ibuf, struct got_pack *pack,
81     struct got_packidx *packidx, struct got_object_cache *objcache)
82 {
83 	const struct got_error *err = NULL;
84 	struct got_imsg_packed_object iobj;
85 	struct got_object *obj;
86 	struct got_object_id id;
87 	size_t datalen;
88 
89 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
90 	if (datalen != sizeof(iobj))
91 		return got_error(GOT_ERR_PRIVSEP_LEN);
92 	memcpy(&iobj, imsg->data, sizeof(iobj));
93 	memcpy(id.sha1, iobj.id, SHA1_DIGEST_LENGTH);
94 
95 	obj = got_object_cache_get(objcache, &id);
96 	if (obj) {
97 		obj->refcnt++;
98 	} else {
99 		err = open_object(&obj, pack, packidx, iobj.idx, &id,
100 		    objcache);
101 		if (err)
102 			goto done;
103 	}
104 
105 	err = got_privsep_send_obj(ibuf, obj);
106 done:
107 	got_object_close(obj);
108 	return err;
109 }
110 
111 static const struct got_error *
112 open_commit(struct got_commit_object **commit, struct got_pack *pack,
113     struct got_packidx *packidx, int obj_idx, struct got_object_id *id,
114     struct got_object_cache *objcache)
115 {
116 	const struct got_error *err = NULL;
117 	struct got_object *obj = NULL;
118 	uint8_t *buf = NULL;
119 	size_t len;
120 
121 	*commit = NULL;
122 
123 	obj = got_object_cache_get(objcache, id);
124 	if (obj) {
125 		obj->refcnt++;
126 	} else {
127 		err = open_object(&obj, pack, packidx, obj_idx, id,
128 		    objcache);
129 		if (err)
130 			return err;
131 	}
132 
133 	err = got_packfile_extract_object_to_mem(&buf, &len, obj, pack);
134 	if (err)
135 		goto done;
136 
137 	obj->size = len;
138 
139 	err = got_object_parse_commit(commit, buf, len);
140 done:
141 	got_object_close(obj);
142 	free(buf);
143 	return err;
144 }
145 
146 static const struct got_error *
147 commit_request(struct imsg *imsg, struct imsgbuf *ibuf, struct got_pack *pack,
148     struct got_packidx *packidx, struct got_object_cache *objcache)
149 {
150 	const struct got_error *err = NULL;
151 	struct got_imsg_packed_object iobj;
152 	struct got_commit_object *commit = NULL;
153 	struct got_object_id id;
154 	size_t datalen;
155 
156 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
157 	if (datalen != sizeof(iobj))
158 		return got_error(GOT_ERR_PRIVSEP_LEN);
159 	memcpy(&iobj, imsg->data, sizeof(iobj));
160 	memcpy(id.sha1, iobj.id, SHA1_DIGEST_LENGTH);
161 
162 	err = open_commit(&commit, pack, packidx, iobj.idx, &id, objcache);
163 	if (err)
164 		goto done;
165 
166 	err = got_privsep_send_commit(ibuf, commit);
167 done:
168 	if (commit)
169 		got_object_commit_close(commit);
170 	if (err) {
171 		if (err->code == GOT_ERR_PRIVSEP_PIPE)
172 			err = NULL;
173 		else
174 			got_privsep_send_error(ibuf, err);
175 	}
176 
177 	return err;
178 }
179 
180 static const struct got_error *
181 open_tree(uint8_t **buf, struct got_parsed_tree_entry **entries, int *nentries,
182     struct got_pack *pack, struct got_packidx *packidx, int obj_idx,
183     struct got_object_id *id, struct got_object_cache *objcache)
184 {
185 	const struct got_error *err = NULL;
186 	struct got_object *obj = NULL;
187 	size_t len;
188 
189 	*buf = NULL;
190 	*nentries = 0;
191 
192 	obj = got_object_cache_get(objcache, id);
193 	if (obj) {
194 		obj->refcnt++;
195 	} else {
196 		err = open_object(&obj, pack, packidx, obj_idx, id,
197 		    objcache);
198 		if (err)
199 			return err;
200 	}
201 
202 	err = got_packfile_extract_object_to_mem(buf, &len, obj, pack);
203 	if (err)
204 		goto done;
205 
206 	obj->size = len;
207 
208 	err = got_object_parse_tree(entries, nentries, *buf, len);
209 done:
210 	got_object_close(obj);
211 	if (err) {
212 		free(*buf);
213 		*buf = NULL;
214 	}
215 	return err;
216 }
217 
218 static const struct got_error *
219 tree_request(struct imsg *imsg, struct imsgbuf *ibuf, struct got_pack *pack,
220     struct got_packidx *packidx, struct got_object_cache *objcache)
221 {
222 	const struct got_error *err = NULL;
223 	struct got_imsg_packed_object iobj;
224 	struct got_parsed_tree_entry *entries = NULL;
225 	int nentries = 0;
226 	uint8_t *buf = NULL;
227 	struct got_object_id id;
228 	size_t datalen;
229 
230 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
231 	if (datalen != sizeof(iobj))
232 		return got_error(GOT_ERR_PRIVSEP_LEN);
233 	memcpy(&iobj, imsg->data, sizeof(iobj));
234 	memcpy(id.sha1, iobj.id, SHA1_DIGEST_LENGTH);
235 
236 	err = open_tree(&buf, &entries, &nentries, pack, packidx, iobj.idx,
237 	    &id, objcache);
238 	if (err)
239 		return err;
240 
241 	err = got_privsep_send_tree(ibuf, entries, nentries);
242 	free(entries);
243 	free(buf);
244 	if (err) {
245 		if (err->code == GOT_ERR_PRIVSEP_PIPE)
246 			err = NULL;
247 		else
248 			got_privsep_send_error(ibuf, err);
249 	}
250 
251 	return err;
252 }
253 
254 static const struct got_error *
255 receive_file(FILE **f, struct imsgbuf *ibuf, uint32_t imsg_code)
256 {
257 	const struct got_error *err;
258 	struct imsg imsg;
259 	size_t datalen;
260 
261 	err = got_privsep_recv_imsg(&imsg, ibuf, 0);
262 	if (err)
263 		return err;
264 
265 	if (imsg.hdr.type != imsg_code) {
266 		err = got_error(GOT_ERR_PRIVSEP_MSG);
267 		goto done;
268 	}
269 
270 	datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
271 	if (datalen != 0) {
272 		err = got_error(GOT_ERR_PRIVSEP_LEN);
273 		goto done;
274 	}
275 	if (imsg.fd == -1) {
276 		err = got_error(GOT_ERR_PRIVSEP_NO_FD);
277 		goto done;
278 	}
279 
280 	*f = fdopen(imsg.fd, "w+");
281 	if (*f == NULL) {
282 		err = got_error_from_errno("fdopen");
283 		close(imsg.fd);
284 		goto done;
285 	}
286 done:
287 	imsg_free(&imsg);
288 	return err;
289 }
290 
291 static const struct got_error *
292 receive_tempfile(FILE **f, const char *mode, struct imsg *imsg,
293     struct imsgbuf *ibuf)
294 {
295 	size_t datalen;
296 
297 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
298 	if (datalen != 0)
299 		return got_error(GOT_ERR_PRIVSEP_LEN);
300 
301 	if (imsg->fd == -1)
302 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
303 
304 	*f = fdopen(imsg->fd, mode);
305 	if (*f == NULL)
306 		return got_error_from_errno("fdopen");
307 	imsg->fd = -1;
308 
309 	return NULL;
310 }
311 
312 static const struct got_error *
313 blob_request(struct imsg *imsg, struct imsgbuf *ibuf, struct got_pack *pack,
314     struct got_packidx *packidx, struct got_object_cache *objcache,
315     FILE *basefile, FILE *accumfile)
316 {
317 	const struct got_error *err = NULL;
318 	struct got_imsg_packed_object iobj;
319 	struct got_object *obj = NULL;
320 	FILE *outfile = NULL;
321 	struct got_object_id id;
322 	size_t datalen;
323 	uint64_t blob_size;
324 	uint8_t *buf = NULL;
325 
326 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
327 	if (datalen != sizeof(iobj))
328 		return got_error(GOT_ERR_PRIVSEP_LEN);
329 	memcpy(&iobj, imsg->data, sizeof(iobj));
330 	memcpy(id.sha1, iobj.id, SHA1_DIGEST_LENGTH);
331 
332 	obj = got_object_cache_get(objcache, &id);
333 	if (obj) {
334 		obj->refcnt++;
335 	} else {
336 		err = open_object(&obj, pack, packidx, iobj.idx, &id,
337 		    objcache);
338 		if (err)
339 			return err;
340 	}
341 
342 	err = receive_file(&outfile, ibuf, GOT_IMSG_BLOB_OUTFD);
343 	if (err)
344 		goto done;
345 
346 	if (obj->flags & GOT_OBJ_FLAG_DELTIFIED) {
347 		err = got_pack_get_max_delta_object_size(&blob_size, obj, pack);
348 		if (err)
349 			goto done;
350 	} else
351 		blob_size = obj->size;
352 
353 	if (blob_size <= GOT_PRIVSEP_INLINE_BLOB_DATA_MAX)
354 		err = got_packfile_extract_object_to_mem(&buf, &obj->size,
355 		    obj, pack);
356 	else
357 		err = got_packfile_extract_object(pack, obj, outfile, basefile,
358 		    accumfile);
359 	if (err)
360 		goto done;
361 
362 	err = got_privsep_send_blob(ibuf, obj->size, obj->hdrlen, buf);
363 done:
364 	free(buf);
365 	if (outfile && fclose(outfile) == EOF && err == NULL)
366 		err = got_error_from_errno("fclose");
367 	got_object_close(obj);
368 	if (err && err->code != GOT_ERR_PRIVSEP_PIPE)
369 		got_privsep_send_error(ibuf, err);
370 
371 	return err;
372 }
373 
374 static const struct got_error *
375 tag_request(struct imsg *imsg, struct imsgbuf *ibuf, struct got_pack *pack,
376     struct got_packidx *packidx, struct got_object_cache *objcache)
377 {
378 	const struct got_error *err = NULL;
379 	struct got_imsg_packed_object iobj;
380 	struct got_object *obj = NULL;
381 	struct got_tag_object *tag = NULL;
382 	uint8_t *buf = NULL;
383 	size_t len;
384 	struct got_object_id id;
385 	size_t datalen;
386 
387 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
388 	if (datalen != sizeof(iobj))
389 		return got_error(GOT_ERR_PRIVSEP_LEN);
390 	memcpy(&iobj, imsg->data, sizeof(iobj));
391 	memcpy(id.sha1, iobj.id, SHA1_DIGEST_LENGTH);
392 
393 	obj = got_object_cache_get(objcache, &id);
394 	if (obj) {
395 		obj->refcnt++;
396 	} else {
397 		err = open_object(&obj, pack, packidx, iobj.idx, &id,
398 		    objcache);
399 		if (err)
400 			return err;
401 	}
402 
403 	err = got_packfile_extract_object_to_mem(&buf, &len, obj, pack);
404 	if (err)
405 		goto done;
406 
407 	obj->size = len;
408 	err = got_object_parse_tag(&tag, buf, len);
409 	if (err)
410 		goto done;
411 
412 	err = got_privsep_send_tag(ibuf, tag);
413 done:
414 	free(buf);
415 	got_object_close(obj);
416 	if (tag)
417 		got_object_tag_close(tag);
418 	if (err) {
419 		if (err->code == GOT_ERR_PRIVSEP_PIPE)
420 			err = NULL;
421 		else
422 			got_privsep_send_error(ibuf, err);
423 	}
424 
425 	return err;
426 }
427 
428 static struct got_parsed_tree_entry *
429 find_entry_by_name(struct got_parsed_tree_entry *entries, int nentries,
430     const char *name, size_t len)
431 {
432 	struct got_parsed_tree_entry *pte;
433 	int cmp, i;
434 
435 	/* Note that tree entries are sorted in strncmp() order. */
436 	for (i = 0; i < nentries; i++) {
437 		pte = &entries[i];
438 		cmp = strncmp(pte->name, name, len);
439 		if (cmp < 0)
440 			continue;
441 		if (cmp > 0)
442 			break;
443 		if (pte->name[len] == '\0')
444 			return pte;
445 	}
446 	return NULL;
447 }
448 
449 static const struct got_error *
450 tree_path_changed(int *changed, uint8_t **buf1, uint8_t **buf2,
451     struct got_parsed_tree_entry **entries1, int *nentries1,
452     struct got_parsed_tree_entry **entries2, int *nentries2,
453     const char *path, struct got_pack *pack, struct got_packidx *packidx,
454     struct imsgbuf *ibuf, struct got_object_cache *objcache)
455 {
456 	const struct got_error *err = NULL;
457 	struct got_parsed_tree_entry *pte1 = NULL, *pte2 = NULL;
458 	const char *seg, *s;
459 	size_t seglen;
460 
461 	*changed = 0;
462 
463 	/* We not do support comparing the root path. */
464 	if (got_path_is_root_dir(path))
465 		return got_error_path(path, GOT_ERR_BAD_PATH);
466 
467 	s = path;
468 	while (*s == '/')
469 		s++;
470 	seg = s;
471 	seglen = 0;
472 	while (*s) {
473 		if (*s != '/') {
474 			s++;
475 			seglen++;
476 			if (*s)
477 				continue;
478 		}
479 
480 		pte1 = find_entry_by_name(*entries1, *nentries1, seg, seglen);
481 		if (pte1 == NULL) {
482 			err = got_error(GOT_ERR_NO_OBJ);
483 			break;
484 		}
485 
486 		pte2 = find_entry_by_name(*entries2, *nentries2, seg, seglen);
487 		if (pte2 == NULL) {
488 			*changed = 1;
489 			break;
490 		}
491 
492 		if (pte1->mode != pte2->mode) {
493 			*changed = 1;
494 			break;
495 		}
496 
497 		if (memcmp(pte1->id, pte2->id, SHA1_DIGEST_LENGTH) == 0) {
498 			*changed = 0;
499 			break;
500 		}
501 
502 		if (*s == '\0') { /* final path element */
503 			*changed = 1;
504 			break;
505 		}
506 
507 		seg = s + 1;
508 		s++;
509 		seglen = 0;
510 		if (*s) {
511 			struct got_object_id id1, id2;
512 			int idx;
513 
514 			memcpy(id1.sha1, pte1->id, SHA1_DIGEST_LENGTH);
515 			idx = got_packidx_get_object_idx(packidx, &id1);
516 			if (idx == -1) {
517 				err = got_error_no_obj(&id1);
518 				break;
519 			}
520 			free(*entries1);
521 			*nentries1 = 0;
522 			free(*buf1);
523 			*buf1 = NULL;
524 			err = open_tree(buf1, entries1, nentries1, pack,
525 			    packidx, idx, &id1, objcache);
526 			pte1 = NULL;
527 			if (err)
528 				break;
529 
530 			memcpy(id2.sha1, pte2->id, SHA1_DIGEST_LENGTH);
531 			idx = got_packidx_get_object_idx(packidx, &id2);
532 			if (idx == -1) {
533 				err = got_error_no_obj(&id2);
534 				break;
535 			}
536 			free(*entries2);
537 			*nentries2 = 0;
538 			free(*buf2);
539 			*buf2 = NULL;
540 			err = open_tree(buf2, entries2, nentries2, pack,
541 			    packidx, idx, &id2, objcache);
542 			pte2 = NULL;
543 			if (err)
544 				break;
545 		}
546 	}
547 
548 	return err;
549 }
550 
551 static const struct got_error *
552 send_traversed_commits(struct got_object_id *commit_ids, size_t ncommits,
553     struct imsgbuf *ibuf)
554 {
555 	struct ibuf *wbuf;
556 	size_t i;
557 
558 	wbuf = imsg_create(ibuf, GOT_IMSG_TRAVERSED_COMMITS, 0, 0,
559 	    sizeof(struct got_imsg_traversed_commits) +
560 	    ncommits * SHA1_DIGEST_LENGTH);
561 	if (wbuf == NULL)
562 		return got_error_from_errno("imsg_create TRAVERSED_COMMITS");
563 
564 	if (imsg_add(wbuf, &ncommits, sizeof(ncommits)) == -1)
565 		return got_error_from_errno("imsg_add TRAVERSED_COMMITS");
566 
567 	for (i = 0; i < ncommits; i++) {
568 		struct got_object_id *id = &commit_ids[i];
569 		if (imsg_add(wbuf, id->sha1, SHA1_DIGEST_LENGTH) == -1) {
570 			return got_error_from_errno(
571 			    "imsg_add TRAVERSED_COMMITS");
572 		}
573 	}
574 
575 	wbuf->fd = -1;
576 	imsg_close(ibuf, wbuf);
577 
578 	return got_privsep_flush_imsg(ibuf);
579 }
580 
581 static const struct got_error *
582 send_commit_traversal_done(struct imsgbuf *ibuf)
583 {
584 	if (imsg_compose(ibuf, GOT_IMSG_COMMIT_TRAVERSAL_DONE, 0, 0, -1,
585 	    NULL, 0) == -1)
586 		return got_error_from_errno("imsg_compose TRAVERSAL_DONE");
587 
588 	return got_privsep_flush_imsg(ibuf);
589 }
590 
591 static const struct got_error *
592 commit_traversal_request(struct imsg *imsg, struct imsgbuf *ibuf,
593     struct got_pack *pack, struct got_packidx *packidx,
594     struct got_object_cache *objcache)
595 {
596 	const struct got_error *err = NULL;
597 	struct got_imsg_packed_object iobj;
598 	struct got_object_qid *pid;
599 	struct got_commit_object *commit = NULL, *pcommit = NULL;
600 	struct got_parsed_tree_entry *entries = NULL, *pentries = NULL;
601 	int nentries = 0, pnentries = 0;
602 	struct got_object_id id;
603 	size_t datalen, path_len;
604 	char *path = NULL;
605 	const int min_alloc = 64;
606 	int changed = 0, ncommits = 0, nallocated = 0;
607 	struct got_object_id *commit_ids = NULL;
608 
609 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
610 	if (datalen < sizeof(iobj))
611 		return got_error(GOT_ERR_PRIVSEP_LEN);
612 	memcpy(&iobj, imsg->data, sizeof(iobj));
613 	memcpy(id.sha1, iobj.id, SHA1_DIGEST_LENGTH);
614 
615 	path_len = datalen - sizeof(iobj) - 1;
616 	if (path_len < 0)
617 		return got_error(GOT_ERR_PRIVSEP_LEN);
618 	if (path_len > 0) {
619 		path = imsg->data + sizeof(iobj);
620 		if (path[path_len] != '\0')
621 			return got_error(GOT_ERR_PRIVSEP_LEN);
622 	}
623 
624 	nallocated = min_alloc;
625 	commit_ids = reallocarray(NULL, nallocated, sizeof(*commit_ids));
626 	if (commit_ids == NULL)
627 		return got_error_from_errno("reallocarray");
628 
629 	do {
630 		const size_t max_datalen = MAX_IMSGSIZE - IMSG_HEADER_SIZE;
631 		int idx;
632 
633 		if (sigint_received) {
634 			err = got_error(GOT_ERR_CANCELLED);
635 			goto done;
636 		}
637 
638 		if (commit == NULL) {
639 			idx = got_packidx_get_object_idx(packidx, &id);
640 			if (idx == -1)
641 				break;
642 			err = open_commit(&commit, pack, packidx,
643 			    idx, &id, objcache);
644 			if (err) {
645 				if (err->code != GOT_ERR_NO_OBJ)
646 					goto done;
647 				err = NULL;
648 				break;
649 			}
650 		}
651 
652 		if (sizeof(struct got_imsg_traversed_commits) +
653 		    ncommits * SHA1_DIGEST_LENGTH >= max_datalen) {
654 			err = send_traversed_commits(commit_ids, ncommits,
655 			    ibuf);
656 			if (err)
657 				goto done;
658 			ncommits = 0;
659 		}
660 		ncommits++;
661 		if (ncommits > nallocated) {
662 			struct got_object_id *new;
663 			nallocated += min_alloc;
664 			new = reallocarray(commit_ids, nallocated,
665 			    sizeof(*commit_ids));
666 			if (new == NULL) {
667 				err = got_error_from_errno("reallocarray");
668 				goto done;
669 			}
670 			commit_ids = new;
671 		}
672 		memcpy(commit_ids[ncommits - 1].sha1, id.sha1,
673 		    SHA1_DIGEST_LENGTH);
674 
675 		pid = STAILQ_FIRST(&commit->parent_ids);
676 		if (pid == NULL)
677 			break;
678 
679 		idx = got_packidx_get_object_idx(packidx, &pid->id);
680 		if (idx == -1)
681 			break;
682 
683 		err = open_commit(&pcommit, pack, packidx, idx, &pid->id,
684 		    objcache);
685 		if (err) {
686 			if (err->code != GOT_ERR_NO_OBJ)
687 				goto done;
688 			err = NULL;
689 			break;
690 		}
691 
692 		if (path[0] == '/' && path[1] == '\0') {
693 			if (got_object_id_cmp(pcommit->tree_id,
694 			    commit->tree_id) != 0) {
695 				changed = 1;
696 				break;
697 			}
698 		} else {
699 			int pidx;
700 			uint8_t *buf = NULL, *pbuf = NULL;
701 
702 			idx = got_packidx_get_object_idx(packidx,
703 			    commit->tree_id);
704 			if (idx == -1)
705 				break;
706 			pidx = got_packidx_get_object_idx(packidx,
707 			    pcommit->tree_id);
708 			if (pidx == -1)
709 				break;
710 
711 			err = open_tree(&buf, &entries, &nentries, pack,
712 			    packidx, idx, commit->tree_id, objcache);
713 			if (err)
714 				goto done;
715 			err = open_tree(&pbuf, &pentries, &pnentries, pack,
716 			    packidx, pidx, pcommit->tree_id, objcache);
717 			if (err) {
718 				free(buf);
719 				goto done;
720 			}
721 
722 			err = tree_path_changed(&changed, &buf, &pbuf,
723 			    &entries, &nentries, &pentries, &pnentries, path,
724 			    pack, packidx, ibuf, objcache);
725 
726 			free(entries);
727 			entries = NULL;
728 			nentries = 0;
729 			free(buf);
730 			free(pentries);
731 			pentries = NULL;
732 			pnentries = 0;
733 			free(pbuf);
734 			if (err) {
735 				if (err->code != GOT_ERR_NO_OBJ)
736 					goto done;
737 				err = NULL;
738 				break;
739 			}
740 		}
741 
742 		if (!changed) {
743 			memcpy(id.sha1, pid->id.sha1, SHA1_DIGEST_LENGTH);
744 			got_object_commit_close(commit);
745 			commit = pcommit;
746 			pcommit = NULL;
747 		}
748 	} while (!changed);
749 
750 	if (ncommits > 0) {
751 		err = send_traversed_commits(commit_ids, ncommits, ibuf);
752 		if (err)
753 			goto done;
754 
755 		if (changed) {
756 			err = got_privsep_send_commit(ibuf, commit);
757 			if (err)
758 				goto done;
759 		}
760 	}
761 	err = send_commit_traversal_done(ibuf);
762 done:
763 	free(commit_ids);
764 	if (commit)
765 		got_object_commit_close(commit);
766 	if (pcommit)
767 		got_object_commit_close(pcommit);
768 	free(entries);
769 	free(pentries);
770 	if (err) {
771 		if (err->code == GOT_ERR_PRIVSEP_PIPE)
772 			err = NULL;
773 		else
774 			got_privsep_send_error(ibuf, err);
775 	}
776 
777 	return err;
778 }
779 
780 static const struct got_error *
781 raw_object_request(struct imsg *imsg, struct imsgbuf *ibuf,
782     struct got_pack *pack, struct got_packidx *packidx,
783     struct got_object_cache *objcache, FILE *basefile, FILE *accumfile)
784 {
785 	const struct got_error *err = NULL;
786 	uint8_t *buf = NULL;
787 	uint64_t size = 0;
788 	FILE *outfile = NULL;
789 	struct got_imsg_packed_object iobj;
790 	struct got_object *obj;
791 	struct got_object_id id;
792 	size_t datalen;
793 
794 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
795 	if (datalen != sizeof(iobj))
796 		return got_error(GOT_ERR_PRIVSEP_LEN);
797 	memcpy(&iobj, imsg->data, sizeof(iobj));
798 	memcpy(id.sha1, iobj.id, SHA1_DIGEST_LENGTH);
799 
800 	obj = got_object_cache_get(objcache, &id);
801 	if (obj) {
802 		obj->refcnt++;
803 	} else {
804 		err = open_object(&obj, pack, packidx, iobj.idx, &id,
805 		    objcache);
806 		if (err)
807 			return err;
808 	}
809 
810 	err = receive_file(&outfile, ibuf, GOT_IMSG_RAW_OBJECT_OUTFD);
811 	if (err)
812 		return err;
813 
814 	if (obj->flags & GOT_OBJ_FLAG_DELTIFIED) {
815 		err = got_pack_get_max_delta_object_size(&size, obj, pack);
816 		if (err)
817 			goto done;
818 	} else
819 		size = obj->size;
820 
821 	if (size <= GOT_PRIVSEP_INLINE_OBJECT_DATA_MAX)
822 		err = got_packfile_extract_object_to_mem(&buf, &obj->size,
823 		    obj, pack);
824 	else
825 		err = got_packfile_extract_object(pack, obj, outfile, basefile,
826 		    accumfile);
827 	if (err)
828 		goto done;
829 
830 	err = got_privsep_send_raw_obj(ibuf, obj->size, obj->hdrlen, buf);
831 done:
832 	free(buf);
833 	if (outfile && fclose(outfile) == EOF && err == NULL)
834 		err = got_error_from_errno("fclose");
835 	got_object_close(obj);
836 	if (err && err->code != GOT_ERR_PRIVSEP_PIPE)
837 		got_privsep_send_error(ibuf, err);
838 
839 	return err;
840 }
841 
842 static const struct got_error *
843 get_base_object_id(struct got_object_id *base_id, struct got_packidx *packidx,
844     off_t base_offset)
845 {
846 	const struct got_error *err;
847 	int idx;
848 
849 	err = got_packidx_get_offset_idx(&idx, packidx, base_offset); 
850 	if (err)
851 		return err;
852 	if (idx == -1)
853 		return got_error(GOT_ERR_BAD_PACKIDX);
854 
855 	return got_packidx_get_object_id(base_id, packidx, idx);
856 }
857 
858 static const struct got_error *
859 raw_delta_request(struct imsg *imsg, struct imsgbuf *ibuf,
860     FILE *delta_outfile, struct got_pack *pack,
861     struct got_packidx *packidx)
862 {
863 	const struct got_error *err = NULL;
864 	struct got_imsg_raw_delta_request req;
865 	size_t datalen, delta_size, delta_compressed_size;
866 	off_t delta_offset;
867 	uint8_t *delta_buf = NULL;
868 	struct got_object_id id, base_id;
869 	off_t base_offset, delta_out_offset = 0;
870 	uint64_t base_size = 0, result_size = 0;
871 	size_t w;
872 
873 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
874 	if (datalen != sizeof(req))
875 		return got_error(GOT_ERR_PRIVSEP_LEN);
876 	memcpy(&req, imsg->data, sizeof(req));
877 	memcpy(id.sha1, req.id, SHA1_DIGEST_LENGTH);
878 
879 	imsg->fd = -1;
880 
881 	err = got_packfile_extract_raw_delta(&delta_buf, &delta_size,
882 	    &delta_compressed_size, &delta_offset, &base_offset, &base_id,
883 	    &base_size, &result_size, pack, packidx, req.idx);
884 	if (err)
885 		goto done;
886 
887 	/*
888 	 * If this is an offset delta we must determine the base
889 	 * object ID ourselves.
890 	 */
891 	if (base_offset != 0) {
892 		err = get_base_object_id(&base_id, packidx, base_offset);
893 		if (err)
894 			goto done;
895 	}
896 
897 	delta_out_offset = ftello(delta_outfile);
898 	w = fwrite(delta_buf, 1, delta_compressed_size, delta_outfile);
899 	if (w != delta_compressed_size) {
900 		err = got_ferror(delta_outfile, GOT_ERR_IO);
901 		goto done;
902 	}
903 	if (fflush(delta_outfile) == -1) {
904 		err = got_error_from_errno("fflush");
905 		goto done;
906 	}
907 
908 	err = got_privsep_send_raw_delta(ibuf, base_size, result_size,
909 	    delta_size, delta_compressed_size, delta_offset, delta_out_offset,
910 	    &base_id);
911 done:
912 	free(delta_buf);
913 	return err;
914 }
915 
916 struct search_deltas_arg {
917 	struct imsgbuf *ibuf;
918 	struct got_packidx *packidx;
919 	struct got_pack *pack;
920 	struct got_object_idset *idset;
921 	FILE *delta_outfile;
922 	struct got_imsg_reused_delta deltas[GOT_IMSG_REUSED_DELTAS_MAX_NDELTAS];
923 	size_t ndeltas;
924 };
925 
926 static const struct got_error *
927 search_delta_for_object(struct got_object_id *id, void *data, void *arg)
928 {
929 	const struct got_error *err;
930 	struct search_deltas_arg *a = arg;
931 	int obj_idx;
932 	uint8_t *delta_buf = NULL;
933 	uint64_t base_size, result_size;
934 	size_t delta_size, delta_compressed_size;
935 	off_t delta_offset, base_offset;
936 	struct got_object_id base_id;
937 
938 	if (sigint_received)
939 		return got_error(GOT_ERR_CANCELLED);
940 
941 	obj_idx = got_packidx_get_object_idx(a->packidx, id);
942 	if (obj_idx == -1)
943 		return NULL; /* object not present in our pack file */
944 
945 	err = got_packfile_extract_raw_delta(&delta_buf, &delta_size,
946 	    &delta_compressed_size, &delta_offset, &base_offset, &base_id,
947 	    &base_size, &result_size, a->pack, a->packidx, obj_idx);
948 	if (err) {
949 		if (err->code == GOT_ERR_OBJ_TYPE)
950 			return NULL; /* object not stored as a delta */
951 		return err;
952 	}
953 
954 	/*
955 	 * If this is an offset delta we must determine the base
956 	 * object ID ourselves.
957 	 */
958 	if (base_offset != 0) {
959 		err = get_base_object_id(&base_id, a->packidx, base_offset);
960 		if (err)
961 			goto done;
962 	}
963 
964 	if (got_object_idset_contains(a->idset, &base_id)) {
965 		struct got_imsg_reused_delta *delta;
966 		off_t delta_out_offset = ftello(a->delta_outfile);
967 		size_t w;
968 
969 		w = fwrite(delta_buf, 1, delta_compressed_size,
970 		    a->delta_outfile);
971 		if (w != delta_compressed_size) {
972 			err = got_ferror(a->delta_outfile, GOT_ERR_IO);
973 			goto done;
974 		}
975 
976 		delta = &a->deltas[a->ndeltas++];
977 		memcpy(&delta->id, id, sizeof(delta->id));
978 		memcpy(&delta->base_id, &base_id, sizeof(delta->base_id));
979 		delta->base_size = base_size;
980 		delta->result_size = result_size;
981 		delta->delta_size = delta_size;
982 		delta->delta_compressed_size = delta_compressed_size;
983 		delta->delta_offset = delta_offset;
984 		delta->delta_out_offset = delta_out_offset;
985 
986 		if (a->ndeltas >= GOT_IMSG_REUSED_DELTAS_MAX_NDELTAS) {
987 			err = got_privsep_send_reused_deltas(a->ibuf,
988 			    a->deltas, a->ndeltas);
989 			if (err)
990 				goto done;
991 			a->ndeltas = 0;
992 		}
993 	}
994 done:
995 	free(delta_buf);
996 	return err;
997 }
998 
999 static const struct got_error *
1000 recv_object_ids(struct got_object_idset *idset, struct imsgbuf *ibuf)
1001 {
1002 	const struct got_error *err = NULL;
1003 	int done = 0;
1004 	struct got_object_id *ids;
1005 	size_t nids, i;
1006 
1007 	for (;;) {
1008 		err = got_privsep_recv_object_idlist(&done, &ids, &nids, ibuf);
1009 		if (err || done)
1010 			break;
1011 		for (i = 0; i < nids; i++) {
1012 			err = got_object_idset_add(idset, &ids[i], NULL);
1013 			if (err) {
1014 				free(ids);
1015 				return err;
1016 			}
1017 		}
1018 		free(ids);
1019 	}
1020 
1021 	return err;
1022 }
1023 
1024 static const struct got_error *
1025 recv_object_id_queue(struct got_object_id_queue *queue, struct imsgbuf *ibuf)
1026 {
1027 	const struct got_error *err = NULL;
1028 	int done = 0;
1029 	struct got_object_qid *qid;
1030 	struct got_object_id *ids;
1031 	size_t nids, i;
1032 
1033 	for (;;) {
1034 		err = got_privsep_recv_object_idlist(&done, &ids, &nids, ibuf);
1035 		if (err || done)
1036 			break;
1037 		for (i = 0; i < nids; i++) {
1038 			err = got_object_qid_alloc_partial(&qid);
1039 			if (err)
1040 				return err;
1041 			memcpy(&qid->id, &ids[i], sizeof(qid->id));
1042 			STAILQ_INSERT_TAIL(queue, qid, entry);
1043 		}
1044 	}
1045 
1046 	return err;
1047 }
1048 
1049 static const struct got_error *
1050 delta_reuse_request(struct imsg *imsg, struct imsgbuf *ibuf,
1051     FILE *delta_outfile, struct got_pack *pack, struct got_packidx *packidx)
1052 {
1053 	const struct got_error *err = NULL;
1054 	struct got_object_idset *idset;
1055 	struct search_deltas_arg sda;
1056 
1057 	idset = got_object_idset_alloc();
1058 	if (idset == NULL)
1059 		return got_error_from_errno("got_object_idset_alloc");
1060 
1061 	err = recv_object_ids(idset, ibuf);
1062 	if (err)
1063 		return err;
1064 
1065 	memset(&sda, 0, sizeof(sda));
1066 	sda.ibuf = ibuf;
1067 	sda.idset = idset;
1068 	sda.pack = pack;
1069 	sda.packidx = packidx;
1070 	sda.delta_outfile = delta_outfile;
1071 	err = got_object_idset_for_each(idset, search_delta_for_object, &sda);
1072 	if (err)
1073 		goto done;
1074 
1075 	if (sda.ndeltas > 0) {
1076 		err = got_privsep_send_reused_deltas(ibuf, sda.deltas,
1077 		    sda.ndeltas);
1078 		if (err)
1079 			goto done;
1080 	}
1081 
1082 	if (fflush(delta_outfile) == -1) {
1083 		err = got_error_from_errno("fflush");
1084 		goto done;
1085 	}
1086 
1087 	err = got_privsep_send_reused_deltas_done(ibuf);
1088 done:
1089 	got_object_idset_free(idset);
1090 	return err;
1091 }
1092 
1093 static const struct got_error *
1094 receive_packidx(struct got_packidx **packidx, struct imsgbuf *ibuf)
1095 {
1096 	const struct got_error *err = NULL;
1097 	struct imsg imsg;
1098 	struct got_imsg_packidx ipackidx;
1099 	size_t datalen;
1100 	struct got_packidx *p;
1101 
1102 	*packidx = NULL;
1103 
1104 	err = got_privsep_recv_imsg(&imsg, ibuf, 0);
1105 	if (err)
1106 		return err;
1107 
1108 	p = calloc(1, sizeof(*p));
1109 	if (p == NULL) {
1110 		err = got_error_from_errno("calloc");
1111 		goto done;
1112 	}
1113 
1114 	if (imsg.hdr.type != GOT_IMSG_PACKIDX) {
1115 		err = got_error(GOT_ERR_PRIVSEP_MSG);
1116 		goto done;
1117 	}
1118 
1119 	if (imsg.fd == -1) {
1120 		err = got_error(GOT_ERR_PRIVSEP_NO_FD);
1121 		goto done;
1122 	}
1123 
1124 	datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1125 	if (datalen != sizeof(ipackidx)) {
1126 		err = got_error(GOT_ERR_PRIVSEP_LEN);
1127 		goto done;
1128 	}
1129 	memcpy(&ipackidx, imsg.data, sizeof(ipackidx));
1130 
1131 	p->len = ipackidx.len;
1132 	p->fd = dup(imsg.fd);
1133 	if (p->fd == -1) {
1134 		err = got_error_from_errno("dup");
1135 		goto done;
1136 	}
1137 	if (lseek(p->fd, 0, SEEK_SET) == -1) {
1138 		err = got_error_from_errno("lseek");
1139 		goto done;
1140 	}
1141 
1142 #ifndef GOT_PACK_NO_MMAP
1143 	p->map = mmap(NULL, p->len, PROT_READ, MAP_PRIVATE, p->fd, 0);
1144 	if (p->map == MAP_FAILED)
1145 		p->map = NULL; /* fall back to read(2) */
1146 #endif
1147 	err = got_packidx_init_hdr(p, 1, ipackidx.packfile_size);
1148 done:
1149 	if (err) {
1150 		if (imsg.fd != -1)
1151 			close(imsg.fd);
1152 		got_packidx_close(p);
1153 	} else
1154 		*packidx = p;
1155 	imsg_free(&imsg);
1156 	return err;
1157 }
1158 
1159 static const struct got_error *
1160 send_tree_enumeration_done(struct imsgbuf *ibuf)
1161 {
1162 	if (imsg_compose(ibuf, GOT_IMSG_TREE_ENUMERATION_DONE, 0, 0, -1,
1163 	    NULL, 0) == -1)
1164 		return got_error_from_errno("imsg_compose TREE_ENUMERATION_DONE");
1165 
1166 	return got_privsep_flush_imsg(ibuf);
1167 }
1168 
1169 static const struct got_error *
1170 enumerate_tree(struct imsgbuf *ibuf, size_t *totlen,
1171     struct got_object_id *tree_id,
1172     const char *path, struct got_pack *pack, struct got_packidx *packidx,
1173     struct got_object_cache *objcache, struct got_object_idset *idset)
1174 {
1175 	const struct got_error *err = NULL;
1176 	struct got_object_id_queue ids;
1177 	struct got_object_qid *qid;
1178 	uint8_t *buf = NULL;
1179 	struct got_parsed_tree_entry *entries = NULL;
1180 
1181 	STAILQ_INIT(&ids);
1182 
1183 	err = got_object_qid_alloc_partial(&qid);
1184 	if (err)
1185 		return err;
1186 	memcpy(&qid->id.sha1, tree_id, SHA1_DIGEST_LENGTH);
1187 	qid->data = strdup(path);
1188 	if (qid->data == NULL) {
1189 		err = got_error_from_errno("strdup");
1190 		goto done;
1191 	}
1192 	STAILQ_INSERT_TAIL(&ids, qid, entry);
1193 	qid = NULL;
1194 
1195 	do {
1196 		const char *path;
1197 		int idx, nentries, i;
1198 
1199 		if (sigint_received) {
1200 			err = got_error(GOT_ERR_CANCELLED);
1201 			goto done;
1202 		}
1203 
1204 		qid = STAILQ_FIRST(&ids);
1205 		STAILQ_REMOVE_HEAD(&ids, entry);
1206 		path = qid->data;
1207 
1208 		idx = got_packidx_get_object_idx(packidx, &qid->id);
1209 		if (idx == -1) {
1210 			err = got_privsep_send_enumerated_tree(totlen, ibuf,
1211 			    &qid->id, path, NULL, -1);
1212 			break;
1213 		}
1214 
1215 		err = open_tree(&buf, &entries, &nentries,
1216 		    pack, packidx, idx, &qid->id, objcache);
1217 		if (err) {
1218 			if (err->code != GOT_ERR_NO_OBJ)
1219 				goto done;
1220 		}
1221 
1222 		err = got_privsep_send_enumerated_tree(totlen,
1223 		    ibuf, &qid->id, path, entries, nentries);
1224 		if (err)
1225 			goto done;
1226 
1227 		err = got_object_idset_add(idset, &qid->id, NULL);
1228 		if (err)
1229 			goto done;
1230 
1231 		for (i = 0; i < nentries; i++) {
1232 			struct got_object_qid *eqid = NULL;
1233 			struct got_parsed_tree_entry *pte = &entries[i];
1234 			char *p;
1235 
1236 			if (!S_ISDIR(pte->mode))
1237 				continue;
1238 
1239 			err = got_object_qid_alloc_partial(&eqid);
1240 			if (err)
1241 				goto done;
1242 			memcpy(eqid->id.sha1, pte->id, sizeof(eqid->id.sha1));
1243 
1244 			if (got_object_idset_contains(idset, &eqid->id)) {
1245 				got_object_qid_free(eqid);
1246 				continue;
1247 			}
1248 
1249 			if (asprintf(&p, "%s%s%s", path,
1250 			    got_path_is_root_dir(path) ? "" : "/",
1251 			    pte->name) == -1) {
1252 				err = got_error_from_errno("asprintf");
1253 				got_object_qid_free(eqid);
1254 				goto done;
1255 			}
1256 			eqid->data = p;
1257 			STAILQ_INSERT_TAIL(&ids, eqid, entry);
1258 			idx = got_packidx_get_object_idx(packidx, &eqid->id);
1259 			if (idx == -1)
1260 				break;
1261 		}
1262 
1263 		free(qid->data);
1264 		got_object_qid_free(qid);
1265 		qid = NULL;
1266 
1267 		free(entries);
1268 		entries = NULL;
1269 		free(buf);
1270 		buf = NULL;
1271 	} while (!STAILQ_EMPTY(&ids));
1272 
1273 	err = send_tree_enumeration_done(ibuf);
1274 done:
1275 	free(buf);
1276 	if (qid)
1277 		free(qid->data);
1278 	got_object_qid_free(qid);
1279 	got_object_id_queue_free(&ids);
1280 	free(entries);
1281 	if (err) {
1282 		if (err->code == GOT_ERR_PRIVSEP_PIPE)
1283 			err = NULL;
1284 		else
1285 			got_privsep_send_error(ibuf, err);
1286 	}
1287 
1288 	return err;
1289 }
1290 
1291 static const struct got_error *
1292 enumeration_request(struct imsg *imsg, struct imsgbuf *ibuf,
1293     struct got_pack *pack, struct got_packidx *packidx,
1294     struct got_object_cache *objcache)
1295 {
1296 	const struct got_error *err = NULL;
1297 	struct got_object_id_queue commit_ids;
1298 	const struct got_object_id_queue *parents = NULL;
1299 	struct got_object_qid *qid = NULL;
1300 	struct got_object *obj = NULL;
1301 	struct got_commit_object *commit = NULL;
1302 	struct got_object_id *tree_id = NULL;
1303 	size_t totlen = 0;
1304 	struct got_object_idset *idset;
1305 	int idx;
1306 
1307 	STAILQ_INIT(&commit_ids);
1308 
1309 	idset = got_object_idset_alloc();
1310 	if (idset == NULL)
1311 		return got_error_from_errno("got_object_idset_alloc");
1312 
1313 	err = recv_object_id_queue(&commit_ids, ibuf);
1314 	if (err)
1315 		goto done;
1316 
1317 	err = recv_object_ids(idset, ibuf);
1318 	if (err)
1319 		goto done;
1320 
1321 	while (!STAILQ_EMPTY(&commit_ids)) {
1322 		if (sigint_received) {
1323 			err = got_error(GOT_ERR_CANCELLED);
1324 			goto done;
1325 		}
1326 
1327 		qid = STAILQ_FIRST(&commit_ids);
1328 		STAILQ_REMOVE_HEAD(&commit_ids, entry);
1329 
1330 		if (got_object_idset_contains(idset, &qid->id)) {
1331 			got_object_qid_free(qid);
1332 			qid = NULL;
1333 			continue;
1334 		}
1335 
1336 		idx = got_packidx_get_object_idx(packidx, &qid->id);
1337 		if (idx == -1)
1338 			break;
1339 
1340 		err = open_object(&obj, pack, packidx, idx, &qid->id,
1341 		    objcache);
1342 		if (err)
1343 			goto done;
1344 		if (obj->type == GOT_OBJ_TYPE_TAG) {
1345 			struct got_tag_object *tag;
1346 			uint8_t *buf;
1347 			size_t len;
1348 			err = got_packfile_extract_object_to_mem(&buf,
1349 			    &len, obj, pack);
1350 			if (err)
1351 				goto done;
1352 			obj->size = len;
1353 			err = got_object_parse_tag(&tag, buf, len);
1354 			if (err) {
1355 				free(buf);
1356 				goto done;
1357 			}
1358 			err = open_commit(&commit, pack, packidx, idx,
1359 			    &tag->id, objcache);
1360 			got_object_tag_close(tag);
1361 			free(buf);
1362 			if (err)
1363 				goto done;
1364 		} else if (obj->type == GOT_OBJ_TYPE_COMMIT) {
1365 			err = open_commit(&commit, pack, packidx, idx,
1366 			    &qid->id, objcache);
1367 			if (err)
1368 				goto done;
1369 		} else {
1370 			err = got_error(GOT_ERR_OBJ_TYPE);
1371 			goto done;
1372 		}
1373 		got_object_close(obj);
1374 		obj = NULL;
1375 
1376 		err = got_privsep_send_enumerated_commit(ibuf, &qid->id,
1377 		    got_object_commit_get_committer_time(commit));
1378 		if (err)
1379 			goto done;
1380 
1381 		tree_id = got_object_commit_get_tree_id(commit);
1382 		idx = got_packidx_get_object_idx(packidx, tree_id);
1383 		if (idx == -1) {
1384 			err = got_privsep_send_enumerated_tree(&totlen, ibuf,
1385 			    tree_id, "", NULL, -1);
1386 			if (err)
1387 				goto done;
1388 			break;
1389 		}
1390 
1391 		if (got_object_idset_contains(idset, tree_id)) {
1392 			got_object_qid_free(qid);
1393 			qid = NULL;
1394 			continue;
1395 		}
1396 
1397 		err = enumerate_tree(ibuf, &totlen, tree_id, "/",
1398 		    pack, packidx, objcache, idset);
1399 		if (err)
1400 			goto done;
1401 
1402 		got_object_qid_free(qid);
1403 		qid = NULL;
1404 
1405 		parents = got_object_commit_get_parent_ids(commit);
1406 		if (parents) {
1407 			struct got_object_qid *pid;
1408 			STAILQ_FOREACH(pid, parents, entry) {
1409 				if (got_object_idset_contains(idset, &pid->id))
1410 					continue;
1411 				err = got_object_qid_alloc_partial(&qid);
1412 				if (err)
1413 					goto done;
1414 				memcpy(&qid->id, &pid->id, sizeof(qid->id));
1415 				STAILQ_INSERT_TAIL(&commit_ids, qid, entry);
1416 				qid = NULL;
1417 			}
1418 		}
1419 
1420 		got_object_commit_close(commit);
1421 		commit = NULL;
1422 	}
1423 
1424 	err = got_privsep_send_object_enumeration_done(ibuf);
1425 	if (err)
1426 		goto done;
1427 done:
1428 	if (obj)
1429 		got_object_close(obj);
1430 	if (commit)
1431 		got_object_commit_close(commit);
1432 	got_object_qid_free(qid);
1433 	got_object_id_queue_free(&commit_ids);
1434 	got_object_idset_free(idset);
1435 	return err;
1436 }
1437 
1438 static const struct got_error *
1439 receive_pack(struct got_pack **packp, struct imsgbuf *ibuf)
1440 {
1441 	const struct got_error *err = NULL;
1442 	struct imsg imsg;
1443 	struct got_imsg_pack ipack;
1444 	size_t datalen;
1445 	struct got_pack *pack;
1446 
1447 	*packp = NULL;
1448 
1449 	err = got_privsep_recv_imsg(&imsg, ibuf, 0);
1450 	if (err)
1451 		return err;
1452 
1453 	pack = calloc(1, sizeof(*pack));
1454 	if (pack == NULL) {
1455 		err = got_error_from_errno("calloc");
1456 		goto done;
1457 	}
1458 
1459 	if (imsg.hdr.type != GOT_IMSG_PACK) {
1460 		err = got_error(GOT_ERR_PRIVSEP_MSG);
1461 		goto done;
1462 	}
1463 
1464 	if (imsg.fd == -1) {
1465 		err = got_error(GOT_ERR_PRIVSEP_NO_FD);
1466 		goto done;
1467 	}
1468 
1469 	datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1470 	if (datalen != sizeof(ipack)) {
1471 		err = got_error(GOT_ERR_PRIVSEP_LEN);
1472 		goto done;
1473 	}
1474 	memcpy(&ipack, imsg.data, sizeof(ipack));
1475 
1476 	pack->filesize = ipack.filesize;
1477 	pack->fd = dup(imsg.fd);
1478 	if (pack->fd == -1) {
1479 		err = got_error_from_errno("dup");
1480 		goto done;
1481 	}
1482 	if (lseek(pack->fd, 0, SEEK_SET) == -1) {
1483 		err = got_error_from_errno("lseek");
1484 		goto done;
1485 	}
1486 	pack->path_packfile = strdup(ipack.path_packfile);
1487 	if (pack->path_packfile == NULL) {
1488 		err = got_error_from_errno("strdup");
1489 		goto done;
1490 	}
1491 
1492 	err = got_delta_cache_alloc(&pack->delta_cache);
1493 	if (err)
1494 		goto done;
1495 
1496 #ifndef GOT_PACK_NO_MMAP
1497 	pack->map = mmap(NULL, pack->filesize, PROT_READ, MAP_PRIVATE,
1498 	    pack->fd, 0);
1499 	if (pack->map == MAP_FAILED)
1500 		pack->map = NULL; /* fall back to read(2) */
1501 #endif
1502 done:
1503 	if (err) {
1504 		if (imsg.fd != -1)
1505 			close(imsg.fd);
1506 		free(pack);
1507 	} else
1508 		*packp = pack;
1509 	imsg_free(&imsg);
1510 	return err;
1511 }
1512 
1513 int
1514 main(int argc, char *argv[])
1515 {
1516 	const struct got_error *err = NULL;
1517 	struct imsgbuf ibuf;
1518 	struct imsg imsg;
1519 	struct got_packidx *packidx = NULL;
1520 	struct got_pack *pack = NULL;
1521 	struct got_object_cache objcache;
1522 	FILE *basefile = NULL, *accumfile = NULL, *delta_outfile = NULL;
1523 
1524 	//static int attached;
1525 	//while (!attached) sleep(1);
1526 
1527 	signal(SIGINT, catch_sigint);
1528 
1529 	imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
1530 
1531 	err = got_object_cache_init(&objcache, GOT_OBJECT_CACHE_TYPE_OBJ);
1532 	if (err) {
1533 		err = got_error_from_errno("got_object_cache_init");
1534 		got_privsep_send_error(&ibuf, err);
1535 		return 1;
1536 	}
1537 
1538 #ifndef PROFILE
1539 	/* revoke access to most system calls */
1540 	if (pledge("stdio recvfd", NULL) == -1) {
1541 		err = got_error_from_errno("pledge");
1542 		got_privsep_send_error(&ibuf, err);
1543 		return 1;
1544 	}
1545 #endif
1546 
1547 	err = receive_packidx(&packidx, &ibuf);
1548 	if (err) {
1549 		got_privsep_send_error(&ibuf, err);
1550 		return 1;
1551 	}
1552 
1553 	err = receive_pack(&pack, &ibuf);
1554 	if (err) {
1555 		got_privsep_send_error(&ibuf, err);
1556 		return 1;
1557 	}
1558 
1559 	for (;;) {
1560 		imsg.fd = -1;
1561 
1562 		if (sigint_received) {
1563 			err = got_error(GOT_ERR_CANCELLED);
1564 			break;
1565 		}
1566 
1567 		err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
1568 		if (err) {
1569 			if (err->code == GOT_ERR_PRIVSEP_PIPE)
1570 				err = NULL;
1571 			break;
1572 		}
1573 
1574 		if (imsg.hdr.type == GOT_IMSG_STOP)
1575 			break;
1576 
1577 		switch (imsg.hdr.type) {
1578 		case GOT_IMSG_TMPFD:
1579 			if (basefile == NULL) {
1580 				err = receive_tempfile(&basefile, "w+",
1581 				   &imsg, &ibuf);
1582 			} else if (accumfile == NULL) {
1583 				err = receive_tempfile(&accumfile, "w+",
1584 				   &imsg, &ibuf);
1585 			} else
1586 				err = got_error(GOT_ERR_PRIVSEP_MSG);
1587 			break;
1588 		case GOT_IMSG_PACKED_OBJECT_REQUEST:
1589 			err = object_request(&imsg, &ibuf, pack, packidx,
1590 			    &objcache);
1591 			break;
1592 		case GOT_IMSG_PACKED_RAW_OBJECT_REQUEST:
1593 			if (basefile == NULL || accumfile == NULL) {
1594 				err = got_error(GOT_ERR_PRIVSEP_MSG);
1595 				break;
1596 			}
1597 			err = raw_object_request(&imsg, &ibuf, pack, packidx,
1598 			    &objcache, basefile, accumfile);
1599 			break;
1600 		case GOT_IMSG_RAW_DELTA_OUTFD:
1601 			if (delta_outfile != NULL) {
1602 				err = got_error(GOT_ERR_PRIVSEP_MSG);
1603 				break;
1604 			}
1605 			err = receive_tempfile(&delta_outfile, "w",
1606 			    &imsg, &ibuf);
1607 			break;
1608 		case GOT_IMSG_RAW_DELTA_REQUEST:
1609 			if (delta_outfile == NULL) {
1610 				err = got_error(GOT_ERR_PRIVSEP_NO_FD);
1611 				break;
1612 			}
1613 			err = raw_delta_request(&imsg, &ibuf, delta_outfile,
1614 			    pack, packidx);
1615 			break;
1616 		case GOT_IMSG_DELTA_REUSE_REQUEST:
1617 			if (delta_outfile == NULL) {
1618 				err = got_error(GOT_ERR_PRIVSEP_NO_FD);
1619 				break;
1620 			}
1621 			err = delta_reuse_request(&imsg, &ibuf,
1622 			    delta_outfile, pack, packidx);
1623 			break;
1624 		case GOT_IMSG_COMMIT_REQUEST:
1625 			err = commit_request(&imsg, &ibuf, pack, packidx,
1626 			    &objcache);
1627 			break;
1628 		case GOT_IMSG_TREE_REQUEST:
1629 			err = tree_request(&imsg, &ibuf, pack, packidx,
1630 			    &objcache);
1631 			break;
1632 		case GOT_IMSG_BLOB_REQUEST:
1633 			if (basefile == NULL || accumfile == NULL) {
1634 				err = got_error(GOT_ERR_PRIVSEP_MSG);
1635 				break;
1636 			}
1637 			err = blob_request(&imsg, &ibuf, pack, packidx,
1638 			    &objcache, basefile, accumfile);
1639 			break;
1640 		case GOT_IMSG_TAG_REQUEST:
1641 			err = tag_request(&imsg, &ibuf, pack, packidx,
1642 			    &objcache);
1643 			break;
1644 		case GOT_IMSG_COMMIT_TRAVERSAL_REQUEST:
1645 			err = commit_traversal_request(&imsg, &ibuf, pack,
1646 			    packidx, &objcache);
1647 			break;
1648 		case GOT_IMSG_OBJECT_ENUMERATION_REQUEST:
1649 			err = enumeration_request(&imsg, &ibuf, pack,
1650 			    packidx, &objcache);
1651 			break;
1652 		default:
1653 			err = got_error(GOT_ERR_PRIVSEP_MSG);
1654 			break;
1655 		}
1656 
1657 		if (imsg.fd != -1 && close(imsg.fd) == -1 && err == NULL)
1658 			err = got_error_from_errno("close");
1659 		imsg_free(&imsg);
1660 		if (err)
1661 			break;
1662 	}
1663 
1664 	if (packidx)
1665 		got_packidx_close(packidx);
1666 	if (pack)
1667 		got_pack_close(pack);
1668 	got_object_cache_close(&objcache);
1669 	imsg_clear(&ibuf);
1670 	if (basefile && fclose(basefile) == EOF && err == NULL)
1671 		err = got_error_from_errno("fclose");
1672 	if (accumfile && fclose(accumfile) == EOF && err == NULL)
1673 		err = got_error_from_errno("fclose");
1674 	if (delta_outfile && fclose(delta_outfile) == EOF && err == NULL)
1675 		err = got_error_from_errno("fclose");
1676 	if (err) {
1677 		if (!sigint_received && err->code != GOT_ERR_PRIVSEP_PIPE) {
1678 			fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
1679 			got_privsep_send_error(&ibuf, err);
1680 		}
1681 	}
1682 	if (close(GOT_IMSG_FD_CHILD) == -1 && err == NULL)
1683 		err = got_error_from_errno("close");
1684 	return err ? 1 : 0;
1685 }