2 * Copyright (c) 2018, 2019, 2020 Stefan Sperling <stsp@openbsd.org>
3 * Copyright (c) 2020 Ori Bernstein <ori@openbsd.org>
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 #include <sys/types.h>
19 #include <sys/queue.h>
37 #include "got_object.h"
38 #include "got_error.h"
40 #include "got_repository.h"
42 #include "got_lib_sha1.h"
43 #include "got_lib_delta.h"
44 #include "got_lib_inflate.h"
45 #include "got_lib_object.h"
46 #include "got_lib_object_parse.h"
47 #include "got_lib_privsep.h"
48 #include "got_lib_pack.h"
49 #include "got_lib_poll.h"
51 #include "got_privsep.h"
54 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
58 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
61 static const struct got_error *
62 read_imsg(struct imsgbuf *ibuf)
64 const struct got_error *err;
67 err = got_poll_fd(ibuf->fd, POLLIN, INFTIM);
69 if (err->code == GOT_ERR_EOF)
70 return got_error(GOT_ERR_PRIVSEP_PIPE);
76 if (errno == EAGAIN) /* Could be a file-descriptor leak. */
77 return got_error(GOT_ERR_PRIVSEP_NO_FD);
78 return got_error(GOT_ERR_PRIVSEP_READ);
81 return got_error(GOT_ERR_PRIVSEP_PIPE);
86 const struct got_error *
87 got_privsep_wait_for_child(pid_t pid)
91 if (waitpid(pid, &child_status, 0) == -1)
92 return got_error_from_errno("waitpid");
94 if (!WIFEXITED(child_status))
95 return got_error(GOT_ERR_PRIVSEP_DIED);
97 if (WEXITSTATUS(child_status) != 0)
98 return got_error(GOT_ERR_PRIVSEP_EXIT);
103 static const struct got_error *
104 recv_imsg_error(struct imsg *imsg, size_t datalen)
106 struct got_imsg_error *ierr;
108 if (datalen != sizeof(*ierr))
109 return got_error(GOT_ERR_PRIVSEP_LEN);
112 if (ierr->code == GOT_ERR_ERRNO) {
113 static struct got_error serr;
114 serr.code = GOT_ERR_ERRNO;
115 serr.msg = strerror(ierr->errno_code);
119 return got_error(ierr->code);
122 const struct got_error *
123 got_privsep_recv_imsg(struct imsg *imsg, struct imsgbuf *ibuf,
126 const struct got_error *err;
129 n = imsg_get(ibuf, imsg);
131 return got_error_from_errno("imsg_get");
134 err = read_imsg(ibuf);
137 n = imsg_get(ibuf, imsg);
139 return got_error_from_errno("imsg_get");
142 if (imsg->hdr.len < IMSG_HEADER_SIZE + min_datalen)
143 return got_error(GOT_ERR_PRIVSEP_LEN);
145 if (imsg->hdr.type == GOT_IMSG_ERROR) {
146 size_t datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
147 return recv_imsg_error(imsg, datalen);
153 /* Attempt to send an error in an imsg. Complain on stderr as a last resort. */
155 got_privsep_send_error(struct imsgbuf *ibuf, const struct got_error *err)
157 const struct got_error *poll_err;
158 struct got_imsg_error ierr;
161 ierr.code = err->code;
162 if (err->code == GOT_ERR_ERRNO)
163 ierr.errno_code = errno;
166 ret = imsg_compose(ibuf, GOT_IMSG_ERROR, 0, 0, -1, &ierr, sizeof(ierr));
168 fprintf(stderr, "%s: error %d \"%s\": imsg_compose: %s\n",
169 getprogname(), err->code, err->msg, strerror(errno));
173 poll_err = got_poll_fd(ibuf->fd, POLLOUT, INFTIM);
175 fprintf(stderr, "%s: error %d \"%s\": poll: %s\n",
176 getprogname(), err->code, err->msg, poll_err->msg);
180 ret = imsg_flush(ibuf);
182 fprintf(stderr, "%s: error %d \"%s\": imsg_flush: %s\n",
183 getprogname(), err->code, err->msg, strerror(errno));
189 static const struct got_error *
190 flush_imsg(struct imsgbuf *ibuf)
192 const struct got_error *err;
194 err = got_poll_fd(ibuf->fd, POLLOUT, INFTIM);
198 if (imsg_flush(ibuf) == -1) {
200 return got_error_from_errno("imsg_flush");
206 const struct got_error *
207 got_privsep_flush_imsg(struct imsgbuf *ibuf)
209 return flush_imsg(ibuf);
212 const struct got_error *
213 got_privsep_send_stop(int fd)
215 const struct got_error *err = NULL;
218 imsg_init(&ibuf, fd);
220 if (imsg_compose(&ibuf, GOT_IMSG_STOP, 0, 0, -1, NULL, 0) == -1)
221 return got_error_from_errno("imsg_compose STOP");
223 err = flush_imsg(&ibuf);
227 const struct got_error *
228 got_privsep_send_obj_req(struct imsgbuf *ibuf, int fd,
229 struct got_object_id *id)
231 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_REQUEST, 0, 0, fd,
232 id, sizeof(*id)) == -1)
233 return got_error_from_errno("imsg_compose OBJECT_REQUEST");
235 return flush_imsg(ibuf);
238 const struct got_error *
239 got_privsep_send_raw_obj_req(struct imsgbuf *ibuf, int fd,
240 struct got_object_id *id)
242 if (imsg_compose(ibuf, GOT_IMSG_RAW_OBJECT_REQUEST, 0, 0, fd,
243 id, sizeof(*id)) == -1)
244 return got_error_from_errno("imsg_compose RAW_OBJECT_REQUEST");
246 return flush_imsg(ibuf);
249 const struct got_error *
250 got_privsep_send_raw_obj_outfd(struct imsgbuf *ibuf, int outfd)
252 const struct got_error *err = NULL;
254 if (imsg_compose(ibuf, GOT_IMSG_RAW_OBJECT_OUTFD, 0, 0, outfd, NULL, 0)
256 err = got_error_from_errno("imsg_compose RAW_OBJECT_OUTFD");
261 return flush_imsg(ibuf);
264 const struct got_error *
265 got_privsep_send_raw_obj(struct imsgbuf *ibuf, off_t size, size_t hdrlen,
268 const struct got_error *err = NULL;
269 struct got_imsg_raw_obj iobj;
270 size_t len = sizeof(iobj);
273 memset(&iobj, 0, sizeof(iobj));
274 iobj.hdrlen = hdrlen;
277 if (data && size + hdrlen <= GOT_PRIVSEP_INLINE_OBJECT_DATA_MAX)
278 len += (size_t)size + hdrlen;
280 wbuf = imsg_create(ibuf, GOT_IMSG_RAW_OBJECT, 0, 0, len);
282 err = got_error_from_errno("imsg_create RAW_OBJECT");
286 if (imsg_add(wbuf, &iobj, sizeof(iobj)) == -1)
287 return got_error_from_errno("imsg_add RAW_OBJECT");
289 if (data && size + hdrlen <= GOT_PRIVSEP_INLINE_OBJECT_DATA_MAX) {
290 if (imsg_add(wbuf, data, size + hdrlen) == -1)
291 return got_error_from_errno("imsg_add RAW_OBJECT");
295 imsg_close(ibuf, wbuf);
297 return flush_imsg(ibuf);
300 const struct got_error *
301 got_privsep_recv_raw_obj(uint8_t **outbuf, off_t *size, size_t *hdrlen,
302 struct imsgbuf *ibuf)
304 const struct got_error *err = NULL;
306 struct got_imsg_raw_obj *iobj;
311 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
315 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
317 switch (imsg.hdr.type) {
318 case GOT_IMSG_RAW_OBJECT:
319 if (datalen < sizeof(*iobj)) {
320 err = got_error(GOT_ERR_PRIVSEP_LEN);
325 *hdrlen = iobj->hdrlen;
327 if (datalen == sizeof(*iobj)) {
328 /* Data has been written to file descriptor. */
333 *size + *hdrlen > GOT_PRIVSEP_INLINE_OBJECT_DATA_MAX) {
334 err = got_error(GOT_ERR_PRIVSEP_LEN);
338 *outbuf = malloc(*size + *hdrlen);
339 if (*outbuf == NULL) {
340 err = got_error_from_errno("malloc");
343 memcpy(*outbuf, imsg.data + sizeof(*iobj), *size + *hdrlen);
346 err = got_error(GOT_ERR_PRIVSEP_MSG);
355 const struct got_error *
356 got_privsep_send_commit_req(struct imsgbuf *ibuf, int fd,
357 struct got_object_id *id, int pack_idx)
359 const struct got_error *err = NULL;
360 struct got_imsg_packed_object iobj;
364 memset(&iobj, 0, sizeof(iobj));
365 if (pack_idx != -1) { /* commit is packed */
367 memcpy(&iobj.id, id, sizeof(iobj.id));
375 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_REQUEST, 0, 0, fd, data, len)
377 err = got_error_from_errno("imsg_compose COMMIT_REQUEST");
382 return flush_imsg(ibuf);
385 const struct got_error *
386 got_privsep_send_tree_req(struct imsgbuf *ibuf, int fd,
387 struct got_object_id *id, int pack_idx)
393 len = sizeof(struct got_imsg_packed_object);
397 wbuf = imsg_create(ibuf, GOT_IMSG_TREE_REQUEST, 0, 0, len);
399 return got_error_from_errno("imsg_create TREE_REQUEST");
401 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
402 return got_error_from_errno("imsg_add TREE_REQUEST");
404 if (pack_idx != -1) { /* tree is packed */
405 if (imsg_add(wbuf, &pack_idx, sizeof(pack_idx)) == -1)
406 return got_error_from_errno("imsg_add TREE_REQUEST");
410 imsg_close(ibuf, wbuf);
412 return flush_imsg(ibuf);
415 const struct got_error *
416 got_privsep_send_tag_req(struct imsgbuf *ibuf, int fd,
417 struct got_object_id *id, int pack_idx)
419 struct got_imsg_packed_object iobj;
423 memset(&iobj, 0, sizeof(iobj));
424 if (pack_idx != -1) { /* tag is packed */
426 memcpy(&iobj.id, id, sizeof(iobj.id));
434 if (imsg_compose(ibuf, GOT_IMSG_TAG_REQUEST, 0, 0, fd, data, len)
436 return got_error_from_errno("imsg_compose TAG_REQUEST");
438 return flush_imsg(ibuf);
441 const struct got_error *
442 got_privsep_send_blob_req(struct imsgbuf *ibuf, int infd,
443 struct got_object_id *id, int pack_idx)
445 const struct got_error *err = NULL;
446 struct got_imsg_packed_object iobj;
450 memset(&iobj, 0, sizeof(iobj));
451 if (pack_idx != -1) { /* blob is packed */
453 memcpy(&iobj.id, id, sizeof(iobj.id));
461 if (imsg_compose(ibuf, GOT_IMSG_BLOB_REQUEST, 0, 0, infd, data, len)
463 err = got_error_from_errno("imsg_compose BLOB_REQUEST");
468 return flush_imsg(ibuf);
471 const struct got_error *
472 got_privsep_send_blob_outfd(struct imsgbuf *ibuf, int outfd)
474 const struct got_error *err = NULL;
476 if (imsg_compose(ibuf, GOT_IMSG_BLOB_OUTFD, 0, 0, outfd, NULL, 0)
478 err = got_error_from_errno("imsg_compose BLOB_OUTFD");
483 return flush_imsg(ibuf);
486 static const struct got_error *
487 send_fd(struct imsgbuf *ibuf, int imsg_code, int fd)
489 const struct got_error *err = NULL;
491 if (imsg_compose(ibuf, imsg_code, 0, 0, fd, NULL, 0) == -1) {
492 err = got_error_from_errno("imsg_compose TMPFD");
497 return flush_imsg(ibuf);
500 const struct got_error *
501 got_privsep_send_tmpfd(struct imsgbuf *ibuf, int fd)
503 return send_fd(ibuf, GOT_IMSG_TMPFD, fd);
506 const struct got_error *
507 got_privsep_send_obj(struct imsgbuf *ibuf, struct got_object *obj)
509 struct got_imsg_object iobj;
511 memset(&iobj, 0, sizeof(iobj));
513 memcpy(&iobj.id, &obj->id, sizeof(iobj.id));
514 iobj.type = obj->type;
515 iobj.flags = obj->flags;
516 iobj.hdrlen = obj->hdrlen;
517 iobj.size = obj->size;
518 if (iobj.flags & GOT_OBJ_FLAG_PACKED) {
519 iobj.pack_offset = obj->pack_offset;
520 iobj.pack_idx = obj->pack_idx;
523 if (imsg_compose(ibuf, GOT_IMSG_OBJECT, 0, 0, -1, &iobj, sizeof(iobj))
525 return got_error_from_errno("imsg_compose OBJECT");
527 return flush_imsg(ibuf);
530 const struct got_error *
531 got_privsep_send_fetch_req(struct imsgbuf *ibuf, int fd,
532 struct got_pathlist_head *have_refs, int fetch_all_branches,
533 struct got_pathlist_head *wanted_branches,
534 struct got_pathlist_head *wanted_refs, int list_refs_only, int verbosity)
536 const struct got_error *err = NULL;
539 struct got_pathlist_entry *pe;
540 struct got_imsg_fetch_request fetchreq;
542 memset(&fetchreq, 0, sizeof(fetchreq));
543 fetchreq.fetch_all_branches = fetch_all_branches;
544 fetchreq.list_refs_only = list_refs_only;
545 fetchreq.verbosity = verbosity;
546 TAILQ_FOREACH(pe, have_refs, entry)
547 fetchreq.n_have_refs++;
548 TAILQ_FOREACH(pe, wanted_branches, entry)
549 fetchreq.n_wanted_branches++;
550 TAILQ_FOREACH(pe, wanted_refs, entry)
551 fetchreq.n_wanted_refs++;
552 len = sizeof(struct got_imsg_fetch_request);
553 if (len >= MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
555 return got_error(GOT_ERR_NO_SPACE);
558 if (imsg_compose(ibuf, GOT_IMSG_FETCH_REQUEST, 0, 0, fd,
559 &fetchreq, sizeof(fetchreq)) == -1)
560 return got_error_from_errno(
561 "imsg_compose FETCH_SERVER_PROGRESS");
563 err = flush_imsg(ibuf);
570 TAILQ_FOREACH(pe, have_refs, entry) {
571 const char *name = pe->path;
572 size_t name_len = pe->path_len;
573 struct got_object_id *id = pe->data;
575 len = sizeof(struct got_imsg_fetch_have_ref) + name_len;
576 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_HAVE_REF, 0, 0, len);
578 return got_error_from_errno("imsg_create FETCH_HAVE_REF");
580 /* Keep in sync with struct got_imsg_fetch_have_ref! */
581 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
582 return got_error_from_errno("imsg_add FETCH_HAVE_REF");
583 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
584 return got_error_from_errno("imsg_add FETCH_HAVE_REF");
585 if (imsg_add(wbuf, name, name_len) == -1)
586 return got_error_from_errno("imsg_add FETCH_HAVE_REF");
589 imsg_close(ibuf, wbuf);
590 err = flush_imsg(ibuf);
595 TAILQ_FOREACH(pe, wanted_branches, entry) {
596 const char *name = pe->path;
597 size_t name_len = pe->path_len;
599 len = sizeof(struct got_imsg_fetch_wanted_branch) + name_len;
600 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_WANTED_BRANCH, 0, 0,
603 return got_error_from_errno(
604 "imsg_create FETCH_WANTED_BRANCH");
606 /* Keep in sync with struct got_imsg_fetch_wanted_branch! */
607 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
608 return got_error_from_errno(
609 "imsg_add FETCH_WANTED_BRANCH");
610 if (imsg_add(wbuf, name, name_len) == -1)
611 return got_error_from_errno(
612 "imsg_add FETCH_WANTED_BRANCH");
615 imsg_close(ibuf, wbuf);
616 err = flush_imsg(ibuf);
621 TAILQ_FOREACH(pe, wanted_refs, entry) {
622 const char *name = pe->path;
623 size_t name_len = pe->path_len;
625 len = sizeof(struct got_imsg_fetch_wanted_ref) + name_len;
626 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_WANTED_REF, 0, 0,
629 return got_error_from_errno(
630 "imsg_create FETCH_WANTED_REF");
632 /* Keep in sync with struct got_imsg_fetch_wanted_ref! */
633 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
634 return got_error_from_errno(
635 "imsg_add FETCH_WANTED_REF");
636 if (imsg_add(wbuf, name, name_len) == -1)
637 return got_error_from_errno(
638 "imsg_add FETCH_WANTED_REF");
641 imsg_close(ibuf, wbuf);
642 err = flush_imsg(ibuf);
652 const struct got_error *
653 got_privsep_send_fetch_outfd(struct imsgbuf *ibuf, int fd)
655 return send_fd(ibuf, GOT_IMSG_FETCH_OUTFD, fd);
658 const struct got_error *
659 got_privsep_recv_fetch_progress(int *done, struct got_object_id **id,
660 char **refname, struct got_pathlist_head *symrefs, char **server_progress,
661 off_t *packfile_size, uint8_t *pack_sha1, struct imsgbuf *ibuf)
663 const struct got_error *err = NULL;
666 struct got_imsg_fetch_symrefs *isymrefs = NULL;
674 *server_progress = NULL;
676 memset(pack_sha1, 0, SHA1_DIGEST_LENGTH);
678 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
682 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
683 switch (imsg.hdr.type) {
684 case GOT_IMSG_FETCH_SYMREFS:
685 if (datalen < sizeof(*isymrefs)) {
686 err = got_error(GOT_ERR_PRIVSEP_LEN);
689 if (isymrefs != NULL) {
690 err = got_error(GOT_ERR_PRIVSEP_MSG);
693 isymrefs = (struct got_imsg_fetch_symrefs *)imsg.data;
694 off = sizeof(*isymrefs);
695 remain = datalen - off;
696 for (n = 0; n < isymrefs->nsymrefs; n++) {
697 struct got_imsg_fetch_symref *s;
699 if (remain < sizeof(struct got_imsg_fetch_symref)) {
700 err = got_error(GOT_ERR_PRIVSEP_LEN);
703 s = (struct got_imsg_fetch_symref *)(imsg.data + off);
705 remain -= sizeof(*s);
706 if (remain < s->name_len) {
707 err = got_error(GOT_ERR_PRIVSEP_LEN);
710 name = strndup(imsg.data + off, s->name_len);
712 err = got_error_from_errno("strndup");
716 remain -= s->name_len;
717 if (remain < s->target_len) {
718 err = got_error(GOT_ERR_PRIVSEP_LEN);
722 target = strndup(imsg.data + off, s->target_len);
723 if (target == NULL) {
724 err = got_error_from_errno("strndup");
728 off += s->target_len;
729 remain -= s->target_len;
730 err = got_pathlist_append(symrefs, name, target);
738 case GOT_IMSG_FETCH_REF:
739 if (datalen <= sizeof(**id)) {
740 err = got_error(GOT_ERR_PRIVSEP_MSG);
743 *id = malloc(sizeof(**id));
745 err = got_error_from_errno("malloc");
748 memcpy(*id, imsg.data, sizeof(**id));
749 *refname = strndup(imsg.data + sizeof(**id),
750 datalen - sizeof(**id));
751 if (*refname == NULL) {
752 err = got_error_from_errno("strndup");
756 case GOT_IMSG_FETCH_SERVER_PROGRESS:
758 err = got_error(GOT_ERR_PRIVSEP_LEN);
761 *server_progress = strndup(imsg.data, datalen);
762 if (*server_progress == NULL) {
763 err = got_error_from_errno("strndup");
766 for (i = 0; i < datalen; i++) {
767 if (!isprint((unsigned char)(*server_progress)[i]) &&
768 !isspace((unsigned char)(*server_progress)[i])) {
769 err = got_error(GOT_ERR_PRIVSEP_MSG);
770 free(*server_progress);
771 *server_progress = NULL;
776 case GOT_IMSG_FETCH_DOWNLOAD_PROGRESS:
777 if (datalen < sizeof(*packfile_size)) {
778 err = got_error(GOT_ERR_PRIVSEP_MSG);
781 memcpy(packfile_size, imsg.data, sizeof(*packfile_size));
783 case GOT_IMSG_FETCH_DONE:
784 if (datalen != SHA1_DIGEST_LENGTH) {
785 err = got_error(GOT_ERR_PRIVSEP_MSG);
788 memcpy(pack_sha1, imsg.data, SHA1_DIGEST_LENGTH);
792 err = got_error(GOT_ERR_PRIVSEP_MSG);
806 static const struct got_error *
807 send_send_ref(const char *name, size_t name_len, struct got_object_id *id,
808 int delete, struct imsgbuf *ibuf)
813 len = sizeof(struct got_imsg_send_ref) + name_len;
814 wbuf = imsg_create(ibuf, GOT_IMSG_SEND_REF, 0, 0, len);
816 return got_error_from_errno("imsg_create SEND_REF");
818 /* Keep in sync with struct got_imsg_send_ref! */
819 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
820 return got_error_from_errno("imsg_add SEND_REF");
821 if (imsg_add(wbuf, &delete, sizeof(delete)) == -1)
822 return got_error_from_errno("imsg_add SEND_REF");
823 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
824 return got_error_from_errno("imsg_add SEND_REF");
825 if (imsg_add(wbuf, name, name_len) == -1)
826 return got_error_from_errno("imsg_add SEND_REF");
829 imsg_close(ibuf, wbuf);
830 return flush_imsg(ibuf);
833 const struct got_error *
834 got_privsep_send_send_req(struct imsgbuf *ibuf, int fd,
835 struct got_pathlist_head *have_refs,
836 struct got_pathlist_head *delete_refs,
839 const struct got_error *err = NULL;
840 struct got_pathlist_entry *pe;
841 struct got_imsg_send_request sendreq;
842 struct got_object_id zero_id;
844 memset(&zero_id, 0, sizeof(zero_id));
845 memset(&sendreq, 0, sizeof(sendreq));
846 sendreq.verbosity = verbosity;
847 TAILQ_FOREACH(pe, have_refs, entry)
849 TAILQ_FOREACH(pe, delete_refs, entry)
851 if (imsg_compose(ibuf, GOT_IMSG_SEND_REQUEST, 0, 0, fd,
852 &sendreq, sizeof(sendreq)) == -1) {
853 err = got_error_from_errno(
854 "imsg_compose FETCH_SERVER_PROGRESS");
858 err = flush_imsg(ibuf);
863 TAILQ_FOREACH(pe, have_refs, entry) {
864 const char *name = pe->path;
865 size_t name_len = pe->path_len;
866 struct got_object_id *id = pe->data;
867 err = send_send_ref(name, name_len, id, 0, ibuf);
872 TAILQ_FOREACH(pe, delete_refs, entry) {
873 const char *name = pe->path;
874 size_t name_len = pe->path_len;
875 err = send_send_ref(name, name_len, &zero_id, 1, ibuf);
880 if (fd != -1 && close(fd) == -1 && err == NULL)
881 err = got_error_from_errno("close");
886 const struct got_error *
887 got_privsep_recv_send_remote_refs(struct got_pathlist_head *remote_refs,
888 struct imsgbuf *ibuf)
890 const struct got_error *err = NULL;
894 struct got_imsg_send_remote_ref iremote_ref;
895 struct got_object_id *id = NULL;
896 char *refname = NULL;
897 struct got_pathlist_entry *new;
900 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
903 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
904 switch (imsg.hdr.type) {
905 case GOT_IMSG_SEND_REMOTE_REF:
906 if (datalen < sizeof(iremote_ref)) {
907 err = got_error(GOT_ERR_PRIVSEP_MSG);
910 memcpy(&iremote_ref, imsg.data, sizeof(iremote_ref));
911 if (datalen != sizeof(iremote_ref) +
912 iremote_ref.name_len) {
913 err = got_error(GOT_ERR_PRIVSEP_MSG);
916 id = malloc(sizeof(*id));
918 err = got_error_from_errno("malloc");
921 memcpy(id, &iremote_ref.id, sizeof(*id));
922 refname = strndup(imsg.data + sizeof(iremote_ref),
923 datalen - sizeof(iremote_ref));
924 if (refname == NULL) {
925 err = got_error_from_errno("strndup");
928 err = got_pathlist_insert(&new, remote_refs,
932 if (new == NULL) { /* duplicate which wasn't inserted */
939 case GOT_IMSG_SEND_PACK_REQUEST:
941 err = got_error(GOT_ERR_PRIVSEP_MSG);
944 /* got-send-pack is now waiting for a pack file. */
948 err = got_error(GOT_ERR_PRIVSEP_MSG);
959 const struct got_error *
960 got_privsep_send_packfd(struct imsgbuf *ibuf, int fd)
962 return send_fd(ibuf, GOT_IMSG_SEND_PACKFD, fd);
965 const struct got_error *
966 got_privsep_recv_send_progress(int *done, off_t *bytes_sent,
967 int *success, char **refname, char **errmsg, struct imsgbuf *ibuf)
969 const struct got_error *err = NULL;
972 struct got_imsg_send_ref_status iref_status;
974 /* Do not reset the current value of 'bytes_sent', it accumulates. */
980 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
984 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
985 switch (imsg.hdr.type) {
986 case GOT_IMSG_SEND_UPLOAD_PROGRESS:
987 if (datalen < sizeof(*bytes_sent)) {
988 err = got_error(GOT_ERR_PRIVSEP_MSG);
991 memcpy(bytes_sent, imsg.data, sizeof(*bytes_sent));
993 case GOT_IMSG_SEND_REF_STATUS:
994 if (datalen < sizeof(iref_status)) {
995 err = got_error(GOT_ERR_PRIVSEP_MSG);
998 memcpy(&iref_status, imsg.data, sizeof(iref_status));
999 if (datalen != sizeof(iref_status) + iref_status.name_len +
1000 iref_status.errmsg_len) {
1001 err = got_error(GOT_ERR_PRIVSEP_MSG);
1004 *success = iref_status.success;
1005 *refname = strndup(imsg.data + sizeof(iref_status),
1006 iref_status.name_len);
1008 if (iref_status.errmsg_len != 0)
1009 *errmsg = strndup(imsg.data + sizeof(iref_status) +
1010 iref_status.name_len, iref_status.errmsg_len);
1012 case GOT_IMSG_SEND_DONE:
1014 err = got_error(GOT_ERR_PRIVSEP_MSG);
1020 err = got_error(GOT_ERR_PRIVSEP_MSG);
1028 const struct got_error *
1029 got_privsep_send_index_pack_req(struct imsgbuf *ibuf, uint8_t *pack_sha1,
1032 const struct got_error *err = NULL;
1034 /* Keep in sync with struct got_imsg_index_pack_request */
1035 if (imsg_compose(ibuf, GOT_IMSG_IDXPACK_REQUEST, 0, 0, fd,
1036 pack_sha1, SHA1_DIGEST_LENGTH) == -1) {
1037 err = got_error_from_errno("imsg_compose INDEX_REQUEST");
1041 return flush_imsg(ibuf);
1044 const struct got_error *
1045 got_privsep_send_index_pack_outfd(struct imsgbuf *ibuf, int fd)
1047 return send_fd(ibuf, GOT_IMSG_IDXPACK_OUTFD, fd);
1050 const struct got_error *
1051 got_privsep_recv_index_progress(int *done, int *nobj_total,
1052 int *nobj_indexed, int *nobj_loose, int *nobj_resolved,
1053 struct imsgbuf *ibuf)
1055 const struct got_error *err = NULL;
1057 struct got_imsg_index_pack_progress *iprogress;
1065 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
1069 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1070 switch (imsg.hdr.type) {
1071 case GOT_IMSG_IDXPACK_PROGRESS:
1072 if (datalen < sizeof(*iprogress)) {
1073 err = got_error(GOT_ERR_PRIVSEP_LEN);
1076 iprogress = (struct got_imsg_index_pack_progress *)imsg.data;
1077 if (iprogress->nobj_total < 0 || iprogress->nobj_indexed < 0 ||
1078 iprogress->nobj_loose < 0 || iprogress->nobj_resolved < 0) {
1079 err = got_error(GOT_ERR_RANGE);
1082 *nobj_total = iprogress->nobj_total;
1083 *nobj_indexed = iprogress->nobj_indexed;
1084 *nobj_loose = iprogress->nobj_loose;
1085 *nobj_resolved = iprogress->nobj_resolved;
1087 case GOT_IMSG_IDXPACK_DONE:
1089 err = got_error(GOT_ERR_PRIVSEP_LEN);
1095 err = got_error(GOT_ERR_PRIVSEP_MSG);
1103 const struct got_error *
1104 got_privsep_get_imsg_obj(struct got_object **obj, struct imsg *imsg,
1105 struct imsgbuf *ibuf)
1107 struct got_imsg_object *iobj;
1108 size_t datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1110 if (datalen != sizeof(*iobj))
1111 return got_error(GOT_ERR_PRIVSEP_LEN);
1114 if (iobj->pack_offset < 0)
1115 return got_error(GOT_ERR_PACK_OFFSET);
1117 *obj = calloc(1, sizeof(**obj));
1119 return got_error_from_errno("calloc");
1121 memcpy(&(*obj)->id, &iobj->id, sizeof(iobj->id));
1122 (*obj)->type = iobj->type;
1123 (*obj)->flags = iobj->flags;
1124 (*obj)->hdrlen = iobj->hdrlen;
1125 (*obj)->size = iobj->size;
1126 /* path_packfile is handled by caller */
1127 if (iobj->flags & GOT_OBJ_FLAG_PACKED) {
1128 (*obj)->pack_offset = iobj->pack_offset;
1129 (*obj)->pack_idx = iobj->pack_idx;
1131 STAILQ_INIT(&(*obj)->deltas.entries);
1135 const struct got_error *
1136 got_privsep_recv_obj(struct got_object **obj, struct imsgbuf *ibuf)
1138 const struct got_error *err = NULL;
1140 const size_t min_datalen =
1141 MIN(sizeof(struct got_imsg_error), sizeof(struct got_imsg_object));
1145 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1149 switch (imsg.hdr.type) {
1150 case GOT_IMSG_OBJECT:
1151 err = got_privsep_get_imsg_obj(obj, &imsg, ibuf);
1154 err = got_error(GOT_ERR_PRIVSEP_MSG);
1163 static const struct got_error *
1164 send_commit_logmsg(struct imsgbuf *ibuf, struct got_commit_object *commit,
1167 const struct got_error *err = NULL;
1168 size_t offset, remain;
1171 remain = logmsg_len;
1172 while (remain > 0) {
1173 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE, remain);
1175 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_LOGMSG, 0, 0, -1,
1176 commit->logmsg + offset, n) == -1) {
1177 err = got_error_from_errno("imsg_compose "
1182 err = flush_imsg(ibuf);
1193 const struct got_error *
1194 got_privsep_send_commit(struct imsgbuf *ibuf, struct got_commit_object *commit)
1196 const struct got_error *err = NULL;
1197 struct got_imsg_commit_object *icommit;
1200 struct got_object_qid *qid;
1201 size_t author_len = strlen(commit->author);
1202 size_t committer_len = strlen(commit->committer);
1203 size_t logmsg_len = strlen(commit->logmsg);
1205 total = sizeof(*icommit) + author_len + committer_len +
1206 commit->nparents * sizeof(struct got_object_id);
1208 buf = malloc(total);
1210 return got_error_from_errno("malloc");
1212 icommit = (struct got_imsg_commit_object *)buf;
1213 memcpy(&icommit->tree_id, commit->tree_id, sizeof(icommit->tree_id));
1214 icommit->author_len = author_len;
1215 icommit->author_time = commit->author_time;
1216 icommit->author_gmtoff = commit->author_gmtoff;
1217 icommit->committer_len = committer_len;
1218 icommit->committer_time = commit->committer_time;
1219 icommit->committer_gmtoff = commit->committer_gmtoff;
1220 icommit->logmsg_len = logmsg_len;
1221 icommit->nparents = commit->nparents;
1223 len = sizeof(*icommit);
1224 memcpy(buf + len, commit->author, author_len);
1226 memcpy(buf + len, commit->committer, committer_len);
1227 len += committer_len;
1228 STAILQ_FOREACH(qid, &commit->parent_ids, entry) {
1229 memcpy(buf + len, &qid->id, sizeof(qid->id));
1230 len += sizeof(qid->id);
1233 if (imsg_compose(ibuf, GOT_IMSG_COMMIT, 0, 0, -1, buf, len) == -1) {
1234 err = got_error_from_errno("imsg_compose COMMIT");
1238 if (logmsg_len == 0 ||
1239 logmsg_len + len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
1240 err = flush_imsg(ibuf);
1244 err = send_commit_logmsg(ibuf, commit, logmsg_len);
1250 static const struct got_error *
1251 get_commit_from_imsg(struct got_commit_object **commit,
1252 struct imsg *imsg, size_t datalen, struct imsgbuf *ibuf)
1254 const struct got_error *err = NULL;
1255 struct got_imsg_commit_object *icommit;
1259 if (datalen < sizeof(*icommit))
1260 return got_error(GOT_ERR_PRIVSEP_LEN);
1262 icommit = imsg->data;
1263 if (datalen != sizeof(*icommit) + icommit->author_len +
1264 icommit->committer_len +
1265 icommit->nparents * sizeof(struct got_object_id))
1266 return got_error(GOT_ERR_PRIVSEP_LEN);
1268 if (icommit->nparents < 0)
1269 return got_error(GOT_ERR_PRIVSEP_LEN);
1271 len += sizeof(*icommit);
1273 *commit = got_object_commit_alloc_partial();
1274 if (*commit == NULL)
1275 return got_error_from_errno(
1276 "got_object_commit_alloc_partial");
1278 memcpy((*commit)->tree_id, &icommit->tree_id,
1279 sizeof(icommit->tree_id));
1280 (*commit)->author_time = icommit->author_time;
1281 (*commit)->author_gmtoff = icommit->author_gmtoff;
1282 (*commit)->committer_time = icommit->committer_time;
1283 (*commit)->committer_gmtoff = icommit->committer_gmtoff;
1285 (*commit)->author = strndup(imsg->data + len, icommit->author_len);
1286 if ((*commit)->author == NULL) {
1287 err = got_error_from_errno("strndup");
1290 len += icommit->author_len;
1292 (*commit)->committer = strndup(imsg->data + len,
1293 icommit->committer_len);
1294 if ((*commit)->committer == NULL) {
1295 err = got_error_from_errno("strndup");
1298 len += icommit->committer_len;
1300 if (icommit->logmsg_len == 0) {
1301 (*commit)->logmsg = strdup("");
1302 if ((*commit)->logmsg == NULL) {
1303 err = got_error_from_errno("strdup");
1307 size_t offset = 0, remain = icommit->logmsg_len;
1309 (*commit)->logmsg = malloc(icommit->logmsg_len + 1);
1310 if ((*commit)->logmsg == NULL) {
1311 err = got_error_from_errno("malloc");
1314 while (remain > 0) {
1315 struct imsg imsg_log;
1316 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE,
1319 err = got_privsep_recv_imsg(&imsg_log, ibuf, n);
1323 if (imsg_log.hdr.type != GOT_IMSG_COMMIT_LOGMSG) {
1324 err = got_error(GOT_ERR_PRIVSEP_MSG);
1328 memcpy((*commit)->logmsg + offset,
1330 imsg_free(&imsg_log);
1334 (*commit)->logmsg[icommit->logmsg_len] = '\0';
1337 for (i = 0; i < icommit->nparents; i++) {
1338 struct got_object_qid *qid;
1340 err = got_object_qid_alloc_partial(&qid);
1343 memcpy(&qid->id, imsg->data + len +
1344 i * sizeof(qid->id), sizeof(qid->id));
1345 STAILQ_INSERT_TAIL(&(*commit)->parent_ids, qid, entry);
1346 (*commit)->nparents++;
1350 got_object_commit_close(*commit);
1356 const struct got_error *
1357 got_privsep_recv_commit(struct got_commit_object **commit, struct imsgbuf *ibuf)
1359 const struct got_error *err = NULL;
1362 const size_t min_datalen =
1363 MIN(sizeof(struct got_imsg_error),
1364 sizeof(struct got_imsg_commit_object));
1368 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1372 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1374 switch (imsg.hdr.type) {
1375 case GOT_IMSG_COMMIT:
1376 err = get_commit_from_imsg(commit, &imsg, datalen, ibuf);
1379 err = got_error(GOT_ERR_PRIVSEP_MSG);
1388 static const struct got_error *
1389 send_tree_entries_batch(struct imsgbuf *ibuf,
1390 struct got_parsed_tree_entry *entries, int idx0, int idxN, size_t len)
1393 struct got_imsg_tree_entries ientries;
1396 memset(&ientries, 0, sizeof(ientries));
1398 wbuf = imsg_create(ibuf, GOT_IMSG_TREE_ENTRIES, 0, 0, len);
1400 return got_error_from_errno("imsg_create TREE_ENTRY");
1402 ientries.nentries = idxN - idx0 + 1;
1403 if (imsg_add(wbuf, &ientries, sizeof(ientries)) == -1)
1404 return got_error_from_errno("imsg_add TREE_ENTRY");
1406 for (i = idx0; i <= idxN; i++) {
1407 struct got_parsed_tree_entry *pte = &entries[i];
1409 /* Keep in sync with struct got_imsg_tree_entry definition! */
1410 if (imsg_add(wbuf, pte->id, SHA1_DIGEST_LENGTH) == -1)
1411 return got_error_from_errno("imsg_add TREE_ENTRY");
1412 if (imsg_add(wbuf, &pte->mode, sizeof(pte->mode)) == -1)
1413 return got_error_from_errno("imsg_add TREE_ENTRY");
1414 if (imsg_add(wbuf, &pte->namelen, sizeof(pte->namelen)) == -1)
1415 return got_error_from_errno("imsg_add TREE_ENTRY");
1417 /* Remaining bytes are the entry's name. */
1418 if (imsg_add(wbuf, pte->name, pte->namelen) == -1)
1419 return got_error_from_errno("imsg_add TREE_ENTRY");
1423 imsg_close(ibuf, wbuf);
1427 static const struct got_error *
1428 send_tree_entries(struct imsgbuf *ibuf, struct got_parsed_tree_entry *entries,
1431 const struct got_error *err = NULL;
1433 size_t entries_len = sizeof(struct got_imsg_tree_entries);
1436 for (j = 0; j < nentries; j++) {
1437 struct got_parsed_tree_entry *pte = &entries[j];
1438 size_t len = SHA1_DIGEST_LENGTH + sizeof(pte->mode) +
1439 sizeof(pte->namelen) + pte->namelen;
1442 entries_len + len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
1443 err = send_tree_entries_batch(ibuf, entries,
1444 i, j - 1, entries_len);
1448 entries_len = sizeof(struct got_imsg_tree_entries);
1455 err = send_tree_entries_batch(ibuf, entries, i, j - 1,
1464 const struct got_error *
1465 got_privsep_send_tree(struct imsgbuf *ibuf,
1466 struct got_parsed_tree_entry *entries, int nentries)
1468 const struct got_error *err = NULL;
1469 struct got_imsg_tree_object itree;
1471 memset(&itree, 0, sizeof(itree));
1472 itree.nentries = nentries;
1473 if (imsg_compose(ibuf, GOT_IMSG_TREE, 0, 0, -1, &itree, sizeof(itree))
1475 return got_error_from_errno("imsg_compose TREE");
1477 err = send_tree_entries(ibuf, entries, nentries);
1481 return flush_imsg(ibuf);
1485 static const struct got_error *
1486 recv_tree_entries(void *data, size_t datalen, struct got_tree_object *tree,
1489 const struct got_error *err = NULL;
1490 struct got_imsg_tree_entries *ientries;
1491 struct got_tree_entry *te;
1495 if (datalen <= sizeof(*ientries) ||
1496 datalen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
1497 return got_error(GOT_ERR_PRIVSEP_LEN);
1499 ientries = (struct got_imsg_tree_entries *)data;
1500 if (ientries->nentries > INT_MAX) {
1501 return got_error_msg(GOT_ERR_NO_SPACE,
1502 "too many tree entries");
1505 te_offset = sizeof(*ientries);
1506 for (i = 0; i < ientries->nentries; i++) {
1507 struct got_imsg_tree_entry ite;
1508 const char *te_name;
1509 uint8_t *buf = (uint8_t *)data + te_offset;
1511 if (te_offset >= datalen) {
1512 err = got_error(GOT_ERR_PRIVSEP_LEN);
1516 /* Might not be aligned, size is ~32 bytes. */
1517 memcpy(&ite, buf, sizeof(ite));
1519 if (ite.namelen >= sizeof(te->name)) {
1520 err = got_error(GOT_ERR_PRIVSEP_LEN);
1523 if (te_offset + sizeof(ite) + ite.namelen > datalen) {
1524 err = got_error(GOT_ERR_PRIVSEP_LEN);
1528 if (*nentries >= tree->nentries) {
1529 err = got_error(GOT_ERR_PRIVSEP_LEN);
1532 te = &tree->entries[*nentries];
1533 te_name = buf + sizeof(ite);
1534 memcpy(te->name, te_name, ite.namelen);
1535 te->name[ite.namelen] = '\0';
1536 memcpy(te->id.sha1, ite.id, SHA1_DIGEST_LENGTH);
1537 te->mode = ite.mode;
1538 te->idx = *nentries;
1541 te_offset += sizeof(ite) + ite.namelen;
1547 const struct got_error *
1548 got_privsep_recv_tree(struct got_tree_object **tree, struct imsgbuf *ibuf)
1550 const struct got_error *err = NULL;
1551 const size_t min_datalen =
1552 MIN(sizeof(struct got_imsg_error),
1553 sizeof(struct got_imsg_tree_object));
1554 struct got_imsg_tree_object *itree;
1559 while (*tree == NULL || nentries < (*tree)->nentries) {
1563 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1567 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1569 switch (imsg.hdr.type) {
1571 /* This message should only appear once. */
1572 if (*tree != NULL) {
1573 err = got_error(GOT_ERR_PRIVSEP_MSG);
1576 if (datalen != sizeof(*itree)) {
1577 err = got_error(GOT_ERR_PRIVSEP_LEN);
1581 if (itree->nentries < 0) {
1582 err = got_error(GOT_ERR_PRIVSEP_LEN);
1585 *tree = malloc(sizeof(**tree));
1586 if (*tree == NULL) {
1587 err = got_error_from_errno("malloc");
1590 (*tree)->entries = calloc(itree->nentries,
1591 sizeof(struct got_tree_entry));
1592 if ((*tree)->entries == NULL) {
1593 err = got_error_from_errno("malloc");
1598 (*tree)->nentries = itree->nentries;
1599 (*tree)->refcnt = 0;
1601 case GOT_IMSG_TREE_ENTRIES:
1602 /* This message should be preceeded by GOT_IMSG_TREE. */
1603 if (*tree == NULL) {
1604 err = got_error(GOT_ERR_PRIVSEP_MSG);
1607 err = recv_tree_entries(imsg.data, datalen,
1611 err = got_error(GOT_ERR_PRIVSEP_MSG);
1620 if (*tree && (*tree)->nentries != nentries) {
1622 err = got_error(GOT_ERR_PRIVSEP_LEN);
1623 got_object_tree_close(*tree);
1630 const struct got_error *
1631 got_privsep_send_blob(struct imsgbuf *ibuf, size_t size, size_t hdrlen,
1632 const uint8_t *data)
1634 struct got_imsg_blob iblob;
1636 memset(&iblob, 0, sizeof(iblob));
1638 iblob.hdrlen = hdrlen;
1643 if (size > GOT_PRIVSEP_INLINE_BLOB_DATA_MAX)
1644 return got_error(GOT_ERR_NO_SPACE);
1646 buf = malloc(sizeof(iblob) + size);
1648 return got_error_from_errno("malloc");
1650 memcpy(buf, &iblob, sizeof(iblob));
1651 memcpy(buf + sizeof(iblob), data, size);
1652 if (imsg_compose(ibuf, GOT_IMSG_BLOB, 0, 0, -1, buf,
1653 sizeof(iblob) + size) == -1) {
1655 return got_error_from_errno("imsg_compose BLOB");
1659 /* Data has already been written to file descriptor. */
1660 if (imsg_compose(ibuf, GOT_IMSG_BLOB, 0, 0, -1, &iblob,
1661 sizeof(iblob)) == -1)
1662 return got_error_from_errno("imsg_compose BLOB");
1666 return flush_imsg(ibuf);
1669 const struct got_error *
1670 got_privsep_recv_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen,
1671 struct imsgbuf *ibuf)
1673 const struct got_error *err = NULL;
1675 struct got_imsg_blob *iblob;
1680 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
1684 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1686 switch (imsg.hdr.type) {
1688 if (datalen < sizeof(*iblob)) {
1689 err = got_error(GOT_ERR_PRIVSEP_LEN);
1693 *size = iblob->size;
1694 *hdrlen = iblob->hdrlen;
1696 if (datalen == sizeof(*iblob)) {
1697 /* Data has been written to file descriptor. */
1701 if (*size > GOT_PRIVSEP_INLINE_BLOB_DATA_MAX ||
1702 *size > datalen + sizeof(*iblob)) {
1703 err = got_error(GOT_ERR_PRIVSEP_LEN);
1707 *outbuf = malloc(*size);
1708 if (*outbuf == NULL) {
1709 err = got_error_from_errno("malloc");
1712 memcpy(*outbuf, imsg.data + sizeof(*iblob), *size);
1715 err = got_error(GOT_ERR_PRIVSEP_MSG);
1724 static const struct got_error *
1725 send_tagmsg(struct imsgbuf *ibuf, struct got_tag_object *tag, size_t tagmsg_len)
1727 const struct got_error *err = NULL;
1728 size_t offset, remain;
1731 remain = tagmsg_len;
1732 while (remain > 0) {
1733 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE, remain);
1735 if (imsg_compose(ibuf, GOT_IMSG_TAG_TAGMSG, 0, 0, -1,
1736 tag->tagmsg + offset, n) == -1) {
1737 err = got_error_from_errno("imsg_compose TAG_TAGMSG");
1741 err = flush_imsg(ibuf);
1752 const struct got_error *
1753 got_privsep_send_tag(struct imsgbuf *ibuf, struct got_tag_object *tag)
1755 const struct got_error *err = NULL;
1756 struct got_imsg_tag_object *itag;
1759 size_t tag_len = strlen(tag->tag);
1760 size_t tagger_len = strlen(tag->tagger);
1761 size_t tagmsg_len = strlen(tag->tagmsg);
1763 total = sizeof(*itag) + tag_len + tagger_len + tagmsg_len;
1765 buf = malloc(total);
1767 return got_error_from_errno("malloc");
1769 itag = (struct got_imsg_tag_object *)buf;
1770 memcpy(itag->id, tag->id.sha1, sizeof(itag->id));
1771 itag->obj_type = tag->obj_type;
1772 itag->tag_len = tag_len;
1773 itag->tagger_len = tagger_len;
1774 itag->tagger_time = tag->tagger_time;
1775 itag->tagger_gmtoff = tag->tagger_gmtoff;
1776 itag->tagmsg_len = tagmsg_len;
1778 len = sizeof(*itag);
1779 memcpy(buf + len, tag->tag, tag_len);
1781 memcpy(buf + len, tag->tagger, tagger_len);
1784 if (imsg_compose(ibuf, GOT_IMSG_TAG, 0, 0, -1, buf, len) == -1) {
1785 err = got_error_from_errno("imsg_compose TAG");
1789 if (tagmsg_len == 0 ||
1790 tagmsg_len + len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
1791 err = flush_imsg(ibuf);
1795 err = send_tagmsg(ibuf, tag, tagmsg_len);
1801 const struct got_error *
1802 got_privsep_recv_tag(struct got_tag_object **tag, struct imsgbuf *ibuf)
1804 const struct got_error *err = NULL;
1806 struct got_imsg_tag_object *itag;
1807 size_t len, datalen;
1808 const size_t min_datalen =
1809 MIN(sizeof(struct got_imsg_error),
1810 sizeof(struct got_imsg_tag_object));
1814 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1818 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1821 switch (imsg.hdr.type) {
1823 if (datalen < sizeof(*itag)) {
1824 err = got_error(GOT_ERR_PRIVSEP_LEN);
1828 if (datalen != sizeof(*itag) + itag->tag_len +
1830 err = got_error(GOT_ERR_PRIVSEP_LEN);
1833 len += sizeof(*itag);
1835 *tag = calloc(1, sizeof(**tag));
1837 err = got_error_from_errno("calloc");
1841 memcpy((*tag)->id.sha1, itag->id, SHA1_DIGEST_LENGTH);
1843 (*tag)->tag = strndup(imsg.data + len, itag->tag_len);
1844 if ((*tag)->tag == NULL) {
1845 err = got_error_from_errno("strndup");
1848 len += itag->tag_len;
1850 (*tag)->obj_type = itag->obj_type;
1851 (*tag)->tagger_time = itag->tagger_time;
1852 (*tag)->tagger_gmtoff = itag->tagger_gmtoff;
1854 (*tag)->tagger = strndup(imsg.data + len, itag->tagger_len);
1855 if ((*tag)->tagger == NULL) {
1856 err = got_error_from_errno("strndup");
1859 len += itag->tagger_len;
1861 if (itag->tagmsg_len == 0) {
1862 (*tag)->tagmsg = strdup("");
1863 if ((*tag)->tagmsg == NULL) {
1864 err = got_error_from_errno("strdup");
1868 size_t offset = 0, remain = itag->tagmsg_len;
1870 (*tag)->tagmsg = malloc(itag->tagmsg_len + 1);
1871 if ((*tag)->tagmsg == NULL) {
1872 err = got_error_from_errno("malloc");
1875 while (remain > 0) {
1876 struct imsg imsg_log;
1877 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE,
1880 err = got_privsep_recv_imsg(&imsg_log, ibuf, n);
1884 if (imsg_log.hdr.type != GOT_IMSG_TAG_TAGMSG)
1885 return got_error(GOT_ERR_PRIVSEP_MSG);
1887 memcpy((*tag)->tagmsg + offset, imsg_log.data,
1889 imsg_free(&imsg_log);
1893 (*tag)->tagmsg[itag->tagmsg_len] = '\0';
1898 err = got_error(GOT_ERR_PRIVSEP_MSG);
1907 const struct got_error *
1908 got_privsep_init_pack_child(struct imsgbuf *ibuf, struct got_pack *pack,
1909 struct got_packidx *packidx)
1911 const struct got_error *err = NULL;
1912 struct got_imsg_packidx ipackidx;
1913 struct got_imsg_pack ipack;
1916 memset(&ipackidx, 0, sizeof(ipackidx));
1917 memset(&ipack, 0, sizeof(ipack));
1919 ipackidx.len = packidx->len;
1920 ipackidx.packfile_size = pack->filesize;
1921 fd = dup(packidx->fd);
1923 return got_error_from_errno("dup");
1925 if (imsg_compose(ibuf, GOT_IMSG_PACKIDX, 0, 0, fd, &ipackidx,
1926 sizeof(ipackidx)) == -1) {
1927 err = got_error_from_errno("imsg_compose PACKIDX");
1932 if (strlcpy(ipack.path_packfile, pack->path_packfile,
1933 sizeof(ipack.path_packfile)) >= sizeof(ipack.path_packfile))
1934 return got_error(GOT_ERR_NO_SPACE);
1935 ipack.filesize = pack->filesize;
1939 return got_error_from_errno("dup");
1941 if (imsg_compose(ibuf, GOT_IMSG_PACK, 0, 0, fd, &ipack, sizeof(ipack))
1943 err = got_error_from_errno("imsg_compose PACK");
1948 return flush_imsg(ibuf);
1951 const struct got_error *
1952 got_privsep_send_packed_obj_req(struct imsgbuf *ibuf, int idx,
1953 struct got_object_id *id)
1955 struct got_imsg_packed_object iobj;
1957 memset(&iobj, 0, sizeof(iobj));
1959 memcpy(&iobj.id, id, sizeof(iobj.id));
1961 if (imsg_compose(ibuf, GOT_IMSG_PACKED_OBJECT_REQUEST, 0, 0, -1,
1962 &iobj, sizeof(iobj)) == -1)
1963 return got_error_from_errno("imsg_compose "
1964 "PACKED_OBJECT_REQUEST");
1966 return flush_imsg(ibuf);
1969 const struct got_error *
1970 got_privsep_send_packed_raw_obj_req(struct imsgbuf *ibuf, int idx,
1971 struct got_object_id *id)
1973 struct got_imsg_packed_object iobj;
1975 memset(&iobj, 0, sizeof(iobj));
1977 memcpy(&iobj.id, id, sizeof(iobj.id));
1979 if (imsg_compose(ibuf, GOT_IMSG_PACKED_RAW_OBJECT_REQUEST, 0, 0, -1,
1980 &iobj, sizeof(iobj)) == -1)
1981 return got_error_from_errno("imsg_compose "
1982 "PACKED_OBJECT_REQUEST");
1984 return flush_imsg(ibuf);
1987 const struct got_error *
1988 got_privsep_send_gitconfig_parse_req(struct imsgbuf *ibuf, int fd)
1990 const struct got_error *err = NULL;
1992 if (imsg_compose(ibuf, GOT_IMSG_GITCONFIG_PARSE_REQUEST, 0, 0, fd,
1994 err = got_error_from_errno("imsg_compose "
1995 "GITCONFIG_PARSE_REQUEST");
2000 return flush_imsg(ibuf);
2003 const struct got_error *
2004 got_privsep_send_gitconfig_repository_format_version_req(struct imsgbuf *ibuf)
2006 if (imsg_compose(ibuf,
2007 GOT_IMSG_GITCONFIG_REPOSITORY_FORMAT_VERSION_REQUEST, 0, 0, -1,
2009 return got_error_from_errno("imsg_compose "
2010 "GITCONFIG_REPOSITORY_FORMAT_VERSION_REQUEST");
2012 return flush_imsg(ibuf);
2015 const struct got_error *
2016 got_privsep_send_gitconfig_repository_extensions_req(struct imsgbuf *ibuf)
2018 if (imsg_compose(ibuf,
2019 GOT_IMSG_GITCONFIG_REPOSITORY_EXTENSIONS_REQUEST, 0, 0, -1,
2021 return got_error_from_errno("imsg_compose "
2022 "GITCONFIG_REPOSITORY_EXTENSIONS_REQUEST");
2024 return flush_imsg(ibuf);
2028 const struct got_error *
2029 got_privsep_send_gitconfig_author_name_req(struct imsgbuf *ibuf)
2031 if (imsg_compose(ibuf,
2032 GOT_IMSG_GITCONFIG_AUTHOR_NAME_REQUEST, 0, 0, -1, NULL, 0) == -1)
2033 return got_error_from_errno("imsg_compose "
2034 "GITCONFIG_AUTHOR_NAME_REQUEST");
2036 return flush_imsg(ibuf);
2039 const struct got_error *
2040 got_privsep_send_gitconfig_author_email_req(struct imsgbuf *ibuf)
2042 if (imsg_compose(ibuf,
2043 GOT_IMSG_GITCONFIG_AUTHOR_EMAIL_REQUEST, 0, 0, -1, NULL, 0) == -1)
2044 return got_error_from_errno("imsg_compose "
2045 "GITCONFIG_AUTHOR_EMAIL_REQUEST");
2047 return flush_imsg(ibuf);
2050 const struct got_error *
2051 got_privsep_send_gitconfig_remotes_req(struct imsgbuf *ibuf)
2053 if (imsg_compose(ibuf,
2054 GOT_IMSG_GITCONFIG_REMOTES_REQUEST, 0, 0, -1, NULL, 0) == -1)
2055 return got_error_from_errno("imsg_compose "
2056 "GITCONFIG_REMOTE_REQUEST");
2058 return flush_imsg(ibuf);
2061 const struct got_error *
2062 got_privsep_send_gitconfig_owner_req(struct imsgbuf *ibuf)
2064 if (imsg_compose(ibuf,
2065 GOT_IMSG_GITCONFIG_OWNER_REQUEST, 0, 0, -1, NULL, 0) == -1)
2066 return got_error_from_errno("imsg_compose "
2067 "GITCONFIG_OWNER_REQUEST");
2069 return flush_imsg(ibuf);
2072 const struct got_error *
2073 got_privsep_recv_gitconfig_str(char **str, struct imsgbuf *ibuf)
2075 const struct got_error *err = NULL;
2081 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2084 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2086 switch (imsg.hdr.type) {
2087 case GOT_IMSG_GITCONFIG_STR_VAL:
2090 *str = strndup(imsg.data, datalen);
2092 err = got_error_from_errno("strndup");
2097 err = got_error(GOT_ERR_PRIVSEP_MSG);
2105 const struct got_error *
2106 got_privsep_recv_gitconfig_pair(char **key, char **val, struct imsgbuf *ibuf)
2108 const struct got_error *err = NULL;
2109 struct got_imsg_gitconfig_pair p;
2116 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2121 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2123 if (imsg.hdr.type != GOT_IMSG_GITCONFIG_PAIR) {
2124 err = got_error(GOT_ERR_PRIVSEP_MSG);
2128 if (datalen < sizeof(p)) {
2129 err = got_error(GOT_ERR_PRIVSEP_LEN);
2133 memcpy(&p, data, sizeof(p));
2136 if (datalen != sizeof(p) + p.klen + p.vlen) {
2137 err = got_error(GOT_ERR_PRIVSEP_LEN);
2141 *key = strndup(data, p.klen);
2143 err = got_error_from_errno("strndup");
2148 *val = strndup(data, p.vlen);
2150 err = got_error_from_errno("strndup");
2159 const struct got_error *
2160 got_privsep_recv_gitconfig_int(int *val, struct imsgbuf *ibuf)
2162 const struct got_error *err = NULL;
2165 const size_t min_datalen =
2166 MIN(sizeof(struct got_imsg_error), sizeof(int));
2170 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
2173 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2175 switch (imsg.hdr.type) {
2176 case GOT_IMSG_GITCONFIG_INT_VAL:
2177 if (datalen != sizeof(*val)) {
2178 err = got_error(GOT_ERR_PRIVSEP_LEN);
2181 memcpy(val, imsg.data, sizeof(*val));
2184 err = got_error(GOT_ERR_PRIVSEP_MSG);
2193 free_remote_data(struct got_remote_repo *remote)
2198 free(remote->fetch_url);
2199 free(remote->send_url);
2200 for (i = 0; i < remote->nfetch_branches; i++)
2201 free(remote->fetch_branches[i]);
2202 free(remote->fetch_branches);
2203 for (i = 0; i < remote->nsend_branches; i++)
2204 free(remote->send_branches[i]);
2205 free(remote->send_branches);
2206 for (i = 0; i < remote->nfetch_refs; i++)
2207 free(remote->fetch_refs[i]);
2208 free(remote->fetch_refs);
2211 const struct got_error *
2212 got_privsep_recv_gitconfig_remotes(struct got_remote_repo **remotes,
2213 int *nremotes, struct imsgbuf *ibuf)
2215 const struct got_error *err = NULL;
2218 struct got_imsg_remotes iremotes;
2219 struct got_imsg_remote iremote;
2223 iremotes.nremotes = 0;
2225 err = got_privsep_recv_imsg(&imsg, ibuf, sizeof(iremotes));
2228 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2230 switch (imsg.hdr.type) {
2231 case GOT_IMSG_GITCONFIG_REMOTES:
2232 if (datalen != sizeof(iremotes)) {
2233 err = got_error(GOT_ERR_PRIVSEP_LEN);
2236 memcpy(&iremotes, imsg.data, sizeof(iremotes));
2237 if (iremotes.nremotes == 0) {
2244 return got_error(GOT_ERR_PRIVSEP_MSG);
2249 *remotes = recallocarray(NULL, 0, iremotes.nremotes, sizeof(**remotes));
2250 if (*remotes == NULL)
2251 return got_error_from_errno("recallocarray");
2253 while (*nremotes < iremotes.nremotes) {
2254 struct got_remote_repo *remote;
2256 err = got_privsep_recv_imsg(&imsg, ibuf, sizeof(iremote));
2259 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2261 switch (imsg.hdr.type) {
2262 case GOT_IMSG_GITCONFIG_REMOTE:
2263 remote = &(*remotes)[*nremotes];
2264 memset(remote, 0, sizeof(*remote));
2265 if (datalen < sizeof(iremote)) {
2266 err = got_error(GOT_ERR_PRIVSEP_LEN);
2269 memcpy(&iremote, imsg.data, sizeof(iremote));
2270 if (iremote.name_len == 0 ||
2271 iremote.fetch_url_len == 0 ||
2272 iremote.send_url_len == 0 ||
2273 (sizeof(iremote) + iremote.name_len +
2274 iremote.fetch_url_len + iremote.send_url_len) > datalen) {
2275 err = got_error(GOT_ERR_PRIVSEP_LEN);
2278 remote->name = strndup(imsg.data + sizeof(iremote),
2280 if (remote->name == NULL) {
2281 err = got_error_from_errno("strndup");
2284 remote->fetch_url = strndup(imsg.data + sizeof(iremote) +
2285 iremote.name_len, iremote.fetch_url_len);
2286 if (remote->fetch_url == NULL) {
2287 err = got_error_from_errno("strndup");
2288 free_remote_data(remote);
2291 remote->send_url = strndup(imsg.data + sizeof(iremote) +
2292 iremote.name_len + iremote.fetch_url_len,
2293 iremote.send_url_len);
2294 if (remote->send_url == NULL) {
2295 err = got_error_from_errno("strndup");
2296 free_remote_data(remote);
2299 remote->mirror_references = iremote.mirror_references;
2300 remote->fetch_all_branches = iremote.fetch_all_branches;
2301 remote->nfetch_branches = 0;
2302 remote->fetch_branches = NULL;
2303 remote->nsend_branches = 0;
2304 remote->send_branches = NULL;
2305 remote->nfetch_refs = 0;
2306 remote->fetch_refs = NULL;
2310 err = got_error(GOT_ERR_PRIVSEP_MSG);
2321 for (i = 0; i < *nremotes; i++)
2322 free_remote_data(&(*remotes)[i]);
2330 const struct got_error *
2331 got_privsep_send_gotconfig_parse_req(struct imsgbuf *ibuf, int fd)
2333 const struct got_error *err = NULL;
2335 if (imsg_compose(ibuf, GOT_IMSG_GOTCONFIG_PARSE_REQUEST, 0, 0, fd,
2337 err = got_error_from_errno("imsg_compose "
2338 "GOTCONFIG_PARSE_REQUEST");
2343 return flush_imsg(ibuf);
2346 const struct got_error *
2347 got_privsep_send_gotconfig_author_req(struct imsgbuf *ibuf)
2349 if (imsg_compose(ibuf,
2350 GOT_IMSG_GOTCONFIG_AUTHOR_REQUEST, 0, 0, -1, NULL, 0) == -1)
2351 return got_error_from_errno("imsg_compose "
2352 "GOTCONFIG_AUTHOR_REQUEST");
2354 return flush_imsg(ibuf);
2357 const struct got_error *
2358 got_privsep_send_gotconfig_allowed_signers_req(struct imsgbuf *ibuf)
2360 if (imsg_compose(ibuf,
2361 GOT_IMSG_GOTCONFIG_ALLOWEDSIGNERS_REQUEST, 0, 0, -1, NULL, 0) == -1)
2362 return got_error_from_errno("imsg_compose "
2363 "GOTCONFIG_ALLOWEDSIGNERS_REQUEST");
2365 return flush_imsg(ibuf);
2368 const struct got_error *
2369 got_privsep_send_gotconfig_revoked_signers_req(struct imsgbuf *ibuf)
2371 if (imsg_compose(ibuf,
2372 GOT_IMSG_GOTCONFIG_REVOKEDSIGNERS_REQUEST, 0, 0, -1, NULL, 0) == -1)
2373 return got_error_from_errno("imsg_compose "
2374 "GOTCONFIG_REVOKEDSIGNERS_REQUEST");
2376 return flush_imsg(ibuf);
2379 const struct got_error *
2380 got_privsep_send_gotconfig_signer_id_req(struct imsgbuf *ibuf)
2382 if (imsg_compose(ibuf,
2383 GOT_IMSG_GOTCONFIG_SIGNERID_REQUEST, 0, 0, -1, NULL, 0) == -1)
2384 return got_error_from_errno("imsg_compose "
2385 "GOTCONFIG_SIGNERID_REQUEST");
2387 return flush_imsg(ibuf);
2390 const struct got_error *
2391 got_privsep_send_gotconfig_remotes_req(struct imsgbuf *ibuf)
2393 if (imsg_compose(ibuf,
2394 GOT_IMSG_GOTCONFIG_REMOTES_REQUEST, 0, 0, -1, NULL, 0) == -1)
2395 return got_error_from_errno("imsg_compose "
2396 "GOTCONFIG_REMOTE_REQUEST");
2398 return flush_imsg(ibuf);
2401 const struct got_error *
2402 got_privsep_recv_gotconfig_str(char **str, struct imsgbuf *ibuf)
2404 const struct got_error *err = NULL;
2410 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2413 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2415 switch (imsg.hdr.type) {
2416 case GOT_IMSG_GOTCONFIG_STR_VAL:
2419 *str = strndup(imsg.data, datalen);
2421 err = got_error_from_errno("strndup");
2426 err = got_error(GOT_ERR_PRIVSEP_MSG);
2434 const struct got_error *
2435 got_privsep_recv_gotconfig_remotes(struct got_remote_repo **remotes,
2436 int *nremotes, struct imsgbuf *ibuf)
2438 const struct got_error *err = NULL;
2441 struct got_imsg_remotes iremotes;
2442 struct got_imsg_remote iremote;
2443 const size_t min_datalen =
2444 MIN(sizeof(struct got_imsg_error), sizeof(iremotes));
2448 iremotes.nremotes = 0;
2450 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
2453 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2455 switch (imsg.hdr.type) {
2456 case GOT_IMSG_GOTCONFIG_REMOTES:
2457 if (datalen != sizeof(iremotes)) {
2458 err = got_error(GOT_ERR_PRIVSEP_LEN);
2461 memcpy(&iremotes, imsg.data, sizeof(iremotes));
2462 if (iremotes.nremotes < 0) {
2463 err = got_error(GOT_ERR_PRIVSEP_LEN);
2466 if (iremotes.nremotes == 0) {
2473 return got_error(GOT_ERR_PRIVSEP_MSG);
2478 *remotes = recallocarray(NULL, 0, iremotes.nremotes, sizeof(**remotes));
2479 if (*remotes == NULL)
2480 return got_error_from_errno("recallocarray");
2482 while (*nremotes < iremotes.nremotes) {
2483 struct got_remote_repo *remote;
2484 const size_t min_datalen =
2485 MIN(sizeof(struct got_imsg_error), sizeof(iremote));
2488 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
2491 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2493 switch (imsg.hdr.type) {
2494 case GOT_IMSG_GOTCONFIG_REMOTE:
2495 remote = &(*remotes)[*nremotes];
2496 memset(remote, 0, sizeof(*remote));
2497 if (datalen < sizeof(iremote)) {
2498 err = got_error(GOT_ERR_PRIVSEP_LEN);
2501 memcpy(&iremote, imsg.data, sizeof(iremote));
2502 if (iremote.name_len == 0 ||
2503 (iremote.fetch_url_len == 0 &&
2504 iremote.send_url_len == 0) ||
2505 (sizeof(iremote) + iremote.name_len +
2506 iremote.fetch_url_len + iremote.send_url_len) >
2508 err = got_error(GOT_ERR_PRIVSEP_LEN);
2511 remote->name = strndup(imsg.data + sizeof(iremote),
2513 if (remote->name == NULL) {
2514 err = got_error_from_errno("strndup");
2517 remote->fetch_url = strndup(imsg.data +
2518 sizeof(iremote) + iremote.name_len,
2519 iremote.fetch_url_len);
2520 if (remote->fetch_url == NULL) {
2521 err = got_error_from_errno("strndup");
2522 free_remote_data(remote);
2525 remote->send_url = strndup(imsg.data +
2526 sizeof(iremote) + iremote.name_len +
2527 iremote.fetch_url_len, iremote.send_url_len);
2528 if (remote->send_url == NULL) {
2529 err = got_error_from_errno("strndup");
2530 free_remote_data(remote);
2533 remote->mirror_references = iremote.mirror_references;
2534 remote->fetch_all_branches = iremote.fetch_all_branches;
2535 if (iremote.nfetch_branches > 0) {
2536 remote->fetch_branches = recallocarray(NULL, 0,
2537 iremote.nfetch_branches, sizeof(char *));
2538 if (remote->fetch_branches == NULL) {
2539 err = got_error_from_errno("calloc");
2540 free_remote_data(remote);
2544 remote->nfetch_branches = 0;
2545 for (i = 0; i < iremote.nfetch_branches; i++) {
2547 err = got_privsep_recv_gotconfig_str(&branch,
2550 free_remote_data(remote);
2553 remote->fetch_branches[i] = branch;
2554 remote->nfetch_branches++;
2556 if (iremote.nsend_branches > 0) {
2557 remote->send_branches = recallocarray(NULL, 0,
2558 iremote.nsend_branches, sizeof(char *));
2559 if (remote->send_branches == NULL) {
2560 err = got_error_from_errno("calloc");
2561 free_remote_data(remote);
2565 remote->nsend_branches = 0;
2566 for (i = 0; i < iremote.nsend_branches; i++) {
2568 err = got_privsep_recv_gotconfig_str(&branch,
2571 free_remote_data(remote);
2574 remote->send_branches[i] = branch;
2575 remote->nsend_branches++;
2577 if (iremote.nfetch_refs > 0) {
2578 remote->fetch_refs = recallocarray(NULL, 0,
2579 iremote.nfetch_refs, sizeof(char *));
2580 if (remote->fetch_refs == NULL) {
2581 err = got_error_from_errno("calloc");
2582 free_remote_data(remote);
2586 remote->nfetch_refs = 0;
2587 for (i = 0; i < iremote.nfetch_refs; i++) {
2589 err = got_privsep_recv_gotconfig_str(&ref,
2592 free_remote_data(remote);
2595 remote->fetch_refs[i] = ref;
2596 remote->nfetch_refs++;
2601 err = got_error(GOT_ERR_PRIVSEP_MSG);
2612 for (i = 0; i < *nremotes; i++)
2613 free_remote_data(&(*remotes)[i]);
2621 const struct got_error *
2622 got_privsep_send_commit_traversal_request(struct imsgbuf *ibuf,
2623 struct got_object_id *id, int idx, const char *path)
2626 size_t path_len = strlen(path) + 1;
2628 wbuf = imsg_create(ibuf, GOT_IMSG_COMMIT_TRAVERSAL_REQUEST, 0, 0,
2629 sizeof(struct got_imsg_commit_traversal_request) + path_len);
2631 return got_error_from_errno(
2632 "imsg_create COMMIT_TRAVERSAL_REQUEST");
2633 if (imsg_add(wbuf, id->sha1, SHA1_DIGEST_LENGTH) == -1)
2634 return got_error_from_errno("imsg_add "
2635 "COMMIT_TRAVERSAL_REQUEST");
2636 if (imsg_add(wbuf, &idx, sizeof(idx)) == -1)
2637 return got_error_from_errno("imsg_add "
2638 "COMMIT_TRAVERSAL_REQUEST");
2639 if (imsg_add(wbuf, path, path_len) == -1)
2640 return got_error_from_errno("imsg_add "
2641 "COMMIT_TRAVERSAL_REQUEST");
2644 imsg_close(ibuf, wbuf);
2646 return flush_imsg(ibuf);
2649 const struct got_error *
2650 got_privsep_recv_traversed_commits(struct got_commit_object **changed_commit,
2651 struct got_object_id **changed_commit_id,
2652 struct got_object_id_queue *commit_ids, struct imsgbuf *ibuf)
2654 const struct got_error *err = NULL;
2656 struct got_imsg_traversed_commits *icommits;
2660 *changed_commit = NULL;
2661 *changed_commit_id = NULL;
2664 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2668 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2669 switch (imsg.hdr.type) {
2670 case GOT_IMSG_TRAVERSED_COMMITS:
2671 icommits = imsg.data;
2672 if (datalen != sizeof(*icommits) +
2673 icommits->ncommits * SHA1_DIGEST_LENGTH) {
2674 err = got_error(GOT_ERR_PRIVSEP_LEN);
2677 for (i = 0; i < icommits->ncommits; i++) {
2678 struct got_object_qid *qid;
2679 uint8_t *sha1 = (uint8_t *)imsg.data +
2680 sizeof(*icommits) + i * SHA1_DIGEST_LENGTH;
2681 err = got_object_qid_alloc_partial(&qid);
2684 memcpy(qid->id.sha1, sha1, SHA1_DIGEST_LENGTH);
2685 STAILQ_INSERT_TAIL(commit_ids, qid, entry);
2687 /* The last commit may contain a change. */
2688 if (i == icommits->ncommits - 1) {
2689 *changed_commit_id =
2690 got_object_id_dup(&qid->id);
2691 if (*changed_commit_id == NULL) {
2692 err = got_error_from_errno(
2693 "got_object_id_dup");
2699 case GOT_IMSG_COMMIT:
2700 if (*changed_commit_id == NULL) {
2701 err = got_error(GOT_ERR_PRIVSEP_MSG);
2704 err = get_commit_from_imsg(changed_commit, &imsg,
2707 case GOT_IMSG_COMMIT_TRAVERSAL_DONE:
2711 err = got_error(GOT_ERR_PRIVSEP_MSG);
2721 got_object_id_queue_free(commit_ids);
2725 const struct got_error *
2726 got_privsep_send_enumerated_tree(size_t *totlen, struct imsgbuf *ibuf,
2727 struct got_object_id *tree_id, const char *path,
2728 struct got_parsed_tree_entry *entries, int nentries)
2730 const struct got_error *err = NULL;
2732 size_t path_len = strlen(path);
2735 msglen = sizeof(struct got_imsg_enumerated_tree) + path_len;
2736 wbuf = imsg_create(ibuf, GOT_IMSG_ENUMERATED_TREE, 0, 0, msglen);
2738 return got_error_from_errno("imsg_create ENUMERATED_TREE");
2740 if (imsg_add(wbuf, tree_id->sha1, SHA1_DIGEST_LENGTH) == -1)
2741 return got_error_from_errno("imsg_add ENUMERATED_TREE");
2742 if (imsg_add(wbuf, &nentries, sizeof(nentries)) == -1)
2743 return got_error_from_errno("imsg_add ENUMERATED_TREE");
2744 if (imsg_add(wbuf, path, path_len) == -1)
2745 return got_error_from_errno("imsg_add ENUMERATED_TREE");
2748 imsg_close(ibuf, wbuf);
2751 err = send_tree_entries(ibuf, entries, nentries);
2756 return flush_imsg(ibuf);
2759 const struct got_error *
2760 got_privsep_send_object_enumeration_request(struct imsgbuf *ibuf)
2762 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_ENUMERATION_REQUEST,
2763 0, 0, -1, NULL, 0) == -1)
2764 return got_error_from_errno("imsg_compose "
2765 "OBJECT_ENUMERATION_REQUEST");
2767 return flush_imsg(ibuf);
2770 const struct got_error *
2771 got_privsep_send_object_enumeration_done(struct imsgbuf *ibuf)
2773 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_ENUMERATION_DONE,
2774 0, 0, -1, NULL, 0) == -1)
2775 return got_error_from_errno("imsg_compose "
2776 "OBJECT_ENUMERATION_DONE");
2778 return flush_imsg(ibuf);
2781 const struct got_error *
2782 got_privsep_send_object_enumeration_incomplete(struct imsgbuf *ibuf)
2784 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_ENUMERATION_INCOMPLETE,
2785 0, 0, -1, NULL, 0) == -1)
2786 return got_error_from_errno("imsg_compose "
2787 "OBJECT_ENUMERATION_INCOMPLETE");
2789 return flush_imsg(ibuf);
2792 const struct got_error *
2793 got_privsep_send_enumerated_commit(struct imsgbuf *ibuf,
2794 struct got_object_id *id, time_t mtime)
2798 wbuf = imsg_create(ibuf, GOT_IMSG_ENUMERATED_COMMIT, 0, 0,
2799 sizeof(struct got_imsg_enumerated_commit) + SHA1_DIGEST_LENGTH);
2801 return got_error_from_errno("imsg_create ENUMERATED_COMMIT");
2803 /* Keep in sync with struct got_imsg_enumerated_commit! */
2804 if (imsg_add(wbuf, id, SHA1_DIGEST_LENGTH) == -1)
2805 return got_error_from_errno("imsg_add ENUMERATED_COMMIT");
2806 if (imsg_add(wbuf, &mtime, sizeof(mtime)) == -1)
2807 return got_error_from_errno("imsg_add ENUMERATED_COMMIT");
2810 imsg_close(ibuf, wbuf);
2811 /* Don't flush yet, tree entries or ENUMERATION_DONE will follow. */
2815 const struct got_error *
2816 got_privsep_recv_enumerated_objects(int *found_all_objects,
2817 struct imsgbuf *ibuf,
2818 got_object_enumerate_commit_cb cb_commit,
2819 got_object_enumerate_tree_cb cb_tree, void *cb_arg,
2820 struct got_repository *repo)
2822 const struct got_error *err = NULL;
2824 struct got_imsg_enumerated_commit *icommit = NULL;
2825 struct got_object_id commit_id;
2826 int have_commit = 0;
2828 struct got_tree_object tree;
2829 struct got_imsg_enumerated_tree *itree;
2830 struct got_object_id tree_id;
2831 char *path = NULL, *canon_path = NULL;
2832 size_t datalen, path_len;
2836 *found_all_objects = 0;
2837 memset(&tree, 0, sizeof(tree));
2840 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2844 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2845 switch (imsg.hdr.type) {
2846 case GOT_IMSG_ENUMERATED_COMMIT:
2847 if (have_commit && nentries != -1) {
2848 err = got_error(GOT_ERR_PRIVSEP_MSG);
2851 if (datalen != sizeof(*icommit)) {
2852 err = got_error(GOT_ERR_PRIVSEP_LEN);
2855 icommit = (struct got_imsg_enumerated_commit *)imsg.data;
2856 memcpy(commit_id.sha1, icommit->id, SHA1_DIGEST_LENGTH);
2857 mtime = icommit->mtime;
2860 case GOT_IMSG_ENUMERATED_TREE:
2861 /* Should be preceeded by GOT_IMSG_ENUMERATED_COMMIT. */
2863 err = got_error(GOT_ERR_PRIVSEP_MSG);
2866 if (datalen < sizeof(*itree)) {
2867 err = got_error(GOT_ERR_PRIVSEP_LEN);
2871 path_len = datalen - sizeof(*itree);
2872 if (path_len == 0) {
2873 err = got_error(GOT_ERR_PRIVSEP_LEN);
2876 memcpy(tree_id.sha1, itree->id, sizeof(tree_id.sha1));
2878 path = strndup(imsg.data + sizeof(*itree), path_len);
2880 err = got_error_from_errno("strndup");
2884 canon_path = malloc(path_len + 1);
2885 if (canon_path == NULL) {
2886 err = got_error_from_errno("malloc");
2889 if (!got_path_is_absolute(path)) {
2890 err = got_error(GOT_ERR_BAD_PATH);
2893 if (got_path_is_root_dir(path)) {
2894 /* XXX check what got_canonpath() does wrong */
2895 canon_path[0] = '/';
2896 canon_path[1] = '\0';
2898 err = got_canonpath(path, canon_path,
2903 if (strcmp(path, canon_path) != 0) {
2904 err = got_error(GOT_ERR_BAD_PATH);
2907 if (nentries != -1) {
2908 err = got_error(GOT_ERR_PRIVSEP_MSG);
2911 if (itree->nentries < -1) {
2912 err = got_error(GOT_ERR_PRIVSEP_MSG);
2915 if (itree->nentries == -1) {
2916 /* Tree was not found in pack file. */
2917 err = cb_tree(cb_arg, NULL, mtime, &tree_id,
2921 if (itree->nentries > INT_MAX) {
2922 err = got_error(GOT_ERR_PRIVSEP_LEN);
2925 tree.entries = calloc(itree->nentries,
2926 sizeof(struct got_tree_entry));
2927 if (tree.entries == NULL) {
2928 err = got_error_from_errno("calloc");
2931 if (itree->nentries == 0) {
2932 err = cb_tree(cb_arg, &tree, mtime, &tree_id,
2937 /* Prepare for next tree. */
2939 memset(&tree, 0, sizeof(tree));
2942 tree.nentries = itree->nentries;
2946 case GOT_IMSG_TREE_ENTRIES:
2947 /* Should be preceeded by GOT_IMSG_ENUMERATED_TREE. */
2948 if (nentries <= -1) {
2949 err = got_error(GOT_ERR_PRIVSEP_MSG);
2952 err = recv_tree_entries(imsg.data, datalen,
2956 if (tree.nentries == nentries) {
2957 err = cb_tree(cb_arg, &tree, mtime, &tree_id,
2962 /* Prepare for next tree. */
2964 memset(&tree, 0, sizeof(tree));
2968 case GOT_IMSG_TREE_ENUMERATION_DONE:
2969 /* All trees have been found and traversed. */
2970 if (!have_commit || path == NULL || nentries != -1) {
2971 err = got_error(GOT_ERR_PRIVSEP_MSG);
2974 err = cb_commit(cb_arg, mtime, &commit_id, repo);
2979 case GOT_IMSG_OBJECT_ENUMERATION_DONE:
2980 *found_all_objects = 1;
2983 case GOT_IMSG_OBJECT_ENUMERATION_INCOMPLETE:
2987 err = got_error(GOT_ERR_PRIVSEP_MSG);
3002 const struct got_error *
3003 got_privsep_send_raw_delta_req(struct imsgbuf *ibuf, int idx,
3004 struct got_object_id *id)
3006 struct got_imsg_raw_delta_request dreq;
3008 memset(&dreq, 0, sizeof(dreq));
3010 memcpy(&dreq.id, id, sizeof(dreq.id));
3012 if (imsg_compose(ibuf, GOT_IMSG_RAW_DELTA_REQUEST, 0, 0, -1,
3013 &dreq, sizeof(dreq)) == -1)
3014 return got_error_from_errno("imsg_compose RAW_DELTA_REQUEST");
3016 return flush_imsg(ibuf);
3019 const struct got_error *
3020 got_privsep_send_raw_delta_outfd(struct imsgbuf *ibuf, int fd)
3022 return send_fd(ibuf, GOT_IMSG_RAW_DELTA_OUTFD, fd);
3025 const struct got_error *
3026 got_privsep_send_raw_delta(struct imsgbuf *ibuf, uint64_t base_size,
3027 uint64_t result_size, off_t delta_size, off_t delta_compressed_size,
3028 off_t delta_offset, off_t delta_out_offset, struct got_object_id *base_id)
3030 struct got_imsg_raw_delta idelta;
3033 memset(&idelta, 0, sizeof(idelta));
3034 idelta.base_size = base_size;
3035 idelta.result_size = result_size;
3036 idelta.delta_size = delta_size;
3037 idelta.delta_compressed_size = delta_compressed_size;
3038 idelta.delta_offset = delta_offset;
3039 idelta.delta_out_offset = delta_out_offset;
3040 memcpy(&idelta.base_id, &base_id, sizeof(idelta.base_id));
3042 ret = imsg_compose(ibuf, GOT_IMSG_RAW_DELTA, 0, 0, -1,
3043 &idelta, sizeof(idelta));
3045 return got_error_from_errno("imsg_compose RAW_DELTA");
3047 return flush_imsg(ibuf);
3050 const struct got_error *
3051 got_privsep_recv_raw_delta(uint64_t *base_size, uint64_t *result_size,
3052 off_t *delta_size, off_t *delta_compressed_size, off_t *delta_offset,
3053 off_t *delta_out_offset, struct got_object_id **base_id,
3054 struct imsgbuf *ibuf)
3056 const struct got_error *err = NULL;
3058 struct got_imsg_raw_delta *delta;
3064 *delta_compressed_size = 0;
3066 *delta_out_offset = 0;
3069 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3073 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3075 switch (imsg.hdr.type) {
3076 case GOT_IMSG_RAW_DELTA:
3077 if (datalen != sizeof(*delta)) {
3078 err = got_error(GOT_ERR_PRIVSEP_LEN);
3082 *base_size = delta->base_size;
3083 *result_size = delta->result_size;
3084 *delta_size = delta->delta_size;
3085 *delta_compressed_size = delta->delta_compressed_size;
3086 *delta_offset = delta->delta_offset;
3087 *delta_out_offset = delta->delta_out_offset;
3088 *base_id = calloc(1, sizeof(**base_id));
3089 if (*base_id == NULL) {
3090 err = got_error_from_errno("malloc");
3093 memcpy(*base_id, &delta->base_id, sizeof(**base_id));
3096 err = got_error(GOT_ERR_PRIVSEP_MSG);
3109 static const struct got_error *
3110 send_idlist(struct imsgbuf *ibuf, struct got_object_id **ids, size_t nids)
3112 const struct got_error *err = NULL;
3113 struct got_imsg_object_idlist idlist;
3117 memset(&idlist, 0, sizeof(idlist));
3119 if (nids > GOT_IMSG_OBJ_ID_LIST_MAX_NIDS)
3120 return got_error(GOT_ERR_NO_SPACE);
3122 wbuf = imsg_create(ibuf, GOT_IMSG_OBJ_ID_LIST, 0, 0,
3123 sizeof(idlist) + nids * sizeof(**ids));
3125 err = got_error_from_errno("imsg_create OBJ_ID_LIST");
3130 if (imsg_add(wbuf, &idlist, sizeof(idlist)) == -1)
3131 return got_error_from_errno("imsg_add OBJ_ID_LIST");
3133 for (i = 0; i < nids; i++) {
3134 struct got_object_id *id = ids[i];
3135 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
3136 return got_error_from_errno("imsg_add OBJ_ID_LIST");
3140 imsg_close(ibuf, wbuf);
3142 return flush_imsg(ibuf);
3145 const struct got_error *
3146 got_privsep_send_object_idlist(struct imsgbuf *ibuf,
3147 struct got_object_id **ids, size_t nids)
3149 const struct got_error *err = NULL;
3150 struct got_object_id *idlist[GOT_IMSG_OBJ_ID_LIST_MAX_NIDS];
3153 for (i = 0; i < nids; i++) {
3154 idlist[i % nitems(idlist)] = ids[i];
3156 if (queued >= nitems(idlist)) {
3157 err = send_idlist(ibuf, idlist, queued);
3165 err = send_idlist(ibuf, idlist, queued);
3173 const struct got_error *
3174 got_privsep_send_object_idlist_done(struct imsgbuf *ibuf)
3176 if (imsg_compose(ibuf, GOT_IMSG_OBJ_ID_LIST_DONE, 0, 0, -1, NULL, 0)
3178 return got_error_from_errno("imsg_compose OBJ_ID_LIST_DONE");
3180 return flush_imsg(ibuf);
3183 const struct got_error *
3184 got_privsep_recv_object_idlist(int *done, struct got_object_id **ids,
3185 size_t *nids, struct imsgbuf *ibuf)
3187 const struct got_error *err = NULL;
3189 struct got_imsg_object_idlist *idlist;
3196 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3200 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3201 switch (imsg.hdr.type) {
3202 case GOT_IMSG_OBJ_ID_LIST:
3203 if (datalen < sizeof(*idlist)) {
3204 err = got_error(GOT_ERR_PRIVSEP_LEN);
3208 if (idlist->nids > GOT_IMSG_OBJ_ID_LIST_MAX_NIDS ||
3209 idlist->nids * sizeof(**ids) > datalen - sizeof(*idlist)) {
3210 err = got_error(GOT_ERR_PRIVSEP_LEN);
3213 *nids = idlist->nids;
3214 *ids = calloc(*nids, sizeof(**ids));
3216 err = got_error_from_errno("calloc");
3219 memcpy(*ids, (uint8_t *)imsg.data + sizeof(*idlist),
3220 *nids * sizeof(**ids));
3222 case GOT_IMSG_OBJ_ID_LIST_DONE:
3226 err = got_error(GOT_ERR_PRIVSEP_MSG);
3235 const struct got_error *
3236 got_privsep_send_delta_reuse_req(struct imsgbuf *ibuf)
3238 if (imsg_compose(ibuf, GOT_IMSG_DELTA_REUSE_REQUEST, 0, 0, -1, NULL, 0)
3240 return got_error_from_errno("imsg_compose DELTA_REUSE_REQUEST");
3242 return flush_imsg(ibuf);
3245 const struct got_error *
3246 got_privsep_send_reused_deltas(struct imsgbuf *ibuf,
3247 struct got_imsg_reused_delta *deltas, size_t ndeltas)
3249 const struct got_error *err = NULL;
3251 struct got_imsg_reused_deltas ideltas;
3254 memset(&ideltas, 0, sizeof(ideltas));
3256 if (ndeltas > GOT_IMSG_REUSED_DELTAS_MAX_NDELTAS)
3257 return got_error(GOT_ERR_NO_SPACE);
3259 wbuf = imsg_create(ibuf, GOT_IMSG_REUSED_DELTAS, 0, 0,
3260 sizeof(ideltas) + ndeltas * sizeof(*deltas));
3262 err = got_error_from_errno("imsg_create REUSED_DELTAS");
3266 ideltas.ndeltas = ndeltas;
3267 if (imsg_add(wbuf, &ideltas, sizeof(ideltas)) == -1)
3268 return got_error_from_errno("imsg_add REUSED_DELTAS");
3270 for (i = 0; i < ndeltas; i++) {
3271 struct got_imsg_reused_delta *delta = &deltas[i];
3272 if (imsg_add(wbuf, delta, sizeof(*delta)) == -1)
3273 return got_error_from_errno("imsg_add REUSED_DELTAS");
3277 imsg_close(ibuf, wbuf);
3279 return flush_imsg(ibuf);
3282 const struct got_error *
3283 got_privsep_send_reused_deltas_done(struct imsgbuf *ibuf)
3285 if (imsg_compose(ibuf, GOT_IMSG_DELTA_REUSE_DONE, 0, 0, -1, NULL, 0)
3287 return got_error_from_errno("imsg_compose DELTA_REUSE_DONE");
3289 return flush_imsg(ibuf);
3292 const struct got_error *
3293 got_privsep_recv_reused_deltas(int *done, struct got_imsg_reused_delta *deltas,
3294 size_t *ndeltas, struct imsgbuf *ibuf)
3296 const struct got_error *err = NULL;
3298 struct got_imsg_reused_deltas *ideltas;
3304 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3308 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3309 switch (imsg.hdr.type) {
3310 case GOT_IMSG_REUSED_DELTAS:
3311 if (datalen < sizeof(*ideltas)) {
3312 err = got_error(GOT_ERR_PRIVSEP_LEN);
3315 ideltas = imsg.data;
3316 if (ideltas->ndeltas > GOT_IMSG_OBJ_ID_LIST_MAX_NIDS ||
3317 ideltas->ndeltas * sizeof(*deltas) >
3318 datalen - sizeof(*ideltas)) {
3319 err = got_error(GOT_ERR_PRIVSEP_LEN);
3322 *ndeltas = ideltas->ndeltas;
3323 memcpy(deltas, (uint8_t *)imsg.data + sizeof(*ideltas),
3324 *ndeltas * sizeof(*deltas));
3326 case GOT_IMSG_DELTA_REUSE_DONE:
3330 err = got_error(GOT_ERR_PRIVSEP_MSG);
3339 const struct got_error *
3340 got_privsep_init_commit_painting(struct imsgbuf *ibuf)
3342 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_PAINTING_INIT,
3345 return got_error_from_errno("imsg_compose "
3346 "COMMIT_PAINTING_INIT");
3348 return flush_imsg(ibuf);
3351 const struct got_error *
3352 got_privsep_send_painting_request(struct imsgbuf *ibuf, int idx,
3353 struct got_object_id *id, intptr_t color)
3355 struct got_imsg_commit_painting_request ireq;
3357 memset(&ireq, 0, sizeof(ireq));
3358 memcpy(ireq.id, id->sha1, sizeof(ireq.id));
3362 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_PAINTING_REQUEST, 0, 0, -1,
3363 &ireq, sizeof(ireq)) == -1)
3364 return got_error_from_errno("imsg_compose "
3365 "COMMIT_PAINTING_REQUEST");
3367 return flush_imsg(ibuf);
3370 static const struct got_error *
3371 send_painted_commits(struct got_object_id_queue *ids, int *nids,
3372 size_t remain, int present_in_pack, struct imsgbuf *ibuf)
3374 const struct got_error *err = NULL;
3375 struct ibuf *wbuf = NULL;
3376 struct got_object_qid *qid;
3381 msglen = MIN(remain, MAX_IMSGSIZE - IMSG_HEADER_SIZE);
3382 ncommits = (msglen - sizeof(struct got_imsg_painted_commits)) /
3383 sizeof(struct got_imsg_painted_commit);
3385 wbuf = imsg_create(ibuf, GOT_IMSG_PAINTED_COMMITS, 0, 0, msglen);
3387 err = got_error_from_errno("imsg_create PAINTED_COMMITS");
3391 /* Keep in sync with struct got_imsg_painted_commits! */
3392 if (imsg_add(wbuf, &ncommits, sizeof(ncommits)) == -1)
3393 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3394 if (imsg_add(wbuf, &present_in_pack, sizeof(present_in_pack)) == -1)
3395 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3397 while (ncommits > 0) {
3398 qid = STAILQ_FIRST(ids);
3399 STAILQ_REMOVE_HEAD(ids, entry);
3402 color = (intptr_t)qid->data;
3404 /* Keep in sync with struct got_imsg_painted_commit! */
3405 if (imsg_add(wbuf, qid->id.sha1, SHA1_DIGEST_LENGTH) == -1)
3406 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3407 if (imsg_add(wbuf, &color, sizeof(color)) == -1)
3408 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3410 got_object_qid_free(qid);
3414 imsg_close(ibuf, wbuf);
3416 return flush_imsg(ibuf);
3419 const struct got_error *
3420 got_privsep_send_painted_commits(struct imsgbuf *ibuf,
3421 struct got_object_id_queue *ids, int *nids,
3422 int present_in_pack, int flush)
3424 const struct got_error *err;
3431 remain = (sizeof(struct got_imsg_painted_commits)) +
3432 *nids * sizeof(struct got_imsg_painted_commit);
3433 if (flush || remain >= MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
3434 err = send_painted_commits(ids, nids, remain,
3435 present_in_pack, ibuf);
3439 } while (flush && *nids > 0);
3444 const struct got_error *
3445 got_privsep_send_painting_commits_done(struct imsgbuf *ibuf)
3447 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_PAINTING_DONE,
3450 return got_error_from_errno("imsg_compose "
3451 "COMMIT_PAINTING_DONE");
3453 return flush_imsg(ibuf);
3456 const struct got_error *
3457 got_privsep_recv_painted_commits(struct got_object_id_queue *new_ids,
3458 got_privsep_recv_painted_commit_cb cb, void *cb_arg, struct imsgbuf *ibuf)
3460 const struct got_error *err = NULL;
3462 struct got_imsg_painted_commits icommits;
3463 struct got_imsg_painted_commit icommit;
3468 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3472 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3473 if (imsg.hdr.type == GOT_IMSG_COMMIT_PAINTING_DONE)
3475 if (imsg.hdr.type != GOT_IMSG_PAINTED_COMMITS)
3476 return got_error(GOT_ERR_PRIVSEP_MSG);
3478 if (datalen < sizeof(icommits))
3479 return got_error(GOT_ERR_PRIVSEP_LEN);
3480 memcpy(&icommits, imsg.data, sizeof(icommits));
3481 if (icommits.ncommits * sizeof(icommit) < icommits.ncommits ||
3482 datalen < sizeof(icommits) +
3483 icommits.ncommits * sizeof(icommit))
3484 return got_error(GOT_ERR_PRIVSEP_LEN);
3486 for (i = 0; i < icommits.ncommits; i++) {
3488 (uint8_t *)imsg.data + sizeof(icommits) + i * sizeof(icommit),
3491 if (icommits.present_in_pack) {
3492 struct got_object_id id;
3493 memcpy(id.sha1, icommit.id, SHA1_DIGEST_LENGTH);
3494 err = cb(cb_arg, &id, icommit.color);
3498 struct got_object_qid *qid;
3499 err = got_object_qid_alloc_partial(&qid);
3502 memcpy(qid->id.sha1, icommit.id,
3503 SHA1_DIGEST_LENGTH);
3504 qid->data = (void *)icommit.color;
3505 STAILQ_INSERT_TAIL(new_ids, qid, entry);
3515 const struct got_error *
3516 got_privsep_unveil_exec_helpers(void)
3518 const char *helpers[] = {
3519 GOT_PATH_PROG_READ_PACK,
3520 GOT_PATH_PROG_READ_OBJECT,
3521 GOT_PATH_PROG_READ_COMMIT,
3522 GOT_PATH_PROG_READ_TREE,
3523 GOT_PATH_PROG_READ_BLOB,
3524 GOT_PATH_PROG_READ_TAG,
3525 GOT_PATH_PROG_READ_GITCONFIG,
3526 GOT_PATH_PROG_READ_GOTCONFIG,
3527 GOT_PATH_PROG_READ_PATCH,
3528 GOT_PATH_PROG_FETCH_PACK,
3529 GOT_PATH_PROG_INDEX_PACK,
3530 GOT_PATH_PROG_SEND_PACK,
3534 for (i = 0; i < nitems(helpers); i++) {
3535 if (unveil(helpers[i], "x") == 0)
3537 return got_error_from_errno2("unveil", helpers[i]);
3544 got_privsep_exec_child(int imsg_fds[2], const char *path, const char *repo_path)
3546 if (close(imsg_fds[0]) == -1) {
3547 fprintf(stderr, "%s: %s\n", getprogname(), strerror(errno));
3551 if (dup2(imsg_fds[1], GOT_IMSG_FD_CHILD) == -1) {
3552 fprintf(stderr, "%s: %s\n", getprogname(), strerror(errno));
3556 closefrom(GOT_IMSG_FD_CHILD + 1);
3558 if (execl(path, path, repo_path, (char *)NULL) == -1) {
3559 fprintf(stderr, "%s: %s: %s\n", getprogname(), path,