Got Mirror

Blob

Date:: Mon Nov 19 09:05:28 2018 UTC
Message:: store number of lines in int instead of size_t
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_no_obj(id);
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, int *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 const struct got_error *
706 open_tag(struct got_tag_object **tag,
707     struct got_repository *repo, struct got_object *obj, int check_cache)
708 {
709 	const struct got_error *err = NULL;
710 
711 	if (check_cache) {
712 		*tag = got_repo_get_cached_tag(repo, &obj->id);
713 		if (*tag != NULL) {
714 			(*tag)->refcnt++;
715 			return NULL;
716 		}
717 	} else
718 		*tag = NULL;
719 
720 	if (obj->type != GOT_OBJ_TYPE_TAG)
721 		return got_error(GOT_ERR_OBJ_TYPE);
722 
723 	if (obj->flags & GOT_OBJ_FLAG_PACKED) {
724 		struct got_pack *pack;
725 		pack = got_repo_get_cached_pack(repo, obj->path_packfile);
726 		if (pack == NULL) {
727 			err = got_repo_cache_pack(&pack, repo,
728 			    obj->path_packfile, NULL);
729 			if (err)
730 				return err;
731 		}
732 		err = got_object_read_packed_tag_privsep(tag, obj, pack);
733 	} else {
734 		int fd;
735 		err = open_loose_object(&fd, obj, repo);
736 		if (err)
737 			return err;
738 		err = got_object_read_tag_privsep(tag, obj, fd, repo);
739 		close(fd);
740 	}
741 
742 	if (err == NULL) {
743 		(*tag)->refcnt++;
744 		err = got_repo_cache_tag(repo, &obj->id, *tag);
745 	}
746 
747 	return err;
748 }
749 
750 const struct got_error *
751 got_object_open_as_tag(struct got_tag_object **tag,
752     struct got_repository *repo, struct got_object_id *id)
753 {
754 	const struct got_error *err;
755 	struct got_object *obj;
756 
757 	*tag = got_repo_get_cached_tag(repo, id);
758 	if (*tag != NULL) {
759 		(*tag)->refcnt++;
760 		return NULL;
761 	}
762 
763 	err = got_object_open(&obj, repo, id);
764 	if (err)
765 		return err;
766 	if (got_object_get_type(obj) != GOT_OBJ_TYPE_COMMIT) {
767 		err = got_error(GOT_ERR_OBJ_TYPE);
768 		goto done;
769 	}
770 
771 	err = open_tag(tag, repo, obj, 0);
772 done:
773 	got_object_close(obj);
774 	return err;
775 }
776 
777 const struct got_error *
778 got_object_tag_open(struct got_tag_object **tag,
779     struct got_repository *repo, struct got_object *obj)
780 {
781 	return open_tag(tag, repo, obj, 1);
782 }
783 
784 static struct got_tree_entry *
785 find_entry_by_name(struct got_tree_object *tree, const char *name, size_t len)
786 {
787 	struct got_tree_entry *te;
788 
789 	/* Note that tree entries are sorted in strncmp() order. */
790 	SIMPLEQ_FOREACH(te, &tree->entries.head, entry) {
791 		int cmp = strncmp(te->name, name, len);
792 		if (cmp < 0)
793 			continue;
794 		if (cmp > 0)
795 			break;
796 		if (te->name[len] == '\0')
797 			return te;
798 	}
799 	return NULL;
800 }
801 
802 const struct got_error *
803 got_object_id_by_path(struct got_object_id **id, struct got_repository *repo,
804     struct got_object_id *commit_id, const char *path)
805 {
806 	const struct got_error *err = NULL;
807 	struct got_commit_object *commit = NULL;
808 	struct got_tree_object *tree = NULL;
809 	struct got_tree_entry *te = NULL;
810 	const char *seg, *s;
811 	size_t seglen;
812 
813 	*id = NULL;
814 
815 	/* We are expecting an absolute in-repository path. */
816 	if (path[0] != '/')
817 		return got_error(GOT_ERR_NOT_ABSPATH);
818 
819 	err = got_object_open_as_commit(&commit, repo, commit_id);
820 	if (err)
821 		goto done;
822 
823 	/* Handle opening of root of commit's tree. */
824 	if (path[1] == '\0') {
825 		*id = got_object_id_dup(commit->tree_id);
826 		if (*id == NULL)
827 			err = got_error_from_errno();
828 		goto done;
829 	}
830 
831 	err = got_object_open_as_tree(&tree, repo, commit->tree_id);
832 	if (err)
833 		goto done;
834 
835 	s = path;
836 	s++; /* skip leading '/' */
837 	seg = s;
838 	seglen = 0;
839 	while (*s) {
840 		struct got_tree_object *next_tree;
841 
842 		if (*s != '/') {
843 			s++;
844 			seglen++;
845 			if (*s)
846 				continue;
847 		}
848 
849 		te = find_entry_by_name(tree, seg, seglen);
850 		if (te == NULL) {
851 			err = got_error(GOT_ERR_NO_TREE_ENTRY);
852 			goto done;
853 		}
854 
855 		if (*s == '\0')
856 			break;
857 
858 		seg = s + 1;
859 		seglen = 0;
860 		s++;
861 		if (*s) {
862 			err = got_object_open_as_tree(&next_tree, repo,
863 			    te->id);
864 			te = NULL;
865 			if (err)
866 				goto done;
867 			got_object_tree_close(tree);
868 			tree = next_tree;
869 		}
870 	}
871 
872 	if (te) {
873 		*id = got_object_id_dup(te->id);
874 		if (*id == NULL)
875 			return got_error_from_errno();
876 	} else
877 		err = got_error(GOT_ERR_NO_TREE_ENTRY);
878 done:
879 	if (commit)
880 		got_object_commit_close(commit);
881 	if (tree)
882 		got_object_tree_close(tree);
883 	return err;
884 }
885 
886 const struct got_error *
887 got_object_tree_path_changed(int *changed,
888     struct got_tree_object *tree01, struct got_tree_object *tree02,
889     const char *path, struct got_repository *repo)
890 {
891 	const struct got_error *err = NULL;
892 	struct got_tree_object *tree1 = NULL, *tree2 = NULL;
893 	struct got_tree_entry *te1 = NULL, *te2 = NULL;
894 	const char *seg, *s;
895 	size_t seglen;
896 
897 	*changed = 0;
898 
899 	/* We are expecting an absolute in-repository path. */
900 	if (path[0] != '/')
901 		return got_error(GOT_ERR_NOT_ABSPATH);
902 
903 	/* We not do support comparing the root path. */
904 	if (path[1] == '\0')
905 		return got_error(GOT_ERR_BAD_PATH);
906 
907 	tree1 = tree01;
908 	tree2 = tree02;
909 	s = path;
910 	s++; /* skip leading '/' */
911 	seg = s;
912 	seglen = 0;
913 	while (*s) {
914 		struct got_tree_object *next_tree1, *next_tree2;
915 
916 		if (*s != '/') {
917 			s++;
918 			seglen++;
919 			if (*s)
920 				continue;
921 		}
922 
923 		te1 = find_entry_by_name(tree1, seg, seglen);
924 		if (te1 == NULL) {
925 			err = got_error(GOT_ERR_NO_OBJ);
926 			goto done;
927 		}
928 
929 		te2 = find_entry_by_name(tree2, seg, seglen);
930 		if (te2 == NULL) {
931 			*changed = 1;
932 			goto done;
933 		}
934 
935 		if (te1->mode != te2->mode) {
936 			*changed = 1;
937 			goto done;
938 		}
939 
940 		if (got_object_id_cmp(te1->id, te2->id) == 0) {
941 			*changed = 0;
942 			goto done;
943 		}
944 
945 		if (*s == '\0') { /* final path element */
946 			*changed = 1;
947 			goto done;
948 		}
949 
950 		seg = s + 1;
951 		s++;
952 		seglen = 0;
953 		if (*s) {
954 			err = got_object_open_as_tree(&next_tree1, repo,
955 			    te1->id);
956 			te1 = NULL;
957 			if (err)
958 				goto done;
959 			if (tree1 != tree01)
960 				got_object_tree_close(tree1);
961 			tree1 = next_tree1;
962 
963 			err = got_object_open_as_tree(&next_tree2, repo,
964 			    te2->id);
965 			te2 = NULL;
966 			if (err)
967 				goto done;
968 			if (tree2 != tree02)
969 				got_object_tree_close(tree2);
970 			tree2 = next_tree2;
971 		}
972 	}
973 done:
974 	if (tree1 && tree1 != tree01)
975 		got_object_tree_close(tree1);
976 	if (tree2 && tree2 != tree02)
977 		got_object_tree_close(tree2);
978 	return err;
979 }
980 
981 static void
982 exec_privsep_child(int imsg_fds[2], const char *path, const char *repo_path)
983 {
984 	close(imsg_fds[0]);
985 
986 	if (dup2(imsg_fds[1], GOT_IMSG_FD_CHILD) == -1) {
987 		fprintf(stderr, "%s: %s\n", getprogname(),
988 		    strerror(errno));
989 		_exit(1);
990 	}
991 	if (closefrom(GOT_IMSG_FD_CHILD + 1) == -1) {
992 		fprintf(stderr, "%s: %s\n", getprogname(),
993 		    strerror(errno));
994 		_exit(1);
995 	}
996 
997 	if (execl(path, path, repo_path, (char *)NULL) == -1) {
998 		fprintf(stderr, "%s: %s: %s\n", getprogname(), path,
999 		    strerror(errno));
1000 		_exit(1);
1001 	}
1002 }
1003 
1004 static const struct got_error *
1005 request_object(struct got_object **obj, struct got_repository *repo, int fd)
1006 {
1007 	const struct got_error *err = NULL;
1008 	struct imsgbuf *ibuf;
1009 
1010 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
1011 
1012 	err = got_privsep_send_obj_req(ibuf, fd, NULL);
1013 	if (err)
1014 		return err;
1015 
1016 	return got_privsep_recv_obj(obj, ibuf);
1017 }
1018 
1019 const struct got_error *
1020 got_object_read_header_privsep(struct got_object **obj,
1021     struct got_repository *repo, int obj_fd)
1022 {
1023 	int imsg_fds[2];
1024 	pid_t pid;
1025 	struct imsgbuf *ibuf;
1026 
1027 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
1028 		return request_object(obj, repo, obj_fd);
1029 
1030 	ibuf = calloc(1, sizeof(*ibuf));
1031 	if (ibuf == NULL)
1032 		return got_error_from_errno();
1033 
1034 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1035 		return got_error_from_errno();
1036 
1037 	pid = fork();
1038 	if (pid == -1)
1039 		return got_error_from_errno();
1040 	else if (pid == 0) {
1041 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_OBJECT,
1042 		    repo->path);
1043 		/* not reached */
1044 	}
1045 
1046 	close(imsg_fds[1]);
1047 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd =
1048 	    imsg_fds[0];
1049 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].pid = pid;
1050 	imsg_init(ibuf, imsg_fds[0]);
1051 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf = ibuf;
1052 
1053 	return request_object(obj, repo, obj_fd);
1054 }
1055 
1056 static const struct got_error *
1057 request_packed_object(struct got_object **obj, struct got_pack *pack, int idx,
1058     struct got_object_id *id)
1059 {
1060 	const struct got_error *err = NULL;
1061 	struct imsgbuf *ibuf = pack->privsep_child->ibuf;
1062 
1063 	err = got_privsep_send_packed_obj_req(ibuf, idx, id);
1064 	if (err)
1065 		return err;
1066 
1067 	err = got_privsep_recv_obj(obj, ibuf);
1068 	if (err)
1069 		return err;
1070 
1071 	(*obj)->path_packfile = strdup(pack->path_packfile);
1072 	if ((*obj)->path_packfile == NULL) {
1073 		err = got_error_from_errno();
1074 		return err;
1075 	}
1076 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
1077 
1078 	return NULL;
1079 }
1080 
1081 const struct got_error *
1082 got_object_packed_read_privsep(struct got_object **obj,
1083     struct got_repository *repo, struct got_pack *pack,
1084     struct got_packidx *packidx, int idx, struct got_object_id *id)
1085 {
1086 	const struct got_error *err = NULL;
1087 	int imsg_fds[2];
1088 	pid_t pid;
1089 	struct imsgbuf *ibuf;
1090 
1091 	if (pack->privsep_child)
1092 		return request_packed_object(obj, pack, idx, id);
1093 
1094 	ibuf = calloc(1, sizeof(*ibuf));
1095 	if (ibuf == NULL)
1096 		return got_error_from_errno();
1097 
1098 	pack->privsep_child = calloc(1, sizeof(*pack->privsep_child));
1099 	if (pack->privsep_child == NULL) {
1100 		err = got_error_from_errno();
1101 		free(ibuf);
1102 		return err;
1103 	}
1104 
1105 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
1106 		err = got_error_from_errno();
1107 		goto done;
1108 	}
1109 
1110 	pid = fork();
1111 	if (pid == -1) {
1112 		err = got_error_from_errno();
1113 		goto done;
1114 	} else if (pid == 0) {
1115 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_PACK,
1116 		    pack->path_packfile);
1117 		/* not reached */
1118 	}
1119 
1120 	close(imsg_fds[1]);
1121 	pack->privsep_child->imsg_fd = imsg_fds[0];
1122 	pack->privsep_child->pid = pid;
1123 	imsg_init(ibuf, imsg_fds[0]);
1124 	pack->privsep_child->ibuf = ibuf;
1125 
1126 	err = got_privsep_init_pack_child(ibuf, pack, packidx);
1127 	if (err) {
1128 		const struct got_error *child_err;
1129 		err = got_privsep_send_stop(pack->privsep_child->imsg_fd);
1130 		child_err = got_privsep_wait_for_child(
1131 		    pack->privsep_child->pid);
1132 		if (child_err && err == NULL)
1133 			err = child_err;
1134 		free(ibuf);
1135 		free(pack->privsep_child);
1136 		pack->privsep_child = NULL;
1137 		return err;
1138 	}
1139 
1140 done:
1141 	if (err) {
1142 		free(ibuf);
1143 		free(pack->privsep_child);
1144 		pack->privsep_child = NULL;
1145 	} else
1146 		err = request_packed_object(obj, pack, idx, id);
1147 	return err;
1148 }
1149 
1150 static const struct got_error *
1151 request_commit(struct got_commit_object **commit, struct got_repository *repo,
1152     struct got_object *obj, int fd)
1153 {
1154 	const struct got_error *err = NULL;
1155 	struct imsgbuf *ibuf;
1156 
1157 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf;
1158 
1159 	err = got_privsep_send_obj_req(ibuf, fd, obj);
1160 	if (err)
1161 		return err;
1162 
1163 	return got_privsep_recv_commit(commit, ibuf);
1164 }
1165 
1166 const struct got_error *
1167 got_object_read_packed_commit_privsep(struct got_commit_object **commit,
1168     struct got_object *obj, struct got_pack *pack)
1169 {
1170 	const struct got_error *err = NULL;
1171 
1172 	err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
1173 	if (err)
1174 		return err;
1175 
1176 	return got_privsep_recv_commit(commit, pack->privsep_child->ibuf);
1177 }
1178 
1179 const struct got_error *
1180 got_object_read_commit_privsep(struct got_commit_object **commit,
1181     struct got_object *obj, int obj_fd, struct got_repository *repo)
1182 {
1183 	int imsg_fds[2];
1184 	pid_t pid;
1185 	struct imsgbuf *ibuf;
1186 
1187 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd != -1)
1188 		return request_commit(commit, repo, obj, obj_fd);
1189 
1190 	ibuf = calloc(1, sizeof(*ibuf));
1191 	if (ibuf == NULL)
1192 		return got_error_from_errno();
1193 
1194 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1195 		return got_error_from_errno();
1196 
1197 	pid = fork();
1198 	if (pid == -1)
1199 		return got_error_from_errno();
1200 	else if (pid == 0) {
1201 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_COMMIT,
1202 		    repo->path);
1203 		/* not reached */
1204 	}
1205 
1206 	close(imsg_fds[1]);
1207 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd =
1208 	    imsg_fds[0];
1209 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].pid = pid;
1210 	imsg_init(ibuf, imsg_fds[0]);
1211 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf = ibuf;
1212 
1213 	return request_commit(commit, repo, obj, obj_fd);
1214 }
1215 
1216 static const struct got_error *
1217 request_tree(struct got_tree_object **tree, struct got_repository *repo,
1218     struct got_object *obj, int fd)
1219 {
1220 	const struct got_error *err = NULL;
1221 	struct imsgbuf *ibuf;
1222 
1223 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf;
1224 
1225 	err = got_privsep_send_obj_req(ibuf, fd, obj);
1226 	if (err)
1227 		return err;
1228 
1229 	return got_privsep_recv_tree(tree, ibuf);
1230 }
1231 
1232 const struct got_error *
1233 got_object_read_tree_privsep(struct got_tree_object **tree,
1234     struct got_object *obj, int obj_fd, struct got_repository *repo)
1235 {
1236 	int imsg_fds[2];
1237 	pid_t pid;
1238 	struct imsgbuf *ibuf;
1239 
1240 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd != -1)
1241 		return request_tree(tree, repo, obj, obj_fd);
1242 
1243 	ibuf = calloc(1, sizeof(*ibuf));
1244 	if (ibuf == NULL)
1245 		return got_error_from_errno();
1246 
1247 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1248 		return got_error_from_errno();
1249 
1250 	pid = fork();
1251 	if (pid == -1)
1252 		return got_error_from_errno();
1253 	else if (pid == 0) {
1254 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_TREE,
1255 		    repo->path);
1256 		/* not reached */
1257 	}
1258 
1259 	close(imsg_fds[1]);
1260 
1261 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd =
1262 	    imsg_fds[0];
1263 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].pid = pid;
1264 	imsg_init(ibuf, imsg_fds[0]);
1265 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf = ibuf;
1266 
1267 
1268 	return request_tree(tree, repo, obj, obj_fd);
1269 }
1270 
1271 const struct got_error *
1272 got_object_read_packed_tree_privsep(struct got_tree_object **tree,
1273     struct got_object *obj, struct got_pack *pack)
1274 {
1275 	const struct got_error *err = NULL;
1276 
1277 	err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
1278 	if (err)
1279 		return err;
1280 
1281 	return got_privsep_recv_tree(tree, pack->privsep_child->ibuf);
1282 }
1283 
1284 static const struct got_error *
1285 request_blob(size_t *size, int outfd, int infd, struct imsgbuf *ibuf)
1286 {
1287 	const struct got_error *err = NULL;
1288 	int outfd_child;
1289 
1290 	outfd_child = dup(outfd);
1291 	if (outfd_child == -1)
1292 		return got_error_from_errno();
1293 
1294 	err = got_privsep_send_blob_req(ibuf, infd);
1295 	if (err)
1296 		return err;
1297 
1298 	err = got_privsep_send_blob_outfd(ibuf, outfd_child);
1299 	if (err) {
1300 		close(outfd_child);
1301 		return err;
1302 	}
1303 
1304 	err = got_privsep_recv_blob(size, ibuf);
1305 	if (err)
1306 		return err;
1307 
1308 	if (lseek(outfd, SEEK_SET, 0) == -1)
1309 		return got_error_from_errno();
1310 
1311 	return err;
1312 }
1313 
1314 const struct got_error *
1315 got_object_read_blob_privsep(size_t *size, int outfd, int infd,
1316     struct got_repository *repo)
1317 {
1318 	int imsg_fds[2];
1319 	pid_t pid;
1320 	struct imsgbuf *ibuf;
1321 
1322 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd != -1) {
1323 		ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
1324 		return request_blob(size, outfd, infd, ibuf);
1325 	}
1326 
1327 	ibuf = calloc(1, sizeof(*ibuf));
1328 	if (ibuf == NULL)
1329 		return got_error_from_errno();
1330 
1331 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1332 		return got_error_from_errno();
1333 
1334 	pid = fork();
1335 	if (pid == -1)
1336 		return got_error_from_errno();
1337 	else if (pid == 0) {
1338 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_BLOB,
1339 		    repo->path);
1340 		/* not reached */
1341 	}
1342 
1343 	close(imsg_fds[1]);
1344 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd =
1345 	    imsg_fds[0];
1346 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].pid = pid;
1347 	imsg_init(ibuf, imsg_fds[0]);
1348 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf = ibuf;
1349 
1350 	return request_blob(size, outfd, infd, ibuf);
1351 }
1352 
1353 static const struct got_error *
1354 request_tag(struct got_tag_object **tag, struct got_repository *repo,
1355     struct got_object *obj, int fd)
1356 {
1357 	const struct got_error *err = NULL;
1358 	struct imsgbuf *ibuf;
1359 
1360 	ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].ibuf;
1361 
1362 	err = got_privsep_send_obj_req(ibuf, fd, obj);
1363 	if (err)
1364 		return err;
1365 
1366 	return got_privsep_recv_tag(tag, ibuf);
1367 }
1368 
1369 const struct got_error *
1370 got_object_read_packed_tag_privsep(struct got_tag_object **tag,
1371     struct got_object *obj, struct got_pack *pack)
1372 {
1373 	const struct got_error *err = NULL;
1374 
1375 	err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
1376 	if (err)
1377 		return err;
1378 
1379 	return got_privsep_recv_tag(tag, pack->privsep_child->ibuf);
1380 }
1381 
1382 const struct got_error *
1383 got_object_read_tag_privsep(struct got_tag_object **tag,
1384     struct got_object *obj, int obj_fd, struct got_repository *repo)
1385 {
1386 	int imsg_fds[2];
1387 	pid_t pid;
1388 	struct imsgbuf *ibuf;
1389 
1390 	if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].imsg_fd != -1)
1391 		return request_tag(tag, repo, obj, obj_fd);
1392 
1393 	ibuf = calloc(1, sizeof(*ibuf));
1394 	if (ibuf == NULL)
1395 		return got_error_from_errno();
1396 
1397 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1398 		return got_error_from_errno();
1399 
1400 	pid = fork();
1401 	if (pid == -1)
1402 		return got_error_from_errno();
1403 	else if (pid == 0) {
1404 		exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_TAG,
1405 		    repo->path);
1406 		/* not reached */
1407 	}
1408 
1409 	close(imsg_fds[1]);
1410 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].imsg_fd =
1411 	    imsg_fds[0];
1412 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].pid = pid;
1413 	imsg_init(ibuf, imsg_fds[0]);
1414 	repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].ibuf = ibuf;
1415 
1416 	return request_tag(tag, repo, obj, obj_fd);
1417 }