Got Mirror

Blob

Date:: Mon Nov 5 22:23:23 2018 UTC
Message:: no need to zero path during allocation in get_packfile_path()
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <sys/queue.h>
20 #include <sys/uio.h>
21 #include <sys/socket.h>
22 #include <sys/wait.h>
23 #include <sys/syslimits.h>
24 
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <stdint.h>
31 #include <sha1.h>
32 #include <zlib.h>
33 #include <ctype.h>
34 #include <limits.h>
35 #include <imsg.h>
36 #include <time.h>
37 
38 #include "got_error.h"
39 #include "got_object.h"
40 #include "got_repository.h"
41 #include "got_opentemp.h"
42 
43 #include "got_lib_sha1.h"
44 #include "got_lib_delta.h"
45 #include "got_lib_pack.h"
46 #include "got_lib_path.h"
47 #include "got_lib_inflate.h"
48 #include "got_lib_object.h"
49 #include "got_lib_privsep.h"
50 #include "got_lib_object_idcache.h"
51 #include "got_lib_object_cache.h"
52 #include "got_lib_object_parse.h"
53 #include "got_lib_repository.h"
54 
55 #ifndef MIN
56 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
57 #endif
58 
59 struct got_object_id *
60 got_object_id_dup(struct got_object_id *id1)
61 {
62 	struct got_object_id *id2;
63 
64 	id2 = malloc(sizeof(*id2));
65 	if (id2 == NULL)
66 		return NULL;
67 	memcpy(id2, id1, sizeof(*id2));
68 	return id2;
69 }
70 
71 struct got_object_id *
72 got_object_get_id(struct got_object *obj)
73 {
74 	return &obj->id;
75 }
76 
77 const struct got_error *
78 got_object_get_id_str(char **outbuf, struct got_object *obj)
79 {
80 	return got_object_id_str(outbuf, &obj->id);
81 }
82 
83 int
84 got_object_get_type(struct got_object *obj)
85 {
86 	switch (obj->type) {
87 	case GOT_OBJ_TYPE_COMMIT:
88 	case GOT_OBJ_TYPE_TREE:
89 	case GOT_OBJ_TYPE_BLOB:
90 	case GOT_OBJ_TYPE_TAG:
91 		return obj->type;
92 	default:
93 		abort();
94 		break;
95 	}
96 
97 	/* not reached */
98 	return 0;
99 }
100 
101 static const struct got_error *
102 object_path(char **path, struct got_object_id *id, struct got_repository *repo)
103 {
104 	const struct got_error *err = NULL;
105 	char *hex = NULL;
106 	char *path_objects = got_repo_get_path_objects(repo);
107 
108 	*path = NULL;
109 
110 	if (path_objects == NULL)
111 		return got_error_from_errno();
112 
113 	err = got_object_id_str(&hex, id);
114 	if (err)
115 		goto done;
116 
117 	if (asprintf(path, "%s/%.2x/%s", path_objects,
118 	    id->sha1[0], hex + 2) == -1)
119 		err = got_error_from_errno();
120 
121 done:
122 	free(hex);
123 	free(path_objects);
124 	return err;
125 }
126 
127 static const struct got_error *
128 open_loose_object(int *fd, struct got_object *obj, struct got_repository *repo)
129 {
130 	const struct got_error *err = NULL;
131 	char *path;
132 
133 	err = object_path(&path, &obj->id, repo);
134 	if (err)
135 		return err;
136 	*fd = open(path, O_RDONLY | O_NOFOLLOW, GOT_DEFAULT_FILE_MODE);
137 	if (*fd == -1) {
138 		err = got_error_from_errno();
139 		goto done;
140 	}
141 done:
142 	free(path);
143 	return err;
144 }
145 
146 static const struct got_error *
147 get_packfile_path(char **path_packfile, struct got_packidx *packidx)
148 {
149 	size_t size;
150 
151 	/* Packfile path contains ".pack" instead of ".idx", so add one byte. */
152 	size = strlen(packidx->path_packidx) + 2;
153 	if (size < GOT_PACKFILE_NAMELEN + 1)
154 		return got_error(GOT_ERR_BAD_PATH);
155 
156 	*path_packfile = malloc(size);
157 	if (*path_packfile == NULL)
158 		return got_error_from_errno();
159 
160 	/* Copy up to and excluding ".idx". */
161 	if (strlcpy(*path_packfile, packidx->path_packidx,
162 	    size - strlen(GOT_PACKIDX_SUFFIX) - 1) >= size)
163 		return got_error(GOT_ERR_NO_SPACE);
164 
165 	if (strlcat(*path_packfile, GOT_PACKFILE_SUFFIX, size) >= size)
166 		return got_error(GOT_ERR_NO_SPACE);
167 
168 	return NULL;
169 }
170 
171 static const struct got_error *
172 open_packed_object(struct got_object **obj, struct got_object_id *id,
173     struct got_repository *repo)
174 {
175 	const struct got_error *err = NULL;
176 	struct got_pack *pack = NULL;
177 	struct got_packidx *packidx = NULL;
178 	int idx;
179 	char *path_packfile;
180 
181 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
182 	if (err)
183 		return err;
184 
185 	err = get_packfile_path(&path_packfile, packidx);
186 	if (err)
187 		return err;
188 
189 	pack = got_repo_get_cached_pack(repo, path_packfile);
190 	if (pack == NULL) {
191 		err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
192 		if (err)
193 			goto done;
194 	}
195 
196 	err = got_object_packed_read_privsep(obj, repo, pack, packidx, idx, id);
197 	if (err)
198 		goto done;
199 
200 	err = got_repo_cache_pack(NULL, repo, (*obj)->path_packfile, packidx);
201 done:
202 	free(path_packfile);
203 	return err;
204 }
205 
206 const struct got_error *
207 got_object_open(struct got_object **obj, struct got_repository *repo,
208     struct got_object_id *id)
209 {
210 	const struct got_error *err = NULL;
211 	char *path;
212 	int fd;
213 
214 	*obj = got_repo_get_cached_object(repo, id);
215 	if (*obj != NULL) {
216 		(*obj)->refcnt++;
217 		return NULL;
218 	}
219 
220 	err = open_packed_object(obj, id, repo);
221 	if (err && err->code != GOT_ERR_NO_OBJ)
222 		return err;
223 	if (*obj) {
224 		(*obj)->refcnt++;
225 		return got_repo_cache_object(repo, id, *obj);
226 	}
227 
228 	err = object_path(&path, id, repo);
229 	if (err)
230 		return err;
231 
232 	fd = open(path, O_RDONLY | O_NOFOLLOW, GOT_DEFAULT_FILE_MODE);
233 	if (fd == -1) {
234 		if (errno == ENOENT)
235 			err = got_error(GOT_ERR_NO_OBJ);
236 		else
237 			err = got_error_from_errno();
238 		goto done;
239 	} else {
240 		err = got_object_read_header_privsep(obj, repo, fd);
241 		if (err)
242 			goto done;
243 		memcpy((*obj)->id.sha1, id->sha1, SHA1_DIGEST_LENGTH);
244 	}
245 
246 	(*obj)->refcnt++;
247 	err = got_repo_cache_object(repo, id, *obj);
248 done:
249 	free(path);
250 	if (fd != -1)
251 		close(fd);
252 	return err;
253 
254 }
255 
256 const struct got_error *
257 got_object_open_by_id_str(struct got_object **obj, struct got_repository *repo,
258     const char *id_str)
259 {
260 	struct got_object_id id;
261 
262 	if (!got_parse_sha1_digest(id.sha1, id_str))
263 		return got_error(GOT_ERR_BAD_OBJ_ID_STR);
264 
265 	return got_object_open(obj, repo, &id);
266 }
267 
268 static const struct got_error *
269 open_commit(struct got_commit_object **commit,
270     struct got_repository *repo, struct got_object *obj, int check_cache)
271 {
272 	const struct got_error *err = NULL;
273 
274 	if (check_cache) {
275 		*commit = got_repo_get_cached_commit(repo, &obj->id);
276 		if (*commit != NULL) {
277 			(*commit)->refcnt++;
278 			return NULL;
279 		}
280 	} else
281 		*commit = NULL;
282 
283 	if (obj->type != GOT_OBJ_TYPE_COMMIT)
284 		return got_error(GOT_ERR_OBJ_TYPE);
285 
286 	if (obj->flags & GOT_OBJ_FLAG_PACKED) {
287 		struct got_pack *pack;
288 		pack = got_repo_get_cached_pack(repo, obj->path_packfile);
289 		if (pack == NULL) {
290 			err = got_repo_cache_pack(&pack, repo,
291 			    obj->path_packfile, NULL);
292 			if (err)
293 				return err;
294 		}
295 		err = got_object_read_packed_commit_privsep(commit, obj, pack);
296 	} else {
297 		int fd;
298 		err = open_loose_object(&fd, obj, repo);
299 		if (err)
300 			return err;
301 		err = got_object_read_commit_privsep(commit, obj, fd, repo);
302 		close(fd);
303 	}
304 
305 	if (err == NULL) {
306 		(*commit)->refcnt++;
307 		err = got_repo_cache_commit(repo, &obj->id, *commit);
308 	}
309 
310 	return err;
311 }
312 
313 const struct got_error *
314 got_object_open_as_commit(struct got_commit_object **commit,
315     struct got_repository *repo, struct got_object_id *id)
316 {
317 	const struct got_error *err;
318 	struct got_object *obj;
319 
320 	*commit = got_repo_get_cached_commit(repo, id);
321 	if (*commit != NULL) {
322 		(*commit)->refcnt++;
323 		return NULL;
324 	}
325 
326 	err = got_object_open(&obj, repo, id);
327 	if (err)
328 		return err;
329 	if (got_object_get_type(obj) != GOT_OBJ_TYPE_COMMIT) {
330 		err = got_error(GOT_ERR_OBJ_TYPE);
331 		goto done;
332 	}
333 
334 	err = open_commit(commit, repo, obj, 0);
335 done:
336 	got_object_close(obj);
337 	return err;
338 }
339 
340 const struct got_error *
341 got_object_commit_open(struct got_commit_object **commit,
342     struct got_repository *repo, struct got_object *obj)
343 {
344 	return open_commit(commit, repo, obj, 1);
345 }
346 
347 const struct got_error *
348 got_object_qid_alloc(struct got_object_qid **qid, struct got_object_id *id)
349 {
350 	const struct got_error *err = NULL;
351 
352 	*qid = calloc(1, sizeof(**qid));
353 	if (*qid == NULL)
354 		return got_error_from_errno();
355 
356 	(*qid)->id = got_object_id_dup(id);
357 	if ((*qid)->id == NULL) {
358 		err = got_error_from_errno();
359 		got_object_qid_free(*qid);
360 		*qid = NULL;
361 		return err;
362 	}
363 
364 	return NULL;
365 }
366 
367 static const struct got_error *
368 open_tree(struct got_tree_object **tree,
369     struct got_repository *repo, struct got_object *obj, int check_cache)
370 {
371 	const struct got_error *err = NULL;
372 
373 	if (check_cache) {
374 		*tree = got_repo_get_cached_tree(repo, &obj->id);
375 		if (*tree != NULL) {
376 			(*tree)->refcnt++;
377 			return NULL;
378 		}
379 	} else
380 		*tree = NULL;
381 
382 	if (obj->type != GOT_OBJ_TYPE_TREE)
383 		return got_error(GOT_ERR_OBJ_TYPE);
384 
385 	if (obj->flags & GOT_OBJ_FLAG_PACKED) {
386 		struct got_pack *pack;
387 		pack = got_repo_get_cached_pack(repo, obj->path_packfile);
388 		if (pack == NULL) {
389 			err = got_repo_cache_pack(&pack, repo,
390 			    obj->path_packfile, NULL);
391 			if (err)
392 				return err;
393 		}
394 		err = got_object_read_packed_tree_privsep(tree, obj, pack);
395 	} else {
396 		int fd;
397 		err = open_loose_object(&fd, obj, repo);
398 		if (err)
399 			return err;
400 		err = got_object_read_tree_privsep(tree, obj, fd, repo);
401 		close(fd);
402 	}
403 
404 	if (err == NULL) {
405 		(*tree)->refcnt++;
406 		err = got_repo_cache_tree(repo, &obj->id, *tree);
407 	}
408 
409 	return err;
410 }
411 
412 const struct got_error *
413 got_object_open_as_tree(struct got_tree_object **tree,
414     struct got_repository *repo, struct got_object_id *id)
415 {
416 	const struct got_error *err;
417 	struct got_object *obj;
418 
419 	*tree = got_repo_get_cached_tree(repo, id);
420 	if (*tree != NULL) {
421 		(*tree)->refcnt++;
422 		return NULL;
423 	}
424 
425 	err = got_object_open(&obj, repo, id);
426 	if (err)
427 		return err;
428 	if (got_object_get_type(obj) != GOT_OBJ_TYPE_TREE) {
429 		err = got_error(GOT_ERR_OBJ_TYPE);
430 		goto done;
431 	}
432 
433 	err = open_tree(tree, repo, obj, 0);
434 done:
435 	got_object_close(obj);
436 	return err;
437 }
438 
439 const struct got_error *
440 got_object_tree_open(struct got_tree_object **tree,
441     struct got_repository *repo, struct got_object *obj)
442 {
443 	return open_tree(tree, repo, obj, 1);
444 }
445 
446 const struct got_tree_entries *
447 got_object_tree_get_entries(struct got_tree_object *tree)
448 {
449 	return &tree->entries;
450 }
451 
452 static const struct got_error *
453 read_packed_blob_privsep(size_t *size, int outfd, struct got_object *obj,
454     struct got_pack *pack)
455 {
456 	const struct got_error *err = NULL;
457 	int outfd_child;
458 	int basefd, accumfd; /* temporary files for delta application */
459 
460 	basefd = got_opentempfd();
461 	if (basefd == -1)
462 		return got_error_from_errno();
463 	accumfd = got_opentempfd();
464 	if (accumfd == -1)
465 		return got_error_from_errno();
466 
467 	outfd_child = dup(outfd);
468 	if (outfd_child == -1)
469 		return got_error_from_errno();
470 
471 	err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
472 	if (err)
473 		return err;
474 
475 	err = got_privsep_send_blob_outfd(pack->privsep_child->ibuf,
476 	    outfd_child);
477 	if (err) {
478 		close(outfd_child);
479 		return err;
480 	}
481 	err = got_privsep_send_tmpfd(pack->privsep_child->ibuf,
482 	    basefd);
483 	if (err) {
484 		close(basefd);
485 		close(accumfd);
486 		close(outfd_child);
487 		return err;
488 	}
489 
490 	err = got_privsep_send_tmpfd(pack->privsep_child->ibuf,
491 	    accumfd);
492 	if (err) {
493 		close(accumfd);
494 		close(outfd_child);
495 		return err;
496 	}
497 
498 	err = got_privsep_recv_blob(size, pack->privsep_child->ibuf);
499 	if (err)
500 		return err;
501 
502 	if (lseek(outfd, SEEK_SET, 0) == -1)
503 		err = got_error_from_errno();
504 
505 	return err;
506 }
507 
508 const struct got_error *
509 got_object_blob_open(struct got_blob_object **blob,
510     struct got_repository *repo, struct got_object *obj, size_t blocksize)
511 {
512 	const struct got_error *err = NULL;
513 	int outfd;
514 	size_t size;
515 	struct stat sb;
516 
517 	if (obj->type != GOT_OBJ_TYPE_BLOB)
518 		return got_error(GOT_ERR_OBJ_TYPE);
519 
520 	if (blocksize < obj->hdrlen)
521 		return got_error(GOT_ERR_NO_SPACE);
522 
523 	*blob = calloc(1, sizeof(**blob));
524 	if (*blob == NULL)
525 		return got_error_from_errno();
526 
527 	outfd = got_opentempfd();
528 	if (outfd == -1)
529 		return got_error_from_errno();
530 
531 	(*blob)->read_buf = malloc(blocksize);
532 	if ((*blob)->read_buf == NULL) {
533 		err = got_error_from_errno();
534 		goto done;
535 	}
536 	if (obj->flags & GOT_OBJ_FLAG_PACKED) {
537 		struct got_pack *pack;
538 		pack = got_repo_get_cached_pack(repo, obj->path_packfile);
539 		if (pack == NULL) {
540 			err = got_repo_cache_pack(&pack, repo,
541 			    obj->path_packfile, NULL);
542 			if (err)
543 				goto done;
544 		}
545 		err = read_packed_blob_privsep(&size, outfd, obj, pack);
546 		if (err)
547 			goto done;
548 		obj->size = size;
549 	} else {
550 		int infd;
551 
552 		err = open_loose_object(&infd, obj, repo);
553 		if (err)
554 			goto done;
555 
556 		err = got_object_read_blob_privsep(&size, outfd, infd, repo);
557 		close(infd);
558 		if (err)
559 			goto done;
560 
561 		if (size != obj->hdrlen + obj->size) {
562 			err = got_error(GOT_ERR_PRIVSEP_LEN);
563 			goto done;
564 		}
565 	}
566 
567 	if (fstat(outfd, &sb) == -1) {
568 		err = got_error_from_errno();
569 		goto done;
570 	}
571 
572 	if (sb.st_size != obj->hdrlen + obj->size) {
573 		err = got_error(GOT_ERR_PRIVSEP_LEN);
574 		goto done;
575 	}
576 
577 	(*blob)->f = fdopen(outfd, "rb");
578 	if ((*blob)->f == NULL) {
579 		err = got_error_from_errno();
580 		close(outfd);
581 		goto done;
582 	}
583 
584 	(*blob)->hdrlen = obj->hdrlen;
585 	(*blob)->blocksize = blocksize;
586 	memcpy(&(*blob)->id.sha1, obj->id.sha1, SHA1_DIGEST_LENGTH);
587 
588 done:
589 	if (err) {
590 		if (*blob) {
591 			if ((*blob)->f)
592 				fclose((*blob)->f);
593 			free((*blob)->read_buf);
594 			free(*blob);
595 			*blob = NULL;
596 		} else if (outfd != -1)
597 			close(outfd);
598 	}
599 	return err;
600 }
601 
602 const struct got_error *
603 got_object_open_as_blob(struct got_blob_object **blob,
604     struct got_repository *repo, struct got_object_id *id,
605     size_t blocksize)
606 {
607 	const struct got_error *err;
608 	struct got_object *obj;
609 
610 	*blob = NULL;
611 
612 	err = got_object_open(&obj, repo, id);
613 	if (err)
614 		return err;
615 	if (got_object_get_type(obj) != GOT_OBJ_TYPE_BLOB) {
616 		err = got_error(GOT_ERR_OBJ_TYPE);
617 		goto done;
618 	}
619 
620 	err = got_object_blob_open(blob, repo, obj, blocksize);
621 done:
622 	got_object_close(obj);
623 	return err;
624 }
625 
626 void
627 got_object_blob_close(struct got_blob_object *blob)
628 {
629 	free(blob->read_buf);
630 	fclose(blob->f);
631 	free(blob);
632 }
633 
634 char *
635 got_object_blob_id_str(struct got_blob_object *blob, char *buf, size_t size)
636 {
637 	return got_sha1_digest_to_str(blob->id.sha1, buf, size);
638 }
639 
640 size_t
641 got_object_blob_get_hdrlen(struct got_blob_object *blob)
642 {
643 	return blob->hdrlen;
644 }
645 
646 const uint8_t *
647 got_object_blob_get_read_buf(struct got_blob_object *blob)
648 {
649 	return blob->read_buf;
650 }
651 
652 const struct got_error *
653 got_object_blob_read_block(size_t *outlenp, struct got_blob_object *blob)
654 {
655 	size_t n;
656 
657 	n = fread(blob->read_buf, 1, blob->blocksize, blob->f);
658 	if (n == 0 && ferror(blob->f))
659 		return got_ferror(blob->f, GOT_ERR_IO);
660 	*outlenp = n;
661 	return NULL;
662 }
663 
664 const struct got_error *
665 got_object_blob_dump_to_file(size_t *total_len, size_t *nlines,
666     FILE *outfile, struct got_blob_object *blob)
667 {
668 	const struct got_error *err = NULL;
669 	size_t len, hdrlen;
670 	const uint8_t *buf;
671 	int i;
672 
673 	if (total_len)
674 		*total_len = 0;
675 	if (nlines)
676 		*nlines = 0;
677 
678 	hdrlen = got_object_blob_get_hdrlen(blob);
679 	do {
680 		err = got_object_blob_read_block(&len, blob);
681 		if (err)
682 			return err;
683 		if (len == 0)
684 			break;
685 		if (total_len)
686 			*total_len += len;
687 		buf = got_object_blob_get_read_buf(blob);
688 		if (nlines) {
689 			for (i = 0; i < len; i++) {
690 				if (buf[i] == '\n')
691 					(*nlines)++;
692 			}
693 		}
694 		/* Skip blob object header first time around. */
695 		fwrite(buf + hdrlen, len - hdrlen, 1, outfile);
696 		hdrlen = 0;
697 	} while (len != 0);
698 
699 	fflush(outfile);
700 	rewind(outfile);
701 
702 	return NULL;
703 }
704 
705 static struct got_tree_entry *
706 find_entry_by_name(struct got_tree_object *tree, const char *name, size_t len)
707 {
708 	struct got_tree_entry *te;
709 
710 	SIMPLEQ_FOREACH(te, &tree->entries.head, entry) {
711 		if (strncmp(te->name, name, len) == 0 && te->name[len] == '\0')
712 			return te;
713 	}
714 	return NULL;
715 }
716 
717 const struct got_error *
718 got_object_id_by_path(struct got_object_id **id, struct got_repository *repo,
719     struct got_object_id *commit_id, const char *path)
720 {
721 	const struct got_error *err = NULL;
722 	struct got_commit_object *commit = NULL;
723 	struct got_tree_object *tree = NULL;
724 	struct got_tree_entry *te = NULL;
725 	const char *seg, *s;
726 	size_t seglen, len = strlen(path);
727 
728 	*id = NULL;
729 
730 	/* We are expecting an absolute in-repository path. */
731 	if (path[0] != '/')
732 		return got_error(GOT_ERR_NOT_ABSPATH);
733 
734 	err = got_object_open_as_commit(&commit, repo, commit_id);
735 	if (err)
736 		goto done;
737 
738 	/* Handle opening of root of commit's tree. */
739 	if (path[1] == '\0') {
740 		*id = got_object_id_dup(commit->tree_id);
741 		if (*id == NULL)
742 			err = got_error_from_errno();
743 		goto done;
744 	}
745 
746 	err = got_object_open_as_tree(&tree, repo, commit->tree_id);
747 	if (err)
748 		goto done;
749 
750 	s = path;
751 	s++; /* skip leading '/' */
752 	len--;
753 	seg = s;
754 	seglen = 0;
755 	while (len > 0) {
756 		struct got_tree_object *next_tree;
757 
758 		if (*s != '/') {
759 			s++;
760 			len--;
761 			seglen++;
762 			if (*s)
763 				continue;
764 		}
765 
766 		te = find_entry_by_name(tree, seg, seglen);
767 		if (te == NULL) {
768 			err = got_error(GOT_ERR_NO_OBJ);
769 			goto done;
770 		}
771 
772 		if (len == 0)
773 			break;
774 
775 		seg = s + 1;
776 		seglen = 0;
777 		s++;
778 		len--;
779 		if (*s) {
780 			err = got_object_open_as_tree(&next_tree, repo,
781 			    te->id);
782 			te = NULL;
783 			if (err)
784 				goto done;
785 			got_object_tree_close(tree);
786 			tree = next_tree;
787 		}
788 	}
789 
790 	if (te) {
791 		*id = got_object_id_dup(te->id);
792 		if (*id == NULL)
793 			return got_error_from_errno();
794 	} else
795 		err = got_error(GOT_ERR_NO_OBJ);
796 done:
797 	if (commit)
798 		got_object_commit_close(commit);
799 	if (tree)
800 		got_object_tree_close(tree);
801 	return err;
802 }
803 
804 const struct got_error *
805 got_object_tree_path_changed(int *changed,
806     struct got_tree_object *tree01, struct got_tree_object *tree02,
807     const char *path, struct got_repository *repo)
808 {
809 	const struct got_error *err = NULL;
810 	struct got_tree_object *tree1 = NULL, *tree2 = NULL;
811 	struct got_tree_entry *te1 = NULL, *te2 = NULL;
812 	const char *seg, *s;
813 	size_t seglen, remain = strlen(path);
814 
815 	*changed = 0;
816 
817 	/* We are expecting an absolute in-repository path. */
818 	if (path[0] != '/')
819 		return got_error(GOT_ERR_NOT_ABSPATH);
820 
821 	/* We not do support comparing the root path. */
822 	if (path[1] == '\0')
823 		return got_error(GOT_ERR_BAD_PATH);
824 
825 	tree1 = tree01;
826 	tree2 = tree02;
827 	s = path;
828 	s++; /* skip leading '/' */
829 	remain--;
830 	seg = s;
831 	seglen = 0;
832 	while (remain > 0) {
833 		struct got_tree_object *next_tree1, *next_tree2;
834 
835 		if (*s != '/') {
836 			s++;
837 			remain--;
838 			seglen++;
839 			if (*s)
840 				continue;
841 		}
842 
843 		te1 = find_entry_by_name(tree1, seg, seglen);
844 		if (te1 == NULL) {
845 			err = got_error(GOT_ERR_NO_OBJ);
846 			goto done;
847 		}
848 
849 		te2 = find_entry_by_name(tree2, seg, seglen);
850 		if (te2 == NULL) {
851 			*changed = 1;
852 			goto done;
853 		}
854 
855 		if (te1->mode != te2->mode) {
856 			*changed = 1;
857 			goto done;
858 		}
859 
860 		if (got_object_id_cmp(te1->id, te2->id) == 0) {
861 			*changed = 0;
862 			goto done;
863 		}
864 
865 		if (remain == 0) { /* final path element */
866 			*changed = 1;
867 			goto done;
868 		}
869 
870 		seg = s + 1;
871 		s++;
872 		remain--;
873 		seglen = 0;
874 		if (*s) {
875 			err = got_object_open_as_tree(&next_tree1, repo,
876 			    te1->id);
877 			te1 = NULL;
878 			if (err)
879 				goto done;
880 			if (tree1 != tree01)
881 				got_object_tree_close(tree1);
882 			tree1 = next_tree1;
883 
884 			err = got_object_open_as_tree(&next_tree2, repo,
885 			    te2->id);
886 			te2 = NULL;
887 			if (err)
888 				goto done;
889 			if (tree2 != tree02)
890 				got_object_tree_close(tree2);
891 			tree2 = next_tree2;
892 		}
893 	}
894 done:
895 	if (tree1 && tree1 != tree01)
896 		got_object_tree_close(tree1);
897 	if (tree2 && tree2 != tree02)
898 		got_object_tree_close(tree2);
899 	return err;
900 }
901 
902 static void
903 exec_privsep_child(int imsg_fds[2], const char *path, const char *repo_path)
904 {
905 	close(imsg_fds[0]);
906 
907 	if (dup2(imsg_fds[1], GOT_IMSG_FD_CHILD) == -1) {
908 		fprintf(stderr, "%s: %s\n", getprogname(),
909 		    strerror(errno));
910 		_exit(1);
911 	}
912 	if (closefrom(GOT_IMSG_FD_CHILD + 1) == -1) {
913 		fprintf(stderr, "%s: %s\n", getprogname(),
914 		    strerror(errno));
915 		_exit(1);
916 	}
917 
918 	if (execl(path, path, repo_path, (char *)NULL) == -1) {
919 		fprintf(stderr, "%s: %s: %s\n", getprogname(), path,
920 		    strerror(errno));
921 		_exit(1);
922 	}
923 }
924 
925 static const struct got_error *
926 request_object(struct got_object **obj, struct got_repository *repo, int fd)
927 {
928 	const struct got_error *err = NULL;
929 	struct imsgbuf *ibuf;
930 
931 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
932 
933 	err = got_privsep_send_obj_req(ibuf, fd, NULL);
934 	if (err)
935 		return err;
936 
937 	return got_privsep_recv_obj(obj, ibuf);
938 }
939 
940 const struct got_error *
941 got_object_read_header_privsep(struct got_object **obj,
942     struct got_repository *repo, int obj_fd)
943 {
944 	int imsg_fds[2];
945 	pid_t pid;
946 	struct imsgbuf *ibuf;
947 
948 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
949 		return request_object(obj, repo, obj_fd);
950 
951 	ibuf = calloc(1, sizeof(*ibuf));
952 	if (ibuf == NULL)
953 		return got_error_from_errno();
954 
955 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
956 		return got_error_from_errno();
957 
958 	pid = fork();
959 	if (pid == -1)
960 		return got_error_from_errno();
961 	else if (pid == 0) {
962 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_OBJECT,
963 		    repo->path);
964 		/* not reached */
965 	}
966 
967 	close(imsg_fds[1]);
968 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd =
969 	    imsg_fds[0];
970 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].pid = pid;
971 	imsg_init(ibuf, imsg_fds[0]);
972 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf = ibuf;
973 
974 	return request_object(obj, repo, obj_fd);
975 }
976 
977 static const struct got_error *
978 request_packed_object(struct got_object **obj, struct got_pack *pack, int idx,
979     struct got_object_id *id)
980 {
981 	const struct got_error *err = NULL;
982 	struct imsgbuf *ibuf = pack->privsep_child->ibuf;
983 
984 	err = got_privsep_send_packed_obj_req(ibuf, idx, id);
985 	if (err)
986 		return err;
987 
988 	err = got_privsep_recv_obj(obj, ibuf);
989 	if (err)
990 		return err;
991 
992 	(*obj)->path_packfile = strdup(pack->path_packfile);
993 	if ((*obj)->path_packfile == NULL) {
994 		err = got_error_from_errno();
995 		return err;
996 	}
997 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
998 
999 	return NULL;
1000 }
1001 
1002 const struct got_error *
1003 got_object_packed_read_privsep(struct got_object **obj,
1004     struct got_repository *repo, struct got_pack *pack,
1005     struct got_packidx *packidx, int idx, struct got_object_id *id)
1006 {
1007 	const struct got_error *err = NULL;
1008 	int imsg_fds[2];
1009 	pid_t pid;
1010 	struct imsgbuf *ibuf;
1011 
1012 	if (pack->privsep_child)
1013 		return request_packed_object(obj, pack, idx, id);
1014 
1015 	ibuf = calloc(1, sizeof(*ibuf));
1016 	if (ibuf == NULL)
1017 		return got_error_from_errno();
1018 
1019 	pack->privsep_child = calloc(1, sizeof(*pack->privsep_child));
1020 	if (pack->privsep_child == NULL) {
1021 		err = got_error_from_errno();
1022 		free(ibuf);
1023 		return err;
1024 	}
1025 
1026 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
1027 		err = got_error_from_errno();
1028 		goto done;
1029 	}
1030 
1031 	pid = fork();
1032 	if (pid == -1) {
1033 		err = got_error_from_errno();
1034 		goto done;
1035 	} else if (pid == 0) {
1036 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_PACK,
1037 		    pack->path_packfile);
1038 		/* not reached */
1039 	}
1040 
1041 	close(imsg_fds[1]);
1042 	pack->privsep_child->imsg_fd = imsg_fds[0];
1043 	pack->privsep_child->pid = pid;
1044 	imsg_init(ibuf, imsg_fds[0]);
1045 	pack->privsep_child->ibuf = ibuf;
1046 
1047 	err = got_privsep_init_pack_child(ibuf, pack, packidx);
1048 	if (err) {
1049 		const struct got_error *child_err;
1050 		err = got_privsep_send_stop(pack->privsep_child->imsg_fd);
1051 		child_err = got_privsep_wait_for_child(
1052 		    pack->privsep_child->pid);
1053 		if (child_err && err == NULL)
1054 			err = child_err;
1055 		free(ibuf);
1056 		free(pack->privsep_child);
1057 		pack->privsep_child = NULL;
1058 		return err;
1059 	}
1060 
1061 done:
1062 	if (err) {
1063 		free(ibuf);
1064 		free(pack->privsep_child);
1065 		pack->privsep_child = NULL;
1066 	} else
1067 		err = request_packed_object(obj, pack, idx, id);
1068 	return err;
1069 }
1070 
1071 
1072 static const struct got_error *
1073 request_commit(struct got_commit_object **commit, struct got_repository *repo,
1074     struct got_object *obj, int fd)
1075 {
1076 	const struct got_error *err = NULL;
1077 	struct imsgbuf *ibuf;
1078 
1079 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf;
1080 
1081 	err = got_privsep_send_obj_req(ibuf, fd, obj);
1082 	if (err)
1083 		return err;
1084 
1085 	return got_privsep_recv_commit(commit, ibuf);
1086 }
1087 
1088 const struct got_error *
1089 got_object_read_packed_commit_privsep(struct got_commit_object **commit,
1090     struct got_object *obj, struct got_pack *pack)
1091 {
1092 	const struct got_error *err = NULL;
1093 
1094 	err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
1095 	if (err)
1096 		return err;
1097 
1098 	return got_privsep_recv_commit(commit, pack->privsep_child->ibuf);
1099 }
1100 
1101 const struct got_error *
1102 got_object_read_commit_privsep(struct got_commit_object **commit,
1103     struct got_object *obj, int obj_fd, struct got_repository *repo)
1104 {
1105 	int imsg_fds[2];
1106 	pid_t pid;
1107 	struct imsgbuf *ibuf;
1108 
1109 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd != -1)
1110 		return request_commit(commit, repo, obj, obj_fd);
1111 
1112 	ibuf = calloc(1, sizeof(*ibuf));
1113 	if (ibuf == NULL)
1114 		return got_error_from_errno();
1115 
1116 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1117 		return got_error_from_errno();
1118 
1119 	pid = fork();
1120 	if (pid == -1)
1121 		return got_error_from_errno();
1122 	else if (pid == 0) {
1123 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_COMMIT,
1124 		    repo->path);
1125 		/* not reached */
1126 	}
1127 
1128 	close(imsg_fds[1]);
1129 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd =
1130 	    imsg_fds[0];
1131 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].pid = pid;
1132 	imsg_init(ibuf, imsg_fds[0]);
1133 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf = ibuf;
1134 
1135 	return request_commit(commit, repo, obj, obj_fd);
1136 }
1137 
1138 static const struct got_error *
1139 request_tree(struct got_tree_object **tree, struct got_repository *repo,
1140     struct got_object *obj, int fd)
1141 {
1142 	const struct got_error *err = NULL;
1143 	struct imsgbuf *ibuf;
1144 
1145 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf;
1146 
1147 	err = got_privsep_send_obj_req(ibuf, fd, obj);
1148 	if (err)
1149 		return err;
1150 
1151 	return got_privsep_recv_tree(tree, ibuf);
1152 }
1153 
1154 const struct got_error *
1155 got_object_read_tree_privsep(struct got_tree_object **tree,
1156     struct got_object *obj, int obj_fd, struct got_repository *repo)
1157 {
1158 	int imsg_fds[2];
1159 	pid_t pid;
1160 	struct imsgbuf *ibuf;
1161 
1162 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd != -1)
1163 		return request_tree(tree, repo, obj, obj_fd);
1164 
1165 	ibuf = calloc(1, sizeof(*ibuf));
1166 	if (ibuf == NULL)
1167 		return got_error_from_errno();
1168 
1169 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1170 		return got_error_from_errno();
1171 
1172 	pid = fork();
1173 	if (pid == -1)
1174 		return got_error_from_errno();
1175 	else if (pid == 0) {
1176 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_TREE,
1177 		    repo->path);
1178 		/* not reached */
1179 	}
1180 
1181 	close(imsg_fds[1]);
1182 
1183 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd =
1184 	    imsg_fds[0];
1185 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].pid = pid;
1186 	imsg_init(ibuf, imsg_fds[0]);
1187 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf = ibuf;
1188 
1189 
1190 	return request_tree(tree, repo, obj, obj_fd);
1191 }
1192 
1193 const struct got_error *
1194 got_object_read_packed_tree_privsep(struct got_tree_object **tree,
1195     struct got_object *obj, struct got_pack *pack)
1196 {
1197 	const struct got_error *err = NULL;
1198 
1199 	err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
1200 	if (err)
1201 		return err;
1202 
1203 	return got_privsep_recv_tree(tree, pack->privsep_child->ibuf);
1204 }
1205 
1206 static const struct got_error *
1207 request_blob(size_t *size, int outfd, int infd, struct imsgbuf *ibuf)
1208 {
1209 	const struct got_error *err = NULL;
1210 	int outfd_child;
1211 
1212 	outfd_child = dup(outfd);
1213 	if (outfd_child == -1)
1214 		return got_error_from_errno();
1215 
1216 	err = got_privsep_send_blob_req(ibuf, infd);
1217 	if (err)
1218 		return err;
1219 
1220 	err = got_privsep_send_blob_outfd(ibuf, outfd_child);
1221 	if (err) {
1222 		close(outfd_child);
1223 		return err;
1224 	}
1225 
1226 	err = got_privsep_recv_blob(size, ibuf);
1227 	if (err)
1228 		return err;
1229 
1230 	if (lseek(outfd, SEEK_SET, 0) == -1)
1231 		return got_error_from_errno();
1232 
1233 	return err;
1234 }
1235 
1236 const struct got_error *
1237 got_object_read_blob_privsep(size_t *size, int outfd, int infd,
1238     struct got_repository *repo)
1239 {
1240 	int imsg_fds[2];
1241 	pid_t pid;
1242 	struct imsgbuf *ibuf;
1243 
1244 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd != -1) {
1245 		ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
1246 		return request_blob(size, outfd, infd, ibuf);
1247 	}
1248 
1249 	ibuf = calloc(1, sizeof(*ibuf));
1250 	if (ibuf == NULL)
1251 		return got_error_from_errno();
1252 
1253 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1254 		return got_error_from_errno();
1255 
1256 	pid = fork();
1257 	if (pid == -1)
1258 		return got_error_from_errno();
1259 	else if (pid == 0) {
1260 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_BLOB,
1261 		    repo->path);
1262 		/* not reached */
1263 	}
1264 
1265 	close(imsg_fds[1]);
1266 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd =
1267 	    imsg_fds[0];
1268 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].pid = pid;
1269 	imsg_init(ibuf, imsg_fds[0]);
1270 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf = ibuf;
1271 
1272 	return request_blob(size, outfd, infd, ibuf);
1273 }