Blob


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 */
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>
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>
38 #include "got_error.h"
39 #include "got_object.h"
40 #include "got_repository.h"
41 #include "got_opentemp.h"
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"
55 #ifndef MIN
56 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
57 #endif
59 struct got_object_id *
60 got_object_id_dup(struct got_object_id *id1)
61 {
62 struct got_object_id *id2;
64 id2 = malloc(sizeof(*id2));
65 if (id2 == NULL)
66 return NULL;
67 memcpy(id2, id1, sizeof(*id2));
68 return id2;
69 }
71 struct got_object_id *
72 got_object_get_id(struct got_object *obj)
73 {
74 return &obj->id;
75 }
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 }
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 }
97 /* not reached */
98 return 0;
99 }
101 static const struct got_error *
102 object_path(char **path, struct got_object_id *id, struct got_repository *repo)
104 const struct got_error *err = NULL;
105 char *hex = NULL;
106 char *path_objects = got_repo_get_path_objects(repo);
108 *path = NULL;
110 if (path_objects == NULL)
111 return got_error_from_errno();
113 err = got_object_id_str(&hex, id);
114 if (err)
115 goto done;
117 if (asprintf(path, "%s/%.2x/%s", path_objects,
118 id->sha1[0], hex + 2) == -1)
119 err = got_error_from_errno();
121 done:
122 free(hex);
123 free(path_objects);
124 return err;
127 static const struct got_error *
128 open_loose_object(int *fd, struct got_object *obj, struct got_repository *repo)
130 const struct got_error *err = NULL;
131 char *path;
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;
141 done:
142 free(path);
143 return err;
146 static const struct got_error *
147 get_packfile_path(char **path_packfile, struct got_packidx *packidx)
149 size_t size;
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);
156 *path_packfile = malloc(size);
157 if (*path_packfile == NULL)
158 return got_error_from_errno();
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);
165 if (strlcat(*path_packfile, GOT_PACKFILE_SUFFIX, size) >= size)
166 return got_error(GOT_ERR_NO_SPACE);
168 return NULL;
171 static const struct got_error *
172 open_packed_object(struct got_object **obj, struct got_object_id *id,
173 struct got_repository *repo)
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;
181 err = got_repo_search_packidx(&packidx, &idx, repo, id);
182 if (err)
183 return err;
185 err = get_packfile_path(&path_packfile, packidx);
186 if (err)
187 return err;
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;
196 err = got_object_packed_read_privsep(obj, repo, pack, packidx, idx, id);
197 if (err)
198 goto done;
200 err = got_repo_cache_pack(NULL, repo, (*obj)->path_packfile, packidx);
201 done:
202 free(path_packfile);
203 return err;
206 const struct got_error *
207 got_object_open(struct got_object **obj, struct got_repository *repo,
208 struct got_object_id *id)
210 const struct got_error *err = NULL;
211 char *path;
212 int fd;
214 *obj = got_repo_get_cached_object(repo, id);
215 if (*obj != NULL) {
216 (*obj)->refcnt++;
217 return NULL;
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);
228 err = object_path(&path, id, repo);
229 if (err)
230 return err;
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);
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;
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)
260 struct got_object_id id;
262 if (!got_parse_sha1_digest(id.sha1, id_str))
263 return got_error(GOT_ERR_BAD_OBJ_ID_STR);
265 return got_object_open(obj, repo, &id);
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)
272 const struct got_error *err = NULL;
274 if (check_cache) {
275 *commit = got_repo_get_cached_commit(repo, &obj->id);
276 if (*commit != NULL) {
277 (*commit)->refcnt++;
278 return NULL;
280 } else
281 *commit = NULL;
283 if (obj->type != GOT_OBJ_TYPE_COMMIT)
284 return got_error(GOT_ERR_OBJ_TYPE);
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;
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);
305 if (err == NULL) {
306 (*commit)->refcnt++;
307 err = got_repo_cache_commit(repo, &obj->id, *commit);
310 return err;
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)
317 const struct got_error *err;
318 struct got_object *obj;
320 *commit = got_repo_get_cached_commit(repo, id);
321 if (*commit != NULL) {
322 (*commit)->refcnt++;
323 return NULL;
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;
334 err = open_commit(commit, repo, obj, 0);
335 done:
336 got_object_close(obj);
337 return err;
340 const struct got_error *
341 got_object_commit_open(struct got_commit_object **commit,
342 struct got_repository *repo, struct got_object *obj)
344 return open_commit(commit, repo, obj, 1);
347 const struct got_error *
348 got_object_qid_alloc(struct got_object_qid **qid, struct got_object_id *id)
350 const struct got_error *err = NULL;
352 *qid = calloc(1, sizeof(**qid));
353 if (*qid == NULL)
354 return got_error_from_errno();
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;
364 return NULL;
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)
371 const struct got_error *err = NULL;
373 if (check_cache) {
374 *tree = got_repo_get_cached_tree(repo, &obj->id);
375 if (*tree != NULL) {
376 (*tree)->refcnt++;
377 return NULL;
379 } else
380 *tree = NULL;
382 if (obj->type != GOT_OBJ_TYPE_TREE)
383 return got_error(GOT_ERR_OBJ_TYPE);
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;
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);
404 if (err == NULL) {
405 (*tree)->refcnt++;
406 err = got_repo_cache_tree(repo, &obj->id, *tree);
409 return err;
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)
416 const struct got_error *err;
417 struct got_object *obj;
419 *tree = got_repo_get_cached_tree(repo, id);
420 if (*tree != NULL) {
421 (*tree)->refcnt++;
422 return NULL;
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;
433 err = open_tree(tree, repo, obj, 0);
434 done:
435 got_object_close(obj);
436 return err;
439 const struct got_error *
440 got_object_tree_open(struct got_tree_object **tree,
441 struct got_repository *repo, struct got_object *obj)
443 return open_tree(tree, repo, obj, 1);
446 const struct got_tree_entries *
447 got_object_tree_get_entries(struct got_tree_object *tree)
449 return &tree->entries;
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)
456 const struct got_error *err = NULL;
457 int outfd_child;
458 int basefd, accumfd; /* temporary files for delta application */
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();
467 outfd_child = dup(outfd);
468 if (outfd_child == -1)
469 return got_error_from_errno();
471 err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
472 if (err)
473 return err;
475 err = got_privsep_send_blob_outfd(pack->privsep_child->ibuf,
476 outfd_child);
477 if (err) {
478 close(outfd_child);
479 return err;
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;
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;
498 err = got_privsep_recv_blob(size, pack->privsep_child->ibuf);
499 if (err)
500 return err;
502 if (lseek(outfd, SEEK_SET, 0) == -1)
503 err = got_error_from_errno();
505 return err;
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)
512 const struct got_error *err = NULL;
513 int outfd;
514 size_t size;
515 struct stat sb;
517 if (obj->type != GOT_OBJ_TYPE_BLOB)
518 return got_error(GOT_ERR_OBJ_TYPE);
520 if (blocksize < obj->hdrlen)
521 return got_error(GOT_ERR_NO_SPACE);
523 *blob = calloc(1, sizeof(**blob));
524 if (*blob == NULL)
525 return got_error_from_errno();
527 outfd = got_opentempfd();
528 if (outfd == -1)
529 return got_error_from_errno();
531 (*blob)->read_buf = malloc(blocksize);
532 if ((*blob)->read_buf == NULL) {
533 err = got_error_from_errno();
534 goto done;
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;
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;
552 err = open_loose_object(&infd, obj, repo);
553 if (err)
554 goto done;
556 err = got_object_read_blob_privsep(&size, outfd, infd, repo);
557 close(infd);
558 if (err)
559 goto done;
561 if (size != obj->hdrlen + obj->size) {
562 err = got_error(GOT_ERR_PRIVSEP_LEN);
563 goto done;
567 if (fstat(outfd, &sb) == -1) {
568 err = got_error_from_errno();
569 goto done;
572 if (sb.st_size != obj->hdrlen + obj->size) {
573 err = got_error(GOT_ERR_PRIVSEP_LEN);
574 goto done;
577 (*blob)->f = fdopen(outfd, "rb");
578 if ((*blob)->f == NULL) {
579 err = got_error_from_errno();
580 close(outfd);
581 goto done;
584 (*blob)->hdrlen = obj->hdrlen;
585 (*blob)->blocksize = blocksize;
586 memcpy(&(*blob)->id.sha1, obj->id.sha1, SHA1_DIGEST_LENGTH);
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);
599 return err;
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)
607 const struct got_error *err;
608 struct got_object *obj;
610 *blob = NULL;
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;
620 err = got_object_blob_open(blob, repo, obj, blocksize);
621 done:
622 got_object_close(obj);
623 return err;
626 void
627 got_object_blob_close(struct got_blob_object *blob)
629 free(blob->read_buf);
630 fclose(blob->f);
631 free(blob);
634 char *
635 got_object_blob_id_str(struct got_blob_object *blob, char *buf, size_t size)
637 return got_sha1_digest_to_str(blob->id.sha1, buf, size);
640 size_t
641 got_object_blob_get_hdrlen(struct got_blob_object *blob)
643 return blob->hdrlen;
646 const uint8_t *
647 got_object_blob_get_read_buf(struct got_blob_object *blob)
649 return blob->read_buf;
652 const struct got_error *
653 got_object_blob_read_block(size_t *outlenp, struct got_blob_object *blob)
655 size_t n;
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;
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)
668 const struct got_error *err = NULL;
669 size_t len, hdrlen;
670 const uint8_t *buf;
671 int i;
673 if (total_len)
674 *total_len = 0;
675 if (nlines)
676 *nlines = 0;
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)++;
694 /* Skip blob object header first time around. */
695 fwrite(buf + hdrlen, len - hdrlen, 1, outfile);
696 hdrlen = 0;
697 } while (len != 0);
699 fflush(outfile);
700 rewind(outfile);
702 return NULL;
705 static struct got_tree_entry *
706 find_entry_by_name(struct got_tree_object *tree, const char *name, size_t len)
708 struct got_tree_entry *te;
710 /* Note that tree entries are sorted in strncmp() order. */
711 SIMPLEQ_FOREACH(te, &tree->entries.head, entry) {
712 int cmp = strncmp(te->name, name, len);
713 if (cmp < 0)
714 continue;
715 if (cmp > 0)
716 break;
717 if (te->name[len] == '\0')
718 return te;
720 return NULL;
723 const struct got_error *
724 got_object_id_by_path(struct got_object_id **id, struct got_repository *repo,
725 struct got_object_id *commit_id, const char *path)
727 const struct got_error *err = NULL;
728 struct got_commit_object *commit = NULL;
729 struct got_tree_object *tree = NULL;
730 struct got_tree_entry *te = NULL;
731 const char *seg, *s;
732 size_t seglen, len = strlen(path);
734 *id = NULL;
736 /* We are expecting an absolute in-repository path. */
737 if (path[0] != '/')
738 return got_error(GOT_ERR_NOT_ABSPATH);
740 err = got_object_open_as_commit(&commit, repo, commit_id);
741 if (err)
742 goto done;
744 /* Handle opening of root of commit's tree. */
745 if (path[1] == '\0') {
746 *id = got_object_id_dup(commit->tree_id);
747 if (*id == NULL)
748 err = got_error_from_errno();
749 goto done;
752 err = got_object_open_as_tree(&tree, repo, commit->tree_id);
753 if (err)
754 goto done;
756 s = path;
757 s++; /* skip leading '/' */
758 len--;
759 seg = s;
760 seglen = 0;
761 while (len > 0) {
762 struct got_tree_object *next_tree;
764 if (*s != '/') {
765 s++;
766 len--;
767 seglen++;
768 if (*s)
769 continue;
772 te = find_entry_by_name(tree, seg, seglen);
773 if (te == NULL) {
774 err = got_error(GOT_ERR_NO_OBJ);
775 goto done;
778 if (len == 0)
779 break;
781 seg = s + 1;
782 seglen = 0;
783 s++;
784 len--;
785 if (*s) {
786 err = got_object_open_as_tree(&next_tree, repo,
787 te->id);
788 te = NULL;
789 if (err)
790 goto done;
791 got_object_tree_close(tree);
792 tree = next_tree;
796 if (te) {
797 *id = got_object_id_dup(te->id);
798 if (*id == NULL)
799 return got_error_from_errno();
800 } else
801 err = got_error(GOT_ERR_NO_OBJ);
802 done:
803 if (commit)
804 got_object_commit_close(commit);
805 if (tree)
806 got_object_tree_close(tree);
807 return err;
810 const struct got_error *
811 got_object_tree_path_changed(int *changed,
812 struct got_tree_object *tree01, struct got_tree_object *tree02,
813 const char *path, struct got_repository *repo)
815 const struct got_error *err = NULL;
816 struct got_tree_object *tree1 = NULL, *tree2 = NULL;
817 struct got_tree_entry *te1 = NULL, *te2 = NULL;
818 const char *seg, *s;
819 size_t seglen, remain = strlen(path);
821 *changed = 0;
823 /* We are expecting an absolute in-repository path. */
824 if (path[0] != '/')
825 return got_error(GOT_ERR_NOT_ABSPATH);
827 /* We not do support comparing the root path. */
828 if (path[1] == '\0')
829 return got_error(GOT_ERR_BAD_PATH);
831 tree1 = tree01;
832 tree2 = tree02;
833 s = path;
834 s++; /* skip leading '/' */
835 remain--;
836 seg = s;
837 seglen = 0;
838 while (remain > 0) {
839 struct got_tree_object *next_tree1, *next_tree2;
841 if (*s != '/') {
842 s++;
843 remain--;
844 seglen++;
845 if (*s)
846 continue;
849 te1 = find_entry_by_name(tree1, seg, seglen);
850 if (te1 == NULL) {
851 err = got_error(GOT_ERR_NO_OBJ);
852 goto done;
855 te2 = find_entry_by_name(tree2, seg, seglen);
856 if (te2 == NULL) {
857 *changed = 1;
858 goto done;
861 if (te1->mode != te2->mode) {
862 *changed = 1;
863 goto done;
866 if (got_object_id_cmp(te1->id, te2->id) == 0) {
867 *changed = 0;
868 goto done;
871 if (remain == 0) { /* final path element */
872 *changed = 1;
873 goto done;
876 seg = s + 1;
877 s++;
878 remain--;
879 seglen = 0;
880 if (*s) {
881 err = got_object_open_as_tree(&next_tree1, repo,
882 te1->id);
883 te1 = NULL;
884 if (err)
885 goto done;
886 if (tree1 != tree01)
887 got_object_tree_close(tree1);
888 tree1 = next_tree1;
890 err = got_object_open_as_tree(&next_tree2, repo,
891 te2->id);
892 te2 = NULL;
893 if (err)
894 goto done;
895 if (tree2 != tree02)
896 got_object_tree_close(tree2);
897 tree2 = next_tree2;
900 done:
901 if (tree1 && tree1 != tree01)
902 got_object_tree_close(tree1);
903 if (tree2 && tree2 != tree02)
904 got_object_tree_close(tree2);
905 return err;
908 static void
909 exec_privsep_child(int imsg_fds[2], const char *path, const char *repo_path)
911 close(imsg_fds[0]);
913 if (dup2(imsg_fds[1], GOT_IMSG_FD_CHILD) == -1) {
914 fprintf(stderr, "%s: %s\n", getprogname(),
915 strerror(errno));
916 _exit(1);
918 if (closefrom(GOT_IMSG_FD_CHILD + 1) == -1) {
919 fprintf(stderr, "%s: %s\n", getprogname(),
920 strerror(errno));
921 _exit(1);
924 if (execl(path, path, repo_path, (char *)NULL) == -1) {
925 fprintf(stderr, "%s: %s: %s\n", getprogname(), path,
926 strerror(errno));
927 _exit(1);
931 static const struct got_error *
932 request_object(struct got_object **obj, struct got_repository *repo, int fd)
934 const struct got_error *err = NULL;
935 struct imsgbuf *ibuf;
937 ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
939 err = got_privsep_send_obj_req(ibuf, fd, NULL);
940 if (err)
941 return err;
943 return got_privsep_recv_obj(obj, ibuf);
946 const struct got_error *
947 got_object_read_header_privsep(struct got_object **obj,
948 struct got_repository *repo, int obj_fd)
950 int imsg_fds[2];
951 pid_t pid;
952 struct imsgbuf *ibuf;
954 if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
955 return request_object(obj, repo, obj_fd);
957 ibuf = calloc(1, sizeof(*ibuf));
958 if (ibuf == NULL)
959 return got_error_from_errno();
961 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
962 return got_error_from_errno();
964 pid = fork();
965 if (pid == -1)
966 return got_error_from_errno();
967 else if (pid == 0) {
968 exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_OBJECT,
969 repo->path);
970 /* not reached */
973 close(imsg_fds[1]);
974 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd =
975 imsg_fds[0];
976 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].pid = pid;
977 imsg_init(ibuf, imsg_fds[0]);
978 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf = ibuf;
980 return request_object(obj, repo, obj_fd);
983 static const struct got_error *
984 request_packed_object(struct got_object **obj, struct got_pack *pack, int idx,
985 struct got_object_id *id)
987 const struct got_error *err = NULL;
988 struct imsgbuf *ibuf = pack->privsep_child->ibuf;
990 err = got_privsep_send_packed_obj_req(ibuf, idx, id);
991 if (err)
992 return err;
994 err = got_privsep_recv_obj(obj, ibuf);
995 if (err)
996 return err;
998 (*obj)->path_packfile = strdup(pack->path_packfile);
999 if ((*obj)->path_packfile == NULL) {
1000 err = got_error_from_errno();
1001 return err;
1003 memcpy(&(*obj)->id, id, sizeof((*obj)->id));
1005 return NULL;
1008 const struct got_error *
1009 got_object_packed_read_privsep(struct got_object **obj,
1010 struct got_repository *repo, struct got_pack *pack,
1011 struct got_packidx *packidx, int idx, struct got_object_id *id)
1013 const struct got_error *err = NULL;
1014 int imsg_fds[2];
1015 pid_t pid;
1016 struct imsgbuf *ibuf;
1018 if (pack->privsep_child)
1019 return request_packed_object(obj, pack, idx, id);
1021 ibuf = calloc(1, sizeof(*ibuf));
1022 if (ibuf == NULL)
1023 return got_error_from_errno();
1025 pack->privsep_child = calloc(1, sizeof(*pack->privsep_child));
1026 if (pack->privsep_child == NULL) {
1027 err = got_error_from_errno();
1028 free(ibuf);
1029 return err;
1032 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
1033 err = got_error_from_errno();
1034 goto done;
1037 pid = fork();
1038 if (pid == -1) {
1039 err = got_error_from_errno();
1040 goto done;
1041 } else if (pid == 0) {
1042 exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_PACK,
1043 pack->path_packfile);
1044 /* not reached */
1047 close(imsg_fds[1]);
1048 pack->privsep_child->imsg_fd = imsg_fds[0];
1049 pack->privsep_child->pid = pid;
1050 imsg_init(ibuf, imsg_fds[0]);
1051 pack->privsep_child->ibuf = ibuf;
1053 err = got_privsep_init_pack_child(ibuf, pack, packidx);
1054 if (err) {
1055 const struct got_error *child_err;
1056 err = got_privsep_send_stop(pack->privsep_child->imsg_fd);
1057 child_err = got_privsep_wait_for_child(
1058 pack->privsep_child->pid);
1059 if (child_err && err == NULL)
1060 err = child_err;
1061 free(ibuf);
1062 free(pack->privsep_child);
1063 pack->privsep_child = NULL;
1064 return err;
1067 done:
1068 if (err) {
1069 free(ibuf);
1070 free(pack->privsep_child);
1071 pack->privsep_child = NULL;
1072 } else
1073 err = request_packed_object(obj, pack, idx, id);
1074 return err;
1078 static const struct got_error *
1079 request_commit(struct got_commit_object **commit, struct got_repository *repo,
1080 struct got_object *obj, int fd)
1082 const struct got_error *err = NULL;
1083 struct imsgbuf *ibuf;
1085 ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf;
1087 err = got_privsep_send_obj_req(ibuf, fd, obj);
1088 if (err)
1089 return err;
1091 return got_privsep_recv_commit(commit, ibuf);
1094 const struct got_error *
1095 got_object_read_packed_commit_privsep(struct got_commit_object **commit,
1096 struct got_object *obj, struct got_pack *pack)
1098 const struct got_error *err = NULL;
1100 err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
1101 if (err)
1102 return err;
1104 return got_privsep_recv_commit(commit, pack->privsep_child->ibuf);
1107 const struct got_error *
1108 got_object_read_commit_privsep(struct got_commit_object **commit,
1109 struct got_object *obj, int obj_fd, struct got_repository *repo)
1111 int imsg_fds[2];
1112 pid_t pid;
1113 struct imsgbuf *ibuf;
1115 if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd != -1)
1116 return request_commit(commit, repo, obj, obj_fd);
1118 ibuf = calloc(1, sizeof(*ibuf));
1119 if (ibuf == NULL)
1120 return got_error_from_errno();
1122 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1123 return got_error_from_errno();
1125 pid = fork();
1126 if (pid == -1)
1127 return got_error_from_errno();
1128 else if (pid == 0) {
1129 exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_COMMIT,
1130 repo->path);
1131 /* not reached */
1134 close(imsg_fds[1]);
1135 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd =
1136 imsg_fds[0];
1137 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].pid = pid;
1138 imsg_init(ibuf, imsg_fds[0]);
1139 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf = ibuf;
1141 return request_commit(commit, repo, obj, obj_fd);
1144 static const struct got_error *
1145 request_tree(struct got_tree_object **tree, struct got_repository *repo,
1146 struct got_object *obj, int fd)
1148 const struct got_error *err = NULL;
1149 struct imsgbuf *ibuf;
1151 ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf;
1153 err = got_privsep_send_obj_req(ibuf, fd, obj);
1154 if (err)
1155 return err;
1157 return got_privsep_recv_tree(tree, ibuf);
1160 const struct got_error *
1161 got_object_read_tree_privsep(struct got_tree_object **tree,
1162 struct got_object *obj, int obj_fd, struct got_repository *repo)
1164 int imsg_fds[2];
1165 pid_t pid;
1166 struct imsgbuf *ibuf;
1168 if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd != -1)
1169 return request_tree(tree, repo, obj, obj_fd);
1171 ibuf = calloc(1, sizeof(*ibuf));
1172 if (ibuf == NULL)
1173 return got_error_from_errno();
1175 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1176 return got_error_from_errno();
1178 pid = fork();
1179 if (pid == -1)
1180 return got_error_from_errno();
1181 else if (pid == 0) {
1182 exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_TREE,
1183 repo->path);
1184 /* not reached */
1187 close(imsg_fds[1]);
1189 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd =
1190 imsg_fds[0];
1191 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].pid = pid;
1192 imsg_init(ibuf, imsg_fds[0]);
1193 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf = ibuf;
1196 return request_tree(tree, repo, obj, obj_fd);
1199 const struct got_error *
1200 got_object_read_packed_tree_privsep(struct got_tree_object **tree,
1201 struct got_object *obj, struct got_pack *pack)
1203 const struct got_error *err = NULL;
1205 err = got_privsep_send_obj_req(pack->privsep_child->ibuf, -1, obj);
1206 if (err)
1207 return err;
1209 return got_privsep_recv_tree(tree, pack->privsep_child->ibuf);
1212 static const struct got_error *
1213 request_blob(size_t *size, int outfd, int infd, struct imsgbuf *ibuf)
1215 const struct got_error *err = NULL;
1216 int outfd_child;
1218 outfd_child = dup(outfd);
1219 if (outfd_child == -1)
1220 return got_error_from_errno();
1222 err = got_privsep_send_blob_req(ibuf, infd);
1223 if (err)
1224 return err;
1226 err = got_privsep_send_blob_outfd(ibuf, outfd_child);
1227 if (err) {
1228 close(outfd_child);
1229 return err;
1232 err = got_privsep_recv_blob(size, ibuf);
1233 if (err)
1234 return err;
1236 if (lseek(outfd, SEEK_SET, 0) == -1)
1237 return got_error_from_errno();
1239 return err;
1242 const struct got_error *
1243 got_object_read_blob_privsep(size_t *size, int outfd, int infd,
1244 struct got_repository *repo)
1246 int imsg_fds[2];
1247 pid_t pid;
1248 struct imsgbuf *ibuf;
1250 if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd != -1) {
1251 ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
1252 return request_blob(size, outfd, infd, ibuf);
1255 ibuf = calloc(1, sizeof(*ibuf));
1256 if (ibuf == NULL)
1257 return got_error_from_errno();
1259 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1260 return got_error_from_errno();
1262 pid = fork();
1263 if (pid == -1)
1264 return got_error_from_errno();
1265 else if (pid == 0) {
1266 exec_privsep_child(imsg_fds, GOT_PATH_PROG_READ_BLOB,
1267 repo->path);
1268 /* not reached */
1271 close(imsg_fds[1]);
1272 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd =
1273 imsg_fds[0];
1274 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].pid = pid;
1275 imsg_init(ibuf, imsg_fds[0]);
1276 repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf = ibuf;
1278 return request_blob(size, outfd, infd, ibuf);