1 /*
2  * Copyright (c) 2018, 2019, 2022 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/mman.h>
18 #include <sys/queue.h>
19 #include <sys/types.h>
20 #include <sys/stat.h>
21 #include <sys/socket.h>
22 #include <sys/uio.h>
23 
24 #include <errno.h>
25 #include <imsg.h>
26 #include <stdio.h>
27 #include <stdint.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <limits.h>
31 #include <unistd.h>
32 
33 #include "got_compat.h"
34 #include "got_error.h"
35 #include "got_object.h"
36 #include "got_repository.h"
37 #include "got_opentemp.h"
38 #include "got_path.h"
39 
40 #include "got_lib_delta.h"
41 #include "got_lib_object.h"
42 #include "got_lib_privsep.h"
43 #include "got_lib_object_cache.h"
44 #include "got_lib_pack.h"
45 #include "got_lib_repository.h"
46 
47 static const struct got_error *
48 request_packed_object(struct got_object **obj, struct got_pack *pack, int idx,
49     struct got_object_id *id)
50 {
51 	const struct got_error *err = NULL;
52 	struct imsgbuf *ibuf = pack->privsep_child->ibuf;
53 
54 	err = got_privsep_send_packed_obj_req(ibuf, idx, id);
55 	if (err)
56 		return err;
57 
58 	err = got_privsep_recv_obj(obj, ibuf);
59 	if (err)
60 		return err;
61 
62 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
63 
64 	return NULL;
65 }
66 
67 /* Create temporary files used during delta application. */
68 static const struct got_error *
69 pack_child_send_tempfiles(struct imsgbuf *ibuf, struct got_pack *pack)
70 {
71 	const struct got_error *err;
72 	int basefd = -1, accumfd = -1;
73 
74 	/*
75 	 * For performance reasons, the child will keep reusing the
76 	 * same temporary files during every object request.
77 	 * Opening and closing new files for every object request is
78 	 * too expensive during operations such as 'gotadmin pack'.
79 	 */
80 	if (pack->child_has_tempfiles)
81 		return NULL;
82 
83 	basefd = dup(pack->basefd);
84 	if (basefd == -1)
85 		return got_error_from_errno("dup");
86 
87 	accumfd = dup(pack->accumfd);
88 	if (accumfd == -1) {
89 		err = got_error_from_errno("dup");
90 		goto done;
91 	}
92 
93 	err = got_privsep_send_tmpfd(ibuf, basefd);
94 	if (err)
95 		goto done;
96 
97 	err = got_privsep_send_tmpfd(ibuf, accumfd);
98 done:
99 	if (err) {
100 		if (basefd != -1)
101 			close(basefd);
102 		if (accumfd != -1)
103 			close(accumfd);
104 	} else
105 		pack->child_has_tempfiles = 1;
106 	return err;
107 }
108 
109 static const struct got_error *
110 request_packed_object_raw(uint8_t **outbuf, off_t *size, size_t *hdrlen,
111     int outfd, struct got_pack *pack, int idx, struct got_object_id *id)
112 {
113 	const struct got_error *err = NULL;
114 	struct imsgbuf *ibuf = pack->privsep_child->ibuf;
115 	int outfd_child;
116 
117 	 err = pack_child_send_tempfiles(ibuf, pack);
118 	 if (err)
119 		return err;
120 
121 	outfd_child = dup(outfd);
122 	if (outfd_child == -1)
123 		return got_error_from_errno("dup");
124 
125 	err = got_privsep_send_packed_raw_obj_req(ibuf, idx, id);
126 	if (err) {
127 		close(outfd_child);
128 		return err;
129 	}
130 
131 	err = got_privsep_send_raw_obj_outfd(ibuf, outfd_child);
132 	if (err)
133 		return err;
134 
135 	err = got_privsep_recv_raw_obj(outbuf, size, hdrlen, ibuf);
136 	if (err)
137 		return err;
138 
139 	return NULL;
140 }
141 
142 static const struct got_error *
143 read_packed_object_privsep(struct got_object **obj,
144     struct got_repository *repo, struct got_pack *pack,
145     struct got_packidx *packidx, int idx, struct got_object_id *id)
146 {
147 	const struct got_error *err = NULL;
148 
149 	if (pack->privsep_child == NULL) {
150 		err = got_pack_start_privsep_child(pack, packidx);
151 		if (err)
152 			return err;
153 	}
154 
155 	return request_packed_object(obj, pack, idx, id);
156 }
157 
158 static const struct got_error *
159 read_packed_object_raw_privsep(uint8_t **outbuf, off_t *size, size_t *hdrlen,
160     int outfd, struct got_pack *pack, struct got_packidx *packidx, int idx,
161     struct got_object_id *id)
162 {
163 	const struct got_error *err = NULL;
164 
165 	if (pack->privsep_child == NULL) {
166 		err = got_pack_start_privsep_child(pack, packidx);
167 		if (err)
168 			return err;
169 	}
170 
171 	return request_packed_object_raw(outbuf, size, hdrlen, outfd, pack,
172 	    idx, id);
173 }
174 
175 const struct got_error *
176 got_object_open_packed(struct got_object **obj, struct got_object_id *id,
177     struct got_repository *repo)
178 {
179 	const struct got_error *err = NULL;
180 	struct got_pack *pack = NULL;
181 	struct got_packidx *packidx = NULL;
182 	int idx;
183 	char *path_packfile;
184 
185 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
186 	if (err)
187 		return err;
188 
189 	err = got_packidx_get_packfile_path(&path_packfile,
190 	    packidx->path_packidx);
191 	if (err)
192 		return err;
193 
194 	pack = got_repo_get_cached_pack(repo, path_packfile);
195 	if (pack == NULL) {
196 		err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
197 		if (err)
198 			goto done;
199 	}
200 
201 	err = read_packed_object_privsep(obj, repo, pack, packidx, idx, id);
202 	if (err)
203 		goto done;
204 done:
205 	free(path_packfile);
206 	return err;
207 }
208 
209 const struct got_error *
210 got_object_open_from_packfile(struct got_object **obj, struct got_object_id *id,
211     struct got_pack *pack, struct got_packidx *packidx, int obj_idx,
212     struct got_repository *repo)
213 {
214 	return read_packed_object_privsep(obj, repo, pack, packidx,
215 	    obj_idx, id);
216 }
217 
218 const struct got_error *
219 got_object_read_raw_delta(uint64_t *base_size, uint64_t *result_size,
220     off_t *delta_size, off_t *delta_compressed_size, off_t *delta_offset,
221     off_t *delta_out_offset, struct got_object_id **base_id, int delta_cache_fd,
222     struct got_packidx *packidx, int obj_idx, struct got_object_id *id,
223     struct got_repository *repo)
224 {
225 	const struct got_error *err = NULL;
226 	struct got_pack *pack = NULL;
227 	char *path_packfile;
228 
229 	*base_size = 0;
230 	*result_size = 0;
231 	*delta_size = 0;
232 	*delta_compressed_size = 0;
233 	*delta_offset = 0;
234 	*delta_out_offset = 0;
235 
236 	err = got_packidx_get_packfile_path(&path_packfile,
237 	    packidx->path_packidx);
238 	if (err)
239 		return err;
240 
241 	pack = got_repo_get_cached_pack(repo, path_packfile);
242 	if (pack == NULL) {
243 		err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
244 		if (err)
245 			return err;
246 	}
247 
248 	if (pack->privsep_child == NULL) {
249 		err = got_pack_start_privsep_child(pack, packidx);
250 		if (err)
251 			return err;
252 	}
253 
254 	if (!pack->child_has_delta_outfd) {
255 		int outfd_child;
256 		outfd_child = dup(delta_cache_fd);
257 		if (outfd_child == -1)
258 			return got_error_from_errno("dup");
259 		err = got_privsep_send_raw_delta_outfd(
260 		    pack->privsep_child->ibuf, outfd_child);
261 		if (err)
262 			return err;
263 		pack->child_has_delta_outfd = 1;
264 	}
265 
266 	err = got_privsep_send_raw_delta_req(pack->privsep_child->ibuf,
267 	    obj_idx, id);
268 	if (err)
269 		return err;
270 
271 	return got_privsep_recv_raw_delta(base_size, result_size, delta_size,
272 	    delta_compressed_size, delta_offset, delta_out_offset, base_id,
273 	    pack->privsep_child->ibuf);
274 }
275 
276 static const struct got_error *
277 request_object(struct got_object **obj, struct got_object_id *id,
278     struct got_repository *repo, int fd)
279 {
280 	const struct got_error *err = NULL;
281 	struct imsgbuf *ibuf;
282 
283 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
284 
285 	err = got_privsep_send_obj_req(ibuf, fd, id);
286 	if (err)
287 		return err;
288 
289 	return got_privsep_recv_obj(obj, ibuf);
290 }
291 
292 static const struct got_error *
293 request_raw_object(uint8_t **outbuf, off_t *size, size_t *hdrlen, int outfd,
294     struct got_object_id *id, struct got_repository *repo, int infd)
295 {
296 	const struct got_error *err = NULL;
297 	struct imsgbuf *ibuf;
298 	int outfd_child;
299 
300 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
301 
302 	outfd_child = dup(outfd);
303 	if (outfd_child == -1)
304 		return got_error_from_errno("dup");
305 
306 	err = got_privsep_send_raw_obj_req(ibuf, infd, id);
307 	if (err)
308 		return err;
309 
310 	err = got_privsep_send_raw_obj_outfd(ibuf, outfd_child);
311 	if (err)
312 		return err;
313 
314 	return got_privsep_recv_raw_obj(outbuf, size, hdrlen, ibuf);
315 }
316 
317 static const struct got_error *
318 start_child(struct got_repository *repo, int type)
319 {
320 	const struct got_error *err = NULL;
321 	int imsg_fds[2];
322 	pid_t pid;
323 	struct imsgbuf *ibuf;
324 	const char *prog_path;
325 
326 	switch (type) {
327 	case GOT_REPO_PRIVSEP_CHILD_OBJECT:
328 		prog_path = GOT_PATH_PROG_READ_OBJECT;
329 		break;
330 	case GOT_REPO_PRIVSEP_CHILD_TREE:
331 		prog_path = GOT_PATH_PROG_READ_TREE;
332 		break;
333 	case GOT_REPO_PRIVSEP_CHILD_COMMIT:
334 		prog_path = GOT_PATH_PROG_READ_COMMIT;
335 		break;
336 	case GOT_REPO_PRIVSEP_CHILD_BLOB:
337 		prog_path = GOT_PATH_PROG_READ_BLOB;
338 		break;
339 	case GOT_REPO_PRIVSEP_CHILD_TAG:
340 		prog_path = GOT_PATH_PROG_READ_TAG;
341 		break;
342 	default:
343 		return got_error(GOT_ERR_OBJ_TYPE);
344 	}
345 
346 	ibuf = calloc(1, sizeof(*ibuf));
347 	if (ibuf == NULL)
348 		return got_error_from_errno("calloc");
349 
350 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
351 		err = got_error_from_errno("socketpair");
352 		free(ibuf);
353 		return err;
354 	}
355 
356 	pid = fork();
357 	if (pid == -1) {
358 		err = got_error_from_errno("fork");
359 		free(ibuf);
360 		return err;
361 	}
362 	else if (pid == 0) {
363 		got_privsep_exec_child(imsg_fds, prog_path, repo->path);
364 		/* not reached */
365 	}
366 
367 	if (close(imsg_fds[1]) == -1) {
368 		err = got_error_from_errno("close");
369 		free(ibuf);
370 		return err;
371 	}
372 
373 	repo->privsep_children[type].imsg_fd = imsg_fds[0];
374 	repo->privsep_children[type].pid = pid;
375 	imsg_init(ibuf, imsg_fds[0]);
376 	repo->privsep_children[type].ibuf = ibuf;
377 
378 	return NULL;
379 }
380 
381 const struct got_error *
382 got_object_read_header_privsep(struct got_object **obj,
383     struct got_object_id *id, struct got_repository *repo, int obj_fd)
384 {
385 	const struct got_error *err;
386 
387 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
388 		return request_object(obj, id, repo, obj_fd);
389 
390 	err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_OBJECT);
391 	if (err)
392 		return err;
393 
394 	return request_object(obj, id, repo, obj_fd);
395 }
396 
397 static const struct got_error *
398 read_object_raw_privsep(uint8_t **outbuf, off_t *size, size_t *hdrlen,
399     int outfd, struct got_object_id *id, struct got_repository *repo,
400     int obj_fd)
401 {
402 	const struct got_error *err;
403 
404 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
405 		return request_raw_object(outbuf, size, hdrlen, outfd, id,
406 		    repo, obj_fd);
407 
408 	err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_OBJECT);
409 	if (err)
410 		return err;
411 
412 	return request_raw_object(outbuf, size, hdrlen, outfd, id, repo,
413 	    obj_fd);
414 }
415 
416 const struct got_error *
417 got_object_open(struct got_object **obj, struct got_repository *repo,
418     struct got_object_id *id)
419 {
420 	const struct got_error *err = NULL;
421 	int fd;
422 
423 	*obj = got_repo_get_cached_object(repo, id);
424 	if (*obj != NULL) {
425 		(*obj)->refcnt++;
426 		return NULL;
427 	}
428 
429 	err = got_object_open_packed(obj, id, repo);
430 	if (err && err->code != GOT_ERR_NO_OBJ)
431 		return err;
432 	if (*obj) {
433 		(*obj)->refcnt++;
434 		return got_repo_cache_object(repo, id, *obj);
435 	}
436 
437 	err = got_object_open_loose_fd(&fd, id, repo);
438 	if (err) {
439 		if (err->code == GOT_ERR_ERRNO && errno == ENOENT)
440 			err = got_error_no_obj(id);
441 		return err;
442 	}
443 
444 	err = got_object_read_header_privsep(obj, id, repo, fd);
445 	if (err)
446 		return err;
447 
448 	memcpy(&(*obj)->id, id, sizeof(*id));
449 
450 	(*obj)->refcnt++;
451 	return got_repo_cache_object(repo, id, *obj);
452 }
453 
454 /* *outfd must be initialized to -1 by caller */
455 const struct got_error *
456 got_object_raw_open(struct got_raw_object **obj, int *outfd,
457     struct got_repository *repo, struct got_object_id *id)
458 {
459 	const struct got_error *err = NULL;
460 	struct got_packidx *packidx = NULL;
461 	int idx;
462 	uint8_t *outbuf = NULL;
463 	off_t size = 0;
464 	size_t hdrlen = 0;
465 	char *path_packfile = NULL;
466 
467 	*obj = got_repo_get_cached_raw_object(repo, id);
468 	if (*obj != NULL) {
469 		(*obj)->refcnt++;
470 		return NULL;
471 	}
472 
473 	if (*outfd == -1) {
474 		*outfd = got_opentempfd();
475 		if (*outfd == -1)
476 			return got_error_from_errno("got_opentempfd");
477 	}
478 
479 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
480 	if (err == NULL) {
481 		struct got_pack *pack = NULL;
482 
483 		err = got_packidx_get_packfile_path(&path_packfile,
484 		    packidx->path_packidx);
485 		if (err)
486 			goto done;
487 
488 		pack = got_repo_get_cached_pack(repo, path_packfile);
489 		if (pack == NULL) {
490 			err = got_repo_cache_pack(&pack, repo, path_packfile,
491 			    packidx);
492 			if (err)
493 				goto done;
494 		}
495 		err = read_packed_object_raw_privsep(&outbuf, &size, &hdrlen,
496 		    *outfd, pack, packidx, idx, id);
497 		if (err)
498 			goto done;
499 	} else if (err->code == GOT_ERR_NO_OBJ) {
500 		int fd;
501 
502 		err = got_object_open_loose_fd(&fd, id, repo);
503 		if (err)
504 			goto done;
505 		err = read_object_raw_privsep(&outbuf, &size, &hdrlen, *outfd,
506 		    id, repo, fd);
507 		if (err)
508 			goto done;
509 	}
510 
511 	err = got_object_raw_alloc(obj, outbuf, outfd,
512 	    GOT_DELTA_RESULT_SIZE_CACHED_MAX, hdrlen, size);
513 	if (err)
514 		goto done;
515 
516 	err = got_repo_cache_raw_object(repo, id, *obj);
517 done:
518 	free(path_packfile);
519 	if (err) {
520 		if (*obj) {
521 			got_object_raw_close(*obj);
522 			*obj = NULL;
523 		}
524 		free(outbuf);
525 	}
526 	return err;
527 }
528 
529 static const struct got_error *
530 request_packed_commit(struct got_commit_object **commit, struct got_pack *pack,
531     int pack_idx, struct got_object_id *id)
532 {
533 	const struct got_error *err = NULL;
534 
535 	err = got_privsep_send_commit_req(pack->privsep_child->ibuf, -1, id,
536 	    pack_idx);
537 	if (err)
538 		return err;
539 
540 	err = got_privsep_recv_commit(commit, pack->privsep_child->ibuf);
541 	if (err)
542 		return err;
543 
544 	(*commit)->flags |= GOT_COMMIT_FLAG_PACKED;
545 	return NULL;
546 }
547 
548 static const struct got_error *
549 read_packed_commit_privsep(struct got_commit_object **commit,
550     struct got_pack *pack, struct got_packidx *packidx, int idx,
551     struct got_object_id *id)
552 {
553 	const struct got_error *err = NULL;
554 
555 	if (pack->privsep_child)
556 		return request_packed_commit(commit, pack, idx, id);
557 
558 	err = got_pack_start_privsep_child(pack, packidx);
559 	if (err)
560 		return err;
561 
562 	return request_packed_commit(commit, pack, idx, id);
563 }
564 
565 static const struct got_error *
566 request_commit(struct got_commit_object **commit, struct got_repository *repo,
567     int fd, struct got_object_id *id)
568 {
569 	const struct got_error *err = NULL;
570 	struct imsgbuf *ibuf;
571 
572 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf;
573 
574 	err = got_privsep_send_commit_req(ibuf, fd, id, -1);
575 	if (err)
576 		return err;
577 
578 	return got_privsep_recv_commit(commit, ibuf);
579 }
580 
581 static const struct got_error *
582 read_commit_privsep(struct got_commit_object **commit, int obj_fd,
583     struct got_object_id *id, struct got_repository *repo)
584 {
585 	const struct got_error *err;
586 
587 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd != -1)
588 		return request_commit(commit, repo, obj_fd, id);
589 
590 	err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_COMMIT);
591 	if (err)
592 		return err;
593 
594 	return request_commit(commit, repo, obj_fd, id);
595 }
596 
597 static const struct got_error *
598 open_commit(struct got_commit_object **commit,
599     struct got_repository *repo, struct got_object_id *id, int check_cache)
600 {
601 	const struct got_error *err = NULL;
602 	struct got_packidx *packidx = NULL;
603 	int idx;
604 	char *path_packfile = NULL;
605 
606 	if (check_cache) {
607 		*commit = got_repo_get_cached_commit(repo, id);
608 		if (*commit != NULL) {
609 			(*commit)->refcnt++;
610 			return NULL;
611 		}
612 	} else
613 		*commit = NULL;
614 
615 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
616 	if (err == NULL) {
617 		struct got_pack *pack = NULL;
618 
619 		err = got_packidx_get_packfile_path(&path_packfile,
620 		    packidx->path_packidx);
621 		if (err)
622 			return err;
623 
624 		pack = got_repo_get_cached_pack(repo, path_packfile);
625 		if (pack == NULL) {
626 			err = got_repo_cache_pack(&pack, repo, path_packfile,
627 			    packidx);
628 			if (err)
629 				goto done;
630 		}
631 		err = read_packed_commit_privsep(commit, pack,
632 		    packidx, idx, id);
633 	} else if (err->code == GOT_ERR_NO_OBJ) {
634 		int fd;
635 
636 		err = got_object_open_loose_fd(&fd, id, repo);
637 		if (err)
638 			return err;
639 		err = read_commit_privsep(commit, fd, id, repo);
640 	}
641 
642 	if (err == NULL) {
643 		(*commit)->refcnt++;
644 		err = got_repo_cache_commit(repo, id, *commit);
645 	}
646 done:
647 	free(path_packfile);
648 	return err;
649 }
650 
651 const struct got_error *
652 got_object_open_as_commit(struct got_commit_object **commit,
653     struct got_repository *repo, struct got_object_id *id)
654 {
655 	*commit = got_repo_get_cached_commit(repo, id);
656 	if (*commit != NULL) {
657 		(*commit)->refcnt++;
658 		return NULL;
659 	}
660 
661 	return open_commit(commit, repo, id, 0);
662 }
663 
664 const struct got_error *
665 got_object_commit_open(struct got_commit_object **commit,
666     struct got_repository *repo, struct got_object *obj)
667 {
668 	return open_commit(commit, repo, got_object_get_id(obj), 1);
669 }
670 
671 static const struct got_error *
672 request_packed_tree(struct got_tree_object **tree, struct got_pack *pack,
673     int pack_idx, struct got_object_id *id)
674 {
675 	const struct got_error *err = NULL;
676 
677 	err = got_privsep_send_tree_req(pack->privsep_child->ibuf, -1, id,
678 	    pack_idx);
679 	if (err)
680 		return err;
681 
682 	return got_privsep_recv_tree(tree, pack->privsep_child->ibuf);
683 }
684 
685 static const struct got_error *
686 read_packed_tree_privsep(struct got_tree_object **tree,
687     struct got_pack *pack, struct got_packidx *packidx, int idx,
688     struct got_object_id *id)
689 {
690 	const struct got_error *err = NULL;
691 
692 	if (pack->privsep_child)
693 		return request_packed_tree(tree, pack, idx, id);
694 
695 	err = got_pack_start_privsep_child(pack, packidx);
696 	if (err)
697 		return err;
698 
699 	return request_packed_tree(tree, pack, idx, id);
700 }
701 
702 static const struct got_error *
703 request_tree(struct got_tree_object **tree, struct got_repository *repo,
704     int fd, struct got_object_id *id)
705 {
706 	const struct got_error *err = NULL;
707 	struct imsgbuf *ibuf;
708 
709 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf;
710 
711 	err = got_privsep_send_tree_req(ibuf, fd, id, -1);
712 	if (err)
713 		return err;
714 
715 	return got_privsep_recv_tree(tree, ibuf);
716 }
717 
718 static const struct got_error *
719 read_tree_privsep(struct got_tree_object **tree, int obj_fd,
720     struct got_object_id *id, struct got_repository *repo)
721 {
722 	const struct got_error *err;
723 
724 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd != -1)
725 		return request_tree(tree, repo, obj_fd, id);
726 
727 	err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_TREE);
728 	if (err)
729 		return err;
730 
731 	return request_tree(tree, repo, obj_fd, id);
732 }
733 
734 static const struct got_error *
735 open_tree(struct got_tree_object **tree, struct got_repository *repo,
736     struct got_object_id *id, int check_cache)
737 {
738 	const struct got_error *err = NULL;
739 	struct got_packidx *packidx = NULL;
740 	int idx;
741 	char *path_packfile = NULL;
742 
743 	if (check_cache) {
744 		*tree = got_repo_get_cached_tree(repo, id);
745 		if (*tree != NULL) {
746 			(*tree)->refcnt++;
747 			return NULL;
748 		}
749 	} else
750 		*tree = NULL;
751 
752 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
753 	if (err == NULL) {
754 		struct got_pack *pack = NULL;
755 
756 		err = got_packidx_get_packfile_path(&path_packfile,
757 		    packidx->path_packidx);
758 		if (err)
759 			return err;
760 
761 		pack = got_repo_get_cached_pack(repo, path_packfile);
762 		if (pack == NULL) {
763 			err = got_repo_cache_pack(&pack, repo, path_packfile,
764 			    packidx);
765 			if (err)
766 				goto done;
767 		}
768 		err = read_packed_tree_privsep(tree, pack,
769 		    packidx, idx, id);
770 	} else if (err->code == GOT_ERR_NO_OBJ) {
771 		int fd;
772 
773 		err = got_object_open_loose_fd(&fd, id, repo);
774 		if (err)
775 			return err;
776 		err = read_tree_privsep(tree, fd, id, repo);
777 	}
778 
779 	if (err == NULL) {
780 		(*tree)->refcnt++;
781 		err = got_repo_cache_tree(repo, id, *tree);
782 	}
783 done:
784 	free(path_packfile);
785 	return err;
786 }
787 
788 const struct got_error *
789 got_object_open_as_tree(struct got_tree_object **tree,
790     struct got_repository *repo, struct got_object_id *id)
791 {
792 	*tree = got_repo_get_cached_tree(repo, id);
793 	if (*tree != NULL) {
794 		(*tree)->refcnt++;
795 		return NULL;
796 	}
797 
798 	return open_tree(tree, repo, id, 0);
799 }
800 
801 const struct got_error *
802 got_object_tree_open(struct got_tree_object **tree,
803     struct got_repository *repo, struct got_object *obj)
804 {
805 	return open_tree(tree, repo, got_object_get_id(obj), 1);
806 }
807 
808 static const struct got_error *
809 request_packed_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen, int outfd,
810     struct got_pack *pack, struct got_packidx *packidx, int idx,
811     struct got_object_id *id)
812 {
813 	const struct got_error *err = NULL;
814 	struct imsgbuf *ibuf = pack->privsep_child->ibuf;
815 	int outfd_child;
816 
817 	 err = pack_child_send_tempfiles(ibuf, pack);
818 	 if (err)
819 		return err;
820 
821 	outfd_child = dup(outfd);
822 	if (outfd_child == -1)
823 		return got_error_from_errno("dup");
824 
825 	err = got_privsep_send_blob_req(pack->privsep_child->ibuf, -1, id, idx);
826 	if (err)
827 		return err;
828 
829 	err = got_privsep_send_blob_outfd(pack->privsep_child->ibuf,
830 	    outfd_child);
831 	if (err) {
832 		return err;
833 	}
834 
835 	err = got_privsep_recv_blob(outbuf, size, hdrlen,
836 	    pack->privsep_child->ibuf);
837 	if (err)
838 		return err;
839 
840 	if (lseek(outfd, SEEK_SET, 0) == -1)
841 		err = got_error_from_errno("lseek");
842 
843 	return err;
844 }
845 
846 static const struct got_error *
847 read_packed_blob_privsep(uint8_t **outbuf, size_t *size, size_t *hdrlen,
848     int outfd, struct got_pack *pack, struct got_packidx *packidx, int idx,
849     struct got_object_id *id)
850 {
851 	const struct got_error *err = NULL;
852 
853 	if (pack->privsep_child == NULL) {
854 		err = got_pack_start_privsep_child(pack, packidx);
855 		if (err)
856 			return err;
857 	}
858 
859 	return request_packed_blob(outbuf, size, hdrlen, outfd, pack, packidx,
860 	    idx, id);
861 }
862 
863 static const struct got_error *
864 request_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen, int outfd,
865     int infd, struct got_object_id *id, struct imsgbuf *ibuf)
866 {
867 	const struct got_error *err = NULL;
868 	int outfd_child;
869 
870 	outfd_child = dup(outfd);
871 	if (outfd_child == -1)
872 		return got_error_from_errno("dup");
873 
874 	err = got_privsep_send_blob_req(ibuf, infd, id, -1);
875 	if (err)
876 		return err;
877 
878 	err = got_privsep_send_blob_outfd(ibuf, outfd_child);
879 	if (err)
880 		return err;
881 
882 	err = got_privsep_recv_blob(outbuf, size, hdrlen, ibuf);
883 	if (err)
884 		return err;
885 
886 	if (lseek(outfd, SEEK_SET, 0) == -1)
887 		return got_error_from_errno("lseek");
888 
889 	return err;
890 }
891 
892 static const struct got_error *
893 read_blob_privsep(uint8_t **outbuf, size_t *size, size_t *hdrlen,
894     int outfd, int infd, struct got_object_id *id, struct got_repository *repo)
895 {
896 	const struct got_error *err;
897 	struct imsgbuf *ibuf;
898 
899 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd != -1) {
900 		ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
901 		return request_blob(outbuf, size, hdrlen, outfd, infd, id,
902 		    ibuf);
903 	}
904 
905 	err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_BLOB);
906 	if (err)
907 		return err;
908 
909 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
910 	return request_blob(outbuf, size, hdrlen, outfd, infd, id, ibuf);
911 }
912 
913 static const struct got_error *
914 open_blob(struct got_blob_object **blob, struct got_repository *repo,
915     struct got_object_id *id, size_t blocksize, int outfd)
916 {
917 	const struct got_error *err = NULL;
918 	struct got_packidx *packidx = NULL;
919 	int idx, dfd = -1;
920 	char *path_packfile = NULL;
921 	uint8_t *outbuf;
922 	size_t size, hdrlen;
923 	struct stat sb;
924 
925 	*blob = calloc(1, sizeof(**blob));
926 	if (*blob == NULL)
927 		return got_error_from_errno("calloc");
928 
929 	(*blob)->read_buf = malloc(blocksize);
930 	if ((*blob)->read_buf == NULL) {
931 		err = got_error_from_errno("malloc");
932 		goto done;
933 	}
934 
935 	if (ftruncate(outfd, 0L) == -1) {
936 		err = got_error_from_errno("ftruncate");
937 		goto done;
938 	}
939 	if (lseek(outfd, SEEK_SET, 0) == -1) {
940 		err = got_error_from_errno("lseek");
941 		goto done;
942 	}
943 
944 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
945 	if (err == NULL) {
946 		struct got_pack *pack = NULL;
947 
948 		err = got_packidx_get_packfile_path(&path_packfile,
949 		    packidx->path_packidx);
950 		if (err)
951 			goto done;
952 
953 		pack = got_repo_get_cached_pack(repo, path_packfile);
954 		if (pack == NULL) {
955 			err = got_repo_cache_pack(&pack, repo, path_packfile,
956 			    packidx);
957 			if (err)
958 				goto done;
959 		}
960 		err = read_packed_blob_privsep(&outbuf, &size, &hdrlen, outfd,
961 		    pack, packidx, idx, id);
962 	} else if (err->code == GOT_ERR_NO_OBJ) {
963 		int infd;
964 
965 		err = got_object_open_loose_fd(&infd, id, repo);
966 		if (err)
967 			goto done;
968 		err = read_blob_privsep(&outbuf, &size, &hdrlen, outfd, infd,
969 		    id, repo);
970 	}
971 	if (err)
972 		goto done;
973 
974 	if (hdrlen > size) {
975 		err = got_error(GOT_ERR_BAD_OBJ_HDR);
976 		goto done;
977 	}
978 
979 	if (outbuf) {
980 		(*blob)->f = fmemopen(outbuf, size, "rb");
981 		if ((*blob)->f == NULL) {
982 			err = got_error_from_errno("fmemopen");
983 			free(outbuf);
984 			goto done;
985 		}
986 		(*blob)->data = outbuf;
987 	} else {
988 		if (fstat(outfd, &sb) == -1) {
989 			err = got_error_from_errno("fstat");
990 			goto done;
991 		}
992 
993 		if (sb.st_size != size) {
994 			err = got_error(GOT_ERR_PRIVSEP_LEN);
995 			goto done;
996 		}
997 
998 		dfd = dup(outfd);
999 		if (dfd == -1) {
1000 			err = got_error_from_errno("dup");
1001 			goto done;
1002 		}
1003 
1004 		(*blob)->f = fdopen(dfd, "rb");
1005 		if ((*blob)->f == NULL) {
1006 			err = got_error_from_errno("fdopen");
1007 			close(dfd);
1008 			dfd = -1;
1009 			goto done;
1010 		}
1011 	}
1012 
1013 	(*blob)->hdrlen = hdrlen;
1014 	(*blob)->blocksize = blocksize;
1015 	memcpy(&(*blob)->id, id, sizeof(*id));
1016 
1017 done:
1018 	free(path_packfile);
1019 	if (err) {
1020 		if (*blob) {
1021 			got_object_blob_close(*blob);
1022 			*blob = NULL;
1023 		}
1024 	}
1025 	return err;
1026 }
1027 
1028 const struct got_error *
1029 got_object_open_as_blob(struct got_blob_object **blob,
1030     struct got_repository *repo, struct got_object_id *id, size_t blocksize,
1031     int outfd)
1032 {
1033 	return open_blob(blob, repo, id, blocksize, outfd);
1034 }
1035 
1036 const struct got_error *
1037 got_object_blob_open(struct got_blob_object **blob,
1038     struct got_repository *repo, struct got_object *obj, size_t blocksize,
1039     int outfd)
1040 {
1041 	return open_blob(blob, repo, got_object_get_id(obj), blocksize, outfd);
1042 }
1043 
1044 static const struct got_error *
1045 request_packed_tag(struct got_tag_object **tag, struct got_pack *pack,
1046     int pack_idx, struct got_object_id *id)
1047 {
1048 	const struct got_error *err = NULL;
1049 
1050 	err = got_privsep_send_tag_req(pack->privsep_child->ibuf, -1, id,
1051 	    pack_idx);
1052 	if (err)
1053 		return err;
1054 
1055 	return got_privsep_recv_tag(tag, pack->privsep_child->ibuf);
1056 }
1057 
1058 static const struct got_error *
1059 read_packed_tag_privsep(struct got_tag_object **tag,
1060     struct got_pack *pack, struct got_packidx *packidx, int idx,
1061     struct got_object_id *id)
1062 {
1063 	const struct got_error *err = NULL;
1064 
1065 	if (pack->privsep_child)
1066 		return request_packed_tag(tag, pack, idx, id);
1067 
1068 	err = got_pack_start_privsep_child(pack, packidx);
1069 	if (err)
1070 		return err;
1071 
1072 	return request_packed_tag(tag, pack, idx, id);
1073 }
1074 
1075 static const struct got_error *
1076 request_tag(struct got_tag_object **tag, struct got_repository *repo,
1077     int fd, struct got_object_id *id)
1078 {
1079 	const struct got_error *err = NULL;
1080 	struct imsgbuf *ibuf;
1081 
1082 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].ibuf;
1083 
1084 	err = got_privsep_send_tag_req(ibuf, fd, id, -1);
1085 	if (err)
1086 		return err;
1087 
1088 	return got_privsep_recv_tag(tag, ibuf);
1089 }
1090 
1091 static const struct got_error *
1092 read_tag_privsep(struct got_tag_object **tag, int obj_fd,
1093     struct got_object_id *id, struct got_repository *repo)
1094 {
1095 	const struct got_error *err;
1096 
1097 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].imsg_fd != -1)
1098 		return request_tag(tag, repo, obj_fd, id);
1099 
1100 	err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_TAG);
1101 	if (err)
1102 		return err;
1103 
1104 	return request_tag(tag, repo, obj_fd, id);
1105 }
1106 
1107 static const struct got_error *
1108 open_tag(struct got_tag_object **tag, struct got_repository *repo,
1109     struct got_object_id *id, int check_cache)
1110 {
1111 	const struct got_error *err = NULL;
1112 	struct got_packidx *packidx = NULL;
1113 	int idx;
1114 	char *path_packfile = NULL;
1115 	struct got_object *obj = NULL;
1116 	int obj_type = GOT_OBJ_TYPE_ANY;
1117 
1118 	if (check_cache) {
1119 		*tag = got_repo_get_cached_tag(repo, id);
1120 		if (*tag != NULL) {
1121 			(*tag)->refcnt++;
1122 			return NULL;
1123 		}
1124 	} else
1125 		*tag = NULL;
1126 
1127 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
1128 	if (err == NULL) {
1129 		struct got_pack *pack = NULL;
1130 
1131 		err = got_packidx_get_packfile_path(&path_packfile,
1132 		    packidx->path_packidx);
1133 		if (err)
1134 			return err;
1135 
1136 		pack = got_repo_get_cached_pack(repo, path_packfile);
1137 		if (pack == NULL) {
1138 			err = got_repo_cache_pack(&pack, repo, path_packfile,
1139 			    packidx);
1140 			if (err)
1141 				goto done;
1142 		}
1143 
1144 		/* Beware of "lightweight" tags: Check object type first. */
1145 		err = read_packed_object_privsep(&obj, repo, pack, packidx,
1146 		    idx, id);
1147 		if (err)
1148 			goto done;
1149 		obj_type = obj->type;
1150 		got_object_close(obj);
1151 		if (obj_type != GOT_OBJ_TYPE_TAG) {
1152 			err = got_error(GOT_ERR_OBJ_TYPE);
1153 			goto done;
1154 		}
1155 		err = read_packed_tag_privsep(tag, pack, packidx, idx, id);
1156 	} else if (err->code == GOT_ERR_NO_OBJ) {
1157 		int fd;
1158 
1159 		err = got_object_open_loose_fd(&fd, id, repo);
1160 		if (err)
1161 			return err;
1162 		err = got_object_read_header_privsep(&obj, id, repo, fd);
1163 		if (err)
1164 			return err;
1165 		obj_type = obj->type;
1166 		got_object_close(obj);
1167 		if (obj_type != GOT_OBJ_TYPE_TAG)
1168 			return got_error(GOT_ERR_OBJ_TYPE);
1169 
1170 		err = got_object_open_loose_fd(&fd, id, repo);
1171 		if (err)
1172 			return err;
1173 		err = read_tag_privsep(tag, fd, id, repo);
1174 	}
1175 
1176 	if (err == NULL) {
1177 		(*tag)->refcnt++;
1178 		err = got_repo_cache_tag(repo, id, *tag);
1179 	}
1180 done:
1181 	free(path_packfile);
1182 	return err;
1183 }
1184 
1185 const struct got_error *
1186 got_object_open_as_tag(struct got_tag_object **tag,
1187     struct got_repository *repo, struct got_object_id *id)
1188 {
1189 	*tag = got_repo_get_cached_tag(repo, id);
1190 	if (*tag != NULL) {
1191 		(*tag)->refcnt++;
1192 		return NULL;
1193 	}
1194 
1195 	return open_tag(tag, repo, id, 0);
1196 }
1197 
1198 const struct got_error *
1199 got_object_tag_open(struct got_tag_object **tag,
1200     struct got_repository *repo, struct got_object *obj)
1201 {
1202 	return open_tag(tag, repo, got_object_get_id(obj), 1);
1203 }
1204 
1205 const struct got_error *
1206 got_traverse_packed_commits(struct got_object_id_queue *traversed_commits,
1207     struct got_object_id *commit_id, const char *path,
1208     struct got_repository *repo)
1209 {
1210 	const struct got_error *err = NULL;
1211 	struct got_pack *pack = NULL;
1212 	struct got_packidx *packidx = NULL;
1213 	char *path_packfile = NULL;
1214 	struct got_commit_object *changed_commit = NULL;
1215 	struct got_object_id *changed_commit_id = NULL;
1216 	int idx;
1217 
1218 	err = got_repo_search_packidx(&packidx, &idx, repo, commit_id);
1219 	if (err) {
1220 		if (err->code != GOT_ERR_NO_OBJ)
1221 			return err;
1222 		return NULL;
1223 	}
1224 
1225 	err = got_packidx_get_packfile_path(&path_packfile,
1226 	    packidx->path_packidx);
1227 	if (err)
1228 		return err;
1229 
1230 	pack = got_repo_get_cached_pack(repo, path_packfile);
1231 	if (pack == NULL) {
1232 		err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
1233 		if (err)
1234 			goto done;
1235 	}
1236 
1237 	if (pack->privsep_child == NULL) {
1238 		err = got_pack_start_privsep_child(pack, packidx);
1239 		if (err)
1240 			goto done;
1241 	}
1242 
1243 	err = got_privsep_send_commit_traversal_request(
1244 	    pack->privsep_child->ibuf, commit_id, idx, path);
1245 	if (err)
1246 		goto done;
1247 
1248 	err = got_privsep_recv_traversed_commits(&changed_commit,
1249 	    &changed_commit_id, traversed_commits, pack->privsep_child->ibuf);
1250 	if (err)
1251 		goto done;
1252 
1253 	if (changed_commit) {
1254 		/*
1255 		 * Cache the commit in which the path was changed.
1256 		 * This commit might be opened again soon.
1257 		 */
1258 		changed_commit->refcnt++;
1259 		err = got_repo_cache_commit(repo, changed_commit_id,
1260 		    changed_commit);
1261 		got_object_commit_close(changed_commit);
1262 	}
1263 done:
1264 	free(path_packfile);
1265 	free(changed_commit_id);
1266 	return err;
1267 }
1268 
1269 const struct got_error *
1270 got_object_enumerate(int *found_all_objects,
1271     got_object_enumerate_commit_cb cb_commit,
1272     got_object_enumerate_tree_cb cb_tree, void *cb_arg,
1273     struct got_object_id **ours, int nours,
1274     struct got_object_id **theirs, int ntheirs,
1275     struct got_packidx *packidx, struct got_repository *repo)
1276 {
1277 	const struct got_error *err = NULL;
1278 	struct got_pack *pack;
1279 	char *path_packfile = NULL;
1280 
1281 	err = got_packidx_get_packfile_path(&path_packfile,
1282 	    packidx->path_packidx);
1283 	if (err)
1284 		return err;
1285 
1286 	pack = got_repo_get_cached_pack(repo, path_packfile);
1287 	if (pack == NULL) {
1288 		err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
1289 		if (err)
1290 			goto done;
1291 	}
1292 
1293 	if (pack->privsep_child == NULL) {
1294 		err = got_pack_start_privsep_child(pack, packidx);
1295 		if (err)
1296 			goto done;
1297 	}
1298 
1299 	err = got_privsep_send_object_enumeration_request(
1300 	    pack->privsep_child->ibuf);
1301 	if (err)
1302 		goto done;
1303 
1304 	err = got_privsep_send_object_idlist(pack->privsep_child->ibuf,
1305 	    ours, nours);
1306 	if (err)
1307 		goto done;
1308 	err = got_privsep_send_object_idlist_done(pack->privsep_child->ibuf);
1309 	if (err)
1310 		goto done;
1311 
1312 	err = got_privsep_send_object_idlist(pack->privsep_child->ibuf,
1313 	    theirs, ntheirs);
1314 	if (err)
1315 		goto done;
1316 	err = got_privsep_send_object_idlist_done(pack->privsep_child->ibuf);
1317 	if (err)
1318 		goto done;
1319 
1320 	err = got_privsep_recv_enumerated_objects(found_all_objects,
1321 	    pack->privsep_child->ibuf, cb_commit, cb_tree, cb_arg, repo);
1322 done:
1323 	free(path_packfile);
1324 	return err;
1325 }