?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix number of queued ids passed from findtwixt() to got_pack_paint_commits()
[got-portable.git] / lib / privsep.c
blob106d1a9f8b921c7f2648c52049f36704e1ff9d87
1 /*
2 * Copyright (c) 2018, 2019, 2020 Stefan Sperling <stsp@openbsd.org>
3 * Copyright (c) 2020 Ori Bernstein <ori@openbsd.org>
4 *
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.
8 *
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.
16 */
17
18 #include <sys/types.h>
19 #include <sys/queue.h>
20 #include <sys/uio.h>
21 #include <sys/wait.h>
22
23 #include <ctype.h>
24 #include <limits.h>
25 #include <signal.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <stdint.h>
31 #include <poll.h>
32 #include <imsg.h>
33 #include <unistd.h>
34 #include <zlib.h>
35
36 #include "got_compat.h"
37
38 #include "got_object.h"
39 #include "got_error.h"
40 #include "got_path.h"
41 #include "got_repository.h"
42
43 #include "got_lib_hash.h"
44 #include "got_lib_delta.h"
45 #include "got_lib_inflate.h"
46 #include "got_lib_object.h"
47 #include "got_lib_object_parse.h"
48 #include "got_lib_object_qid.h"
49 #include "got_lib_privsep.h"
50 #include "got_lib_pack.h"
51 #include "got_lib_poll.h"
52
53 #include "got_privsep.h"
54
55 #ifndef MIN
56 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
57 #endif
58
59 #ifndef nitems
60 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
61 #endif
62
63 static const struct got_error *
64 read_imsg(struct imsgbuf *ibuf)
65 {
66 const struct got_error *err;
67 size_t n;
68
69 err = got_poll_fd(ibuf->fd, POLLIN, INFTIM);
70 if (err) {
71 if (err->code == GOT_ERR_EOF)
72 return got_error(GOT_ERR_PRIVSEP_PIPE);
73 return err;
74 }
75
76 n = imsgbuf_read(ibuf);
77 if (n == -1)
78 return got_error(GOT_ERR_PRIVSEP_READ);
79 if (n == 0)
80 return got_error(GOT_ERR_PRIVSEP_PIPE);
81
82 return NULL;
83 }
84
85 const struct got_error *
86 got_privsep_wait_for_child(pid_t pid)
87 {
88 int child_status;
89
90 if (waitpid(pid, &child_status, 0) == -1)
91 return got_error_from_errno("waitpid");
92
93 if (!WIFEXITED(child_status))
94 return got_error(GOT_ERR_PRIVSEP_DIED);
95
96 if (WEXITSTATUS(child_status) != 0)
97 return got_error(GOT_ERR_PRIVSEP_EXIT);
98
99 return NULL;
100 }
101
102 static const struct got_error *
103 recv_imsg_error(struct imsg *imsg, size_t datalen)
104 {
105 struct got_imsg_error *ierr;
106
107 if (datalen != sizeof(*ierr))
108 return got_error(GOT_ERR_PRIVSEP_LEN);
109
110 ierr = imsg->data;
111 if (ierr->code == GOT_ERR_ERRNO) {
112 static struct got_error serr;
113 serr.code = GOT_ERR_ERRNO;
114 serr.msg = strerror(ierr->errno_code);
115 return &serr;
116 }
117
118 return got_error(ierr->code);
119 }
120
121 const struct got_error *
122 got_privsep_recv_imsg(struct imsg *imsg, struct imsgbuf *ibuf,
123 size_t min_datalen)
124 {
125 const struct got_error *err;
126 ssize_t n;
127
128 n = imsg_get(ibuf, imsg);
129 if (n == -1)
130 return got_error_from_errno("imsg_get");
131
132 while (n == 0) {
133 err = read_imsg(ibuf);
134 if (err)
135 return err;
136 n = imsg_get(ibuf, imsg);
137 if (n == -1)
138 return got_error_from_errno("imsg_get");
139 }
140
141 if (imsg->hdr.type == GOT_IMSG_ERROR) {
142 size_t datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
143 err = recv_imsg_error(imsg, datalen);
144 imsg_free(imsg);
145 return err;
146 }
147
148 if (imsg->hdr.len < IMSG_HEADER_SIZE + min_datalen) {
149 imsg_free(imsg);
150 return got_error(GOT_ERR_PRIVSEP_LEN);
151 }
152
153 return NULL;
154 }
155
156 /* Attempt to send an error in an imsg. Complain on stderr as a last resort. */
157 void
158 got_privsep_send_error(struct imsgbuf *ibuf, const struct got_error *err)
159 {
160 const struct got_error *poll_err;
161 struct got_imsg_error ierr;
162 int ret;
163
164 ierr.code = err->code;
165 if (err->code == GOT_ERR_ERRNO)
166 ierr.errno_code = errno;
167 else
168 ierr.errno_code = 0;
169 ret = imsg_compose(ibuf, GOT_IMSG_ERROR, 0, 0, -1, &ierr, sizeof(ierr));
170 if (ret == -1) {
171 fprintf(stderr, "%s: error %d \"%s\": imsg_compose: %s\n",
172 getprogname(), err->code, err->msg, strerror(errno));
173 return;
174 }
175
176 poll_err = got_poll_fd(ibuf->fd, POLLOUT, INFTIM);
177 if (poll_err) {
178 if (poll_err->code != GOT_ERR_EOF)
179 fprintf(stderr, "%s: error %d \"%s\": poll: %s\n",
180 getprogname(), err->code, err->msg, poll_err->msg);
181 return;
182 }
183
184 ret = imsgbuf_flush(ibuf);
185 if (ret == -1) {
186 fprintf(stderr, "%s: error %d \"%s\": imsgbuf_flush: %s\n",
187 getprogname(), err->code, err->msg, strerror(errno));
188 return;
189 }
190 }
191
192 static const struct got_error *
193 flush_imsg(struct imsgbuf *ibuf)
194 {
195 const struct got_error *err;
196
197 err = got_poll_fd(ibuf->fd, POLLOUT, INFTIM);
198 if (err)
199 return err;
200
201 if (imsgbuf_flush(ibuf) == -1)
202 return got_error_from_errno("imsgbuf_flush");
203
204 return NULL;
205 }
206
207 const struct got_error *
208 got_privsep_flush_imsg(struct imsgbuf *ibuf)
209 {
210 return flush_imsg(ibuf);
211 }
212
213 const struct got_error *
214 got_privsep_send_stop(int fd)
215 {
216 const struct got_error *err = NULL;
217 struct imsgbuf ibuf;
218
219 if (imsgbuf_init(&ibuf, fd) == -1)
220 return got_error_from_errno("imsgbuf_init");
221
222 if (imsg_compose(&ibuf, GOT_IMSG_STOP, 0, 0, -1, NULL, 0) == -1) {
223 err = got_error_from_errno("imsg_compose STOP");
224 goto done;
225 }
226
227 err = flush_imsg(&ibuf);
228 done:
229 imsgbuf_clear(&ibuf);
230 return err;
231 }
232
233 const struct got_error *
234 got_privsep_send_obj_req(struct imsgbuf *ibuf, int fd,
235 struct got_object_id *id)
236 {
237 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_REQUEST, 0, 0, fd,
238 id, sizeof(*id)) == -1)
239 return got_error_from_errno("imsg_compose OBJECT_REQUEST");
240
241 return flush_imsg(ibuf);
242 }
243
244 const struct got_error *
245 got_privsep_send_raw_obj_req(struct imsgbuf *ibuf, int fd,
246 struct got_object_id *id)
247 {
248 const struct got_error *err;
249
250 if (imsg_compose(ibuf, GOT_IMSG_RAW_OBJECT_REQUEST, 0, 0, fd,
251 id, sizeof(*id)) == -1) {
252 err = got_error_from_errno("imsg_compose RAW_OBJECT_REQUEST");
253 close(fd);
254 return err;
255 }
256
257 return flush_imsg(ibuf);
258 }
259
260 const struct got_error *
261 got_privsep_send_raw_obj_outfd(struct imsgbuf *ibuf, int outfd)
262 {
263 const struct got_error *err = NULL;
264
265 if (imsg_compose(ibuf, GOT_IMSG_RAW_OBJECT_OUTFD, 0, 0, outfd, NULL, 0)
266 == -1) {
267 err = got_error_from_errno("imsg_compose RAW_OBJECT_OUTFD");
268 close(outfd);
269 return err;
270 }
271
272 return flush_imsg(ibuf);
273 }
274
275 const struct got_error *
276 got_privsep_send_raw_obj(struct imsgbuf *ibuf, off_t size, size_t hdrlen,
277 uint8_t *data)
278 {
279 struct got_imsg_raw_obj iobj;
280 size_t len = sizeof(iobj);
281 struct ibuf *wbuf;
282
283 memset(&iobj, 0, sizeof(iobj));
284 iobj.hdrlen = hdrlen;
285 iobj.size = size;
286
287 if (data && size + hdrlen <= GOT_PRIVSEP_INLINE_OBJECT_DATA_MAX)
288 len += (size_t)size + hdrlen;
289
290 wbuf = imsg_create(ibuf, GOT_IMSG_RAW_OBJECT, 0, 0, len);
291 if (wbuf == NULL)
292 return got_error_from_errno("imsg_create RAW_OBJECT");
293
294 if (imsg_add(wbuf, &iobj, sizeof(iobj)) == -1)
295 return got_error_from_errno("imsg_add RAW_OBJECT");
296
297 if (data && size + hdrlen <= GOT_PRIVSEP_INLINE_OBJECT_DATA_MAX) {
298 if (imsg_add(wbuf, data, size + hdrlen) == -1)
299 return got_error_from_errno("imsg_add RAW_OBJECT");
300 }
301
302 imsg_close(ibuf, wbuf);
303 return flush_imsg(ibuf);
304 }
305
306 const struct got_error *
307 got_privsep_recv_raw_obj(uint8_t **outbuf, off_t *size, size_t *hdrlen,
308 struct imsgbuf *ibuf)
309 {
310 const struct got_error *err = NULL;
311 struct imsg imsg;
312 struct got_imsg_raw_obj *iobj;
313 size_t datalen;
314
315 *outbuf = NULL;
316
317 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
318 if (err)
319 return err;
320
321 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
322
323 switch (imsg.hdr.type) {
324 case GOT_IMSG_RAW_OBJECT:
325 if (datalen < sizeof(*iobj)) {
326 err = got_error(GOT_ERR_PRIVSEP_LEN);
327 break;
328 }
329 iobj = imsg.data;
330 *size = iobj->size;
331 *hdrlen = iobj->hdrlen;
332
333 if (datalen == sizeof(*iobj)) {
334 /* Data has been written to file descriptor. */
335 break;
336 }
337
338 if (*size < 0 ||
339 *size + *hdrlen > GOT_PRIVSEP_INLINE_OBJECT_DATA_MAX) {
340 err = got_error(GOT_ERR_PRIVSEP_LEN);
341 break;
342 }
343
344 *outbuf = malloc(*size + *hdrlen);
345 if (*outbuf == NULL) {
346 err = got_error_from_errno("malloc");
347 break;
348 }
349 memcpy(*outbuf, imsg.data + sizeof(*iobj), *size + *hdrlen);
350 break;
351 default:
352 err = got_error(GOT_ERR_PRIVSEP_MSG);
353 break;
354 }
355
356 imsg_free(&imsg);
357
358 return err;
359 }
360
361 const struct got_error *
362 got_privsep_send_commit_req(struct imsgbuf *ibuf, int fd,
363 struct got_object_id *id, int pack_idx)
364 {
365 const struct got_error *err = NULL;
366 struct got_imsg_packed_object iobj;
367 void *data;
368 size_t len;
369
370 memset(&iobj, 0, sizeof(iobj));
371 if (pack_idx != -1) { /* commit is packed */
372 iobj.idx = pack_idx;
373 memcpy(&iobj.id, id, sizeof(iobj.id));
374 data = &iobj;
375 len = sizeof(iobj);
376 } else {
377 data = id;
378 len = sizeof(*id);
379 }
380
381 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_REQUEST, 0, 0, fd, data, len)
382 == -1) {
383 err = got_error_from_errno("imsg_compose COMMIT_REQUEST");
384 close(fd);
385 return err;
386 }
387
388 return flush_imsg(ibuf);
389 }
390
391 const struct got_error *
392 got_privsep_send_tree_req(struct imsgbuf *ibuf, int fd,
393 struct got_object_id *id, int pack_idx)
394 {
395 const struct got_error *err;
396 struct ibuf *wbuf;
397 size_t len;
398
399 if (pack_idx != -1)
400 len = sizeof(struct got_imsg_packed_object);
401 else
402 len = sizeof(*id);
403
404 wbuf = imsg_create(ibuf, GOT_IMSG_TREE_REQUEST, 0, 0, len);
405 if (wbuf == NULL) {
406 err = got_error_from_errno("imsg_create TREE_REQUEST");
407 if (fd != -1)
408 close(fd);
409 return err;
410 }
411
412 if (imsg_add(wbuf, id, sizeof(*id)) == -1) {
413 err = got_error_from_errno("imsg_add TREE_REQUEST");
414 if (fd != -1)
415 close(fd);
416 return err;
417 }
418
419 if (pack_idx != -1) { /* tree is packed */
420 if (imsg_add(wbuf, &pack_idx, sizeof(pack_idx)) == -1) {
421 err = got_error_from_errno("imsg_add TREE_REQUEST");
422 if (fd != -1)
423 close(fd);
424 return err;
425 }
426 }
427
428 ibuf_fd_set(wbuf, fd);
429 imsg_close(ibuf, wbuf);
430
431 return flush_imsg(ibuf);
432 }
433
434 const struct got_error *
435 got_privsep_send_tag_req(struct imsgbuf *ibuf, int fd,
436 struct got_object_id *id, int pack_idx)
437 {
438 const struct got_error *err;
439 struct got_imsg_packed_object iobj;
440 void *data;
441 size_t len;
442
443 memset(&iobj, 0, sizeof(iobj));
444 if (pack_idx != -1) { /* tag is packed */
445 iobj.idx = pack_idx;
446 memcpy(&iobj.id, id, sizeof(iobj.id));
447 data = &iobj;
448 len = sizeof(iobj);
449 } else {
450 data = id;
451 len = sizeof(*id);
452 }
453
454 if (imsg_compose(ibuf, GOT_IMSG_TAG_REQUEST, 0, 0, fd, data, len)
455 == -1) {
456 err = got_error_from_errno("imsg_compose TAG_REQUEST");
457 if (fd != -1)
458 close(fd);
459 return err;
460 }
461
462 return flush_imsg(ibuf);
463 }
464
465 const struct got_error *
466 got_privsep_send_blob_req(struct imsgbuf *ibuf, int infd,
467 struct got_object_id *id, int pack_idx)
468 {
469 const struct got_error *err = NULL;
470 struct got_imsg_packed_object iobj;
471 void *data;
472 size_t len;
473
474 memset(&iobj, 0, sizeof(iobj));
475 if (pack_idx != -1) { /* blob is packed */
476 iobj.idx = pack_idx;
477 memcpy(&iobj.id, id, sizeof(iobj.id));
478 data = &iobj;
479 len = sizeof(iobj);
480 } else {
481 data = id;
482 len = sizeof(*id);
483 }
484
485 if (imsg_compose(ibuf, GOT_IMSG_BLOB_REQUEST, 0, 0, infd, data, len)
486 == -1) {
487 err = got_error_from_errno("imsg_compose BLOB_REQUEST");
488 close(infd);
489 return err;
490 }
491
492 return flush_imsg(ibuf);
493 }
494
495 const struct got_error *
496 got_privsep_send_blob_outfd(struct imsgbuf *ibuf, int outfd)
497 {
498 const struct got_error *err = NULL;
499
500 if (imsg_compose(ibuf, GOT_IMSG_BLOB_OUTFD, 0, 0, outfd, NULL, 0)
501 == -1) {
502 err = got_error_from_errno("imsg_compose BLOB_OUTFD");
503 close(outfd);
504 return err;
505 }
506
507 return flush_imsg(ibuf);
508 }
509
510 static const struct got_error *
511 send_fd(struct imsgbuf *ibuf, int imsg_code, int fd)
512 {
513 const struct got_error *err = NULL;
514
515 if (imsg_compose(ibuf, imsg_code, 0, 0, fd, NULL, 0) == -1) {
516 err = got_error_from_errno("imsg_compose TMPFD");
517 close(fd);
518 return err;
519 }
520
521 return flush_imsg(ibuf);
522 }
523
524 const struct got_error *
525 got_privsep_send_tmpfd(struct imsgbuf *ibuf, int fd)
526 {
527 return send_fd(ibuf, GOT_IMSG_TMPFD, fd);
528 }
529
530 const struct got_error *
531 got_privsep_send_obj(struct imsgbuf *ibuf, struct got_object *obj)
532 {
533 struct got_imsg_object iobj;
534
535 memset(&iobj, 0, sizeof(iobj));
536
537 memcpy(&iobj.id, &obj->id, sizeof(iobj.id));
538 iobj.type = obj->type;
539 iobj.flags = obj->flags;
540 iobj.hdrlen = obj->hdrlen;
541 iobj.size = obj->size;
542 if (iobj.flags & GOT_OBJ_FLAG_PACKED) {
543 iobj.pack_offset = obj->pack_offset;
544 iobj.pack_idx = obj->pack_idx;
545 }
546
547 if (imsg_compose(ibuf, GOT_IMSG_OBJECT, 0, 0, -1, &iobj, sizeof(iobj))
548 == -1)
549 return got_error_from_errno("imsg_compose OBJECT");
550
551 return flush_imsg(ibuf);
552 }
553
554 const struct got_error *
555 got_privsep_send_fetch_req(struct imsgbuf *ibuf, int fd,
556 struct got_pathlist_head *have_refs, int fetch_all_branches,
557 struct got_pathlist_head *wanted_branches,
558 struct got_pathlist_head *wanted_refs, int list_refs_only,
559 const char *worktree_branch, const char *remote_head,
560 int no_head, int verbosity)
561 {
562 const struct got_error *err = NULL;
563 struct ibuf *wbuf;
564 struct got_pathlist_entry *pe;
565 struct got_imsg_fetch_request fetchreq;
566 size_t remote_head_len, worktree_branch_len, len = sizeof(fetchreq);
567
568 if (worktree_branch) {
569 worktree_branch_len = strlen(worktree_branch);
570 len += worktree_branch_len;
571 }
572 if (remote_head) {
573 remote_head_len = strlen(remote_head);
574 len += remote_head_len;
575 }
576
577 if (len >= MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
578 close(fd);
579 return got_error(GOT_ERR_NO_SPACE);
580 }
581
582 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_REQUEST, 0, 0, len);
583 if (wbuf == NULL) {
584 err = got_error_from_errno("imsg_create FETCH_HAVE_REF");
585 close(fd);
586 return err;
587 }
588
589 memset(&fetchreq, 0, sizeof(fetchreq));
590 fetchreq.no_head = no_head;
591 fetchreq.fetch_all_branches = fetch_all_branches;
592 fetchreq.list_refs_only = list_refs_only;
593 fetchreq.verbosity = verbosity;
594 if (worktree_branch != NULL)
595 fetchreq.worktree_branch_len = worktree_branch_len;
596 if (remote_head != NULL)
597 fetchreq.remote_head_len = remote_head_len;
598 RB_FOREACH(pe, got_pathlist_head, have_refs)
599 fetchreq.n_have_refs++;
600 RB_FOREACH(pe, got_pathlist_head, wanted_branches)
601 fetchreq.n_wanted_branches++;
602 RB_FOREACH(pe, got_pathlist_head, wanted_refs)
603 fetchreq.n_wanted_refs++;
604 if (imsg_add(wbuf, &fetchreq, sizeof(fetchreq)) == -1)
605 return got_error_from_errno("imsg_add FETCH_REQUEST");
606 if (worktree_branch) {
607 if (imsg_add(wbuf, worktree_branch, worktree_branch_len)
608 == -1) {
609 err = got_error_from_errno("imsg_add FETCH_REQUEST");
610 close(fd);
611 return err;
612 }
613 }
614 if (remote_head) {
615 if (imsg_add(wbuf, remote_head, remote_head_len) == -1) {
616 err = got_error_from_errno("imsg_add FETCH_REQUEST");
617 close(fd);
618 return err;
619 }
620 }
621 ibuf_fd_set(wbuf, fd);
622 fd = -1;
623 imsg_close(ibuf, wbuf);
624
625 err = flush_imsg(ibuf);
626 if (err)
627 return err;
628
629 RB_FOREACH(pe, got_pathlist_head, have_refs) {
630 const char *name = pe->path;
631 size_t name_len = pe->path_len;
632 struct got_object_id *id = pe->data;
633
634 len = sizeof(struct got_imsg_fetch_have_ref) + name_len;
635 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_HAVE_REF, 0, 0, len);
636 if (wbuf == NULL)
637 return got_error_from_errno("imsg_create FETCH_HAVE_REF");
638
639 /* Keep in sync with struct got_imsg_fetch_have_ref! */
640 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
641 return got_error_from_errno("imsg_add FETCH_HAVE_REF");
642 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
643 return got_error_from_errno("imsg_add FETCH_HAVE_REF");
644 if (imsg_add(wbuf, name, name_len) == -1)
645 return got_error_from_errno("imsg_add FETCH_HAVE_REF");
646
647 imsg_close(ibuf, wbuf);
648 err = flush_imsg(ibuf);
649 if (err)
650 return err;
651 }
652
653 RB_FOREACH(pe, got_pathlist_head, wanted_branches) {
654 const char *name = pe->path;
655 size_t name_len = pe->path_len;
656
657 len = sizeof(struct got_imsg_fetch_wanted_branch) + name_len;
658 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_WANTED_BRANCH, 0, 0,
659 len);
660 if (wbuf == NULL)
661 return got_error_from_errno(
662 "imsg_create FETCH_WANTED_BRANCH");
663
664 /* Keep in sync with struct got_imsg_fetch_wanted_branch! */
665 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
666 return got_error_from_errno(
667 "imsg_add FETCH_WANTED_BRANCH");
668 if (imsg_add(wbuf, name, name_len) == -1)
669 return got_error_from_errno(
670 "imsg_add FETCH_WANTED_BRANCH");
671
672 imsg_close(ibuf, wbuf);
673 err = flush_imsg(ibuf);
674 if (err)
675 return err;
676 }
677
678 RB_FOREACH(pe, got_pathlist_head, wanted_refs) {
679 const char *name = pe->path;
680 size_t name_len = pe->path_len;
681
682 len = sizeof(struct got_imsg_fetch_wanted_ref) + name_len;
683 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_WANTED_REF, 0, 0,
684 len);
685 if (wbuf == NULL)
686 return got_error_from_errno(
687 "imsg_create FETCH_WANTED_REF");
688
689 /* Keep in sync with struct got_imsg_fetch_wanted_ref! */
690 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
691 return got_error_from_errno(
692 "imsg_add FETCH_WANTED_REF");
693 if (imsg_add(wbuf, name, name_len) == -1)
694 return got_error_from_errno(
695 "imsg_add FETCH_WANTED_REF");
696
697 imsg_close(ibuf, wbuf);
698 err = flush_imsg(ibuf);
699 if (err)
700 return err;
701 }
702
703 return NULL;
704 }
705
706 const struct got_error *
707 got_privsep_send_fetch_outfd(struct imsgbuf *ibuf, int fd)
708 {
709 return send_fd(ibuf, GOT_IMSG_FETCH_OUTFD, fd);
710 }
711
712 const struct got_error *
713 got_privsep_recv_fetch_progress(int *done, struct got_object_id **id,
714 char **refname, struct got_pathlist_head *symrefs, char **server_progress,
715 off_t *packfile_size, uint8_t *pack_sha1, struct imsgbuf *ibuf)
716 {
717 const struct got_error *err = NULL;
718 struct imsg imsg;
719 size_t datalen;
720 struct got_imsg_fetch_symrefs *isymrefs = NULL;
721 size_t n, remain;
722 struct got_pathlist_entry *new;
723 off_t off;
724 int i;
725
726 *done = 0;
727 *id = NULL;
728 *refname = NULL;
729 *server_progress = NULL;
730 *packfile_size = 0;
731 memset(pack_sha1, 0, SHA1_DIGEST_LENGTH);
732
733 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
734 if (err)
735 return err;
736
737 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
738 switch (imsg.hdr.type) {
739 case GOT_IMSG_FETCH_SYMREFS:
740 if (datalen < sizeof(*isymrefs)) {
741 err = got_error(GOT_ERR_PRIVSEP_LEN);
742 break;
743 }
744 if (isymrefs != NULL) {
745 err = got_error(GOT_ERR_PRIVSEP_MSG);
746 break;
747 }
748 isymrefs = (struct got_imsg_fetch_symrefs *)imsg.data;
749 off = sizeof(*isymrefs);
750 remain = datalen - off;
751 for (n = 0; n < isymrefs->nsymrefs; n++) {
752 struct got_imsg_fetch_symref *s;
753 char *name, *target;
754 if (remain < sizeof(struct got_imsg_fetch_symref)) {
755 err = got_error(GOT_ERR_PRIVSEP_LEN);
756 goto done;
757 }
758 s = (struct got_imsg_fetch_symref *)(imsg.data + off);
759 off += sizeof(*s);
760 remain -= sizeof(*s);
761 if (remain < s->name_len) {
762 err = got_error(GOT_ERR_PRIVSEP_LEN);
763 goto done;
764 }
765 name = strndup(imsg.data + off, s->name_len);
766 if (name == NULL) {
767 err = got_error_from_errno("strndup");
768 goto done;
769 }
770 off += s->name_len;
771 remain -= s->name_len;
772 if (remain < s->target_len) {
773 err = got_error(GOT_ERR_PRIVSEP_LEN);
774 free(name);
775 goto done;
776 }
777 target = strndup(imsg.data + off, s->target_len);
778 if (target == NULL) {
779 err = got_error_from_errno("strndup");
780 free(name);
781 goto done;
782 }
783 off += s->target_len;
784 remain -= s->target_len;
785 err = got_pathlist_insert(&new, symrefs, name, target);
786 if (err || new == NULL) {
787 free(name);
788 free(target);
789 if (err->code != GOT_ERR_REF_DUP_ENTRY)
790 goto done;
791 }
792 }
793 break;
794 case GOT_IMSG_FETCH_REF:
795 if (datalen <= sizeof(**id)) {
796 err = got_error(GOT_ERR_PRIVSEP_MSG);
797 break;
798 }
799 *id = malloc(sizeof(**id));
800 if (*id == NULL) {
801 err = got_error_from_errno("malloc");
802 break;
803 }
804 memcpy(*id, imsg.data, sizeof(**id));
805 *refname = strndup(imsg.data + sizeof(**id),
806 datalen - sizeof(**id));
807 if (*refname == NULL) {
808 err = got_error_from_errno("strndup");
809 break;
810 }
811 break;
812 case GOT_IMSG_FETCH_SERVER_PROGRESS:
813 if (datalen == 0) {
814 err = got_error(GOT_ERR_PRIVSEP_LEN);
815 break;
816 }
817 *server_progress = strndup(imsg.data, datalen);
818 if (*server_progress == NULL) {
819 err = got_error_from_errno("strndup");
820 break;
821 }
822 for (i = 0; i < datalen; i++) {
823 if (!isprint((unsigned char)(*server_progress)[i]) &&
824 !isspace((unsigned char)(*server_progress)[i])) {
825 err = got_error(GOT_ERR_PRIVSEP_MSG);
826 free(*server_progress);
827 *server_progress = NULL;
828 goto done;
829 }
830 }
831 break;
832 case GOT_IMSG_FETCH_DOWNLOAD_PROGRESS:
833 if (datalen < sizeof(*packfile_size)) {
834 err = got_error(GOT_ERR_PRIVSEP_MSG);
835 break;
836 }
837 memcpy(packfile_size, imsg.data, sizeof(*packfile_size));
838 break;
839 case GOT_IMSG_FETCH_DONE:
840 if (datalen != SHA1_DIGEST_LENGTH) {
841 err = got_error(GOT_ERR_PRIVSEP_MSG);
842 break;
843 }
844 memcpy(pack_sha1, imsg.data, SHA1_DIGEST_LENGTH);
845 *done = 1;
846 break;
847 default:
848 err = got_error(GOT_ERR_PRIVSEP_MSG);
849 break;
850 }
851 done:
852 if (err) {
853 free(*id);
854 *id = NULL;
855 free(*refname);
856 *refname = NULL;
857 }
858 imsg_free(&imsg);
859 return err;
860 }
861
862 static const struct got_error *
863 send_send_ref(const char *name, size_t name_len, struct got_object_id *id,
864 int delete, struct imsgbuf *ibuf)
865 {
866 size_t len;
867 struct ibuf *wbuf;
868
869 len = sizeof(struct got_imsg_send_ref) + name_len;
870 wbuf = imsg_create(ibuf, GOT_IMSG_SEND_REF, 0, 0, len);
871 if (wbuf == NULL)
872 return got_error_from_errno("imsg_create SEND_REF");
873
874 /* Keep in sync with struct got_imsg_send_ref! */
875 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
876 return got_error_from_errno("imsg_add SEND_REF");
877 if (imsg_add(wbuf, &delete, sizeof(delete)) == -1)
878 return got_error_from_errno("imsg_add SEND_REF");
879 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
880 return got_error_from_errno("imsg_add SEND_REF");
881 if (imsg_add(wbuf, name, name_len) == -1)
882 return got_error_from_errno("imsg_add SEND_REF");
883
884 imsg_close(ibuf, wbuf);
885 return flush_imsg(ibuf);
886 }
887
888 const struct got_error *
889 got_privsep_send_send_req(struct imsgbuf *ibuf, int fd,
890 struct got_pathlist_head *have_refs,
891 struct got_pathlist_head *delete_refs,
892 int verbosity)
893 {
894 const struct got_error *err = NULL;
895 struct got_pathlist_entry *pe;
896 struct got_imsg_send_request sendreq;
897 struct got_object_id zero_id;
898
899 memset(&zero_id, 0, sizeof(zero_id));
900 memset(&sendreq, 0, sizeof(sendreq));
901 sendreq.verbosity = verbosity;
902 RB_FOREACH(pe, got_pathlist_head, have_refs)
903 sendreq.nrefs++;
904 RB_FOREACH(pe, got_pathlist_head, delete_refs)
905 sendreq.nrefs++;
906 if (imsg_compose(ibuf, GOT_IMSG_SEND_REQUEST, 0, 0, fd,
907 &sendreq, sizeof(sendreq)) == -1) {
908 err = got_error_from_errno(
909 "imsg_compose FETCH_SERVER_PROGRESS");
910 goto done;
911 }
912
913 fd = -1;
914 err = flush_imsg(ibuf);
915 if (err)
916 goto done;
917
918 RB_FOREACH(pe, got_pathlist_head ,have_refs) {
919 const char *name = pe->path;
920 size_t name_len = pe->path_len;
921 struct got_object_id *id = pe->data;
922 err = send_send_ref(name, name_len, id, 0, ibuf);
923 if (err)
924 goto done;
925 }
926
927 RB_FOREACH(pe, got_pathlist_head, delete_refs) {
928 const char *name = pe->path;
929 size_t name_len = pe->path_len;
930 err = send_send_ref(name, name_len, &zero_id, 1, ibuf);
931 if (err)
932 goto done;
933 }
934 done:
935 if (fd != -1 && close(fd) == -1 && err == NULL)
936 err = got_error_from_errno("close");
937 return err;
938 }
939
940 const struct got_error *
941 got_privsep_recv_send_remote_refs(struct got_pathlist_head *remote_refs,
942 struct imsgbuf *ibuf)
943 {
944 const struct got_error *err = NULL;
945 struct imsg imsg;
946 size_t datalen;
947 struct got_imsg_send_remote_ref iremote_ref;
948 struct got_object_id *id = NULL;
949 char *refname = NULL;
950 struct got_pathlist_entry *new;
951
952 while (1) {
953 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
954 if (err)
955 return err;
956 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
957 switch (imsg.hdr.type) {
958 case GOT_IMSG_SEND_REMOTE_REF:
959 if (datalen < sizeof(iremote_ref)) {
960 err = got_error(GOT_ERR_PRIVSEP_MSG);
961 goto done;
962 }
963 memcpy(&iremote_ref, imsg.data, sizeof(iremote_ref));
964 if (datalen != sizeof(iremote_ref) +
965 iremote_ref.name_len) {
966 err = got_error(GOT_ERR_PRIVSEP_MSG);
967 goto done;
968 }
969 id = malloc(sizeof(*id));
970 if (id == NULL) {
971 err = got_error_from_errno("malloc");
972 goto done;
973 }
974 memcpy(id, &iremote_ref.id, sizeof(*id));
975 refname = strndup(imsg.data + sizeof(iremote_ref),
976 datalen - sizeof(iremote_ref));
977 if (refname == NULL) {
978 err = got_error_from_errno("strndup");
979 goto done;
980 }
981 err = got_pathlist_insert(&new, remote_refs,
982 refname, id);
983 if (err)
984 goto done;
985 if (new == NULL) { /* duplicate which wasn't inserted */
986 free(id);
987 free(refname);
988 }
989 id = NULL;
990 refname = NULL;
991 imsg_free(&imsg);
992 break;
993 case GOT_IMSG_SEND_PACK_REQUEST:
994 if (datalen != 0) {
995 err = got_error(GOT_ERR_PRIVSEP_MSG);
996 goto done;
997 }
998 /* got-send-pack is now waiting for a pack file. */
999 goto done;
1000 default:
1001 err = got_error(GOT_ERR_PRIVSEP_MSG);
1002 goto done;
1003 }
1004 }
1005 done:
1006 free(id);
1007 free(refname);
1008 imsg_free(&imsg);
1009 return err;
1010 }
1011
1012 const struct got_error *
1013 got_privsep_send_packfd(struct imsgbuf *ibuf, int fd)
1014 {
1015 return send_fd(ibuf, GOT_IMSG_SEND_PACKFD, fd);
1016 }
1017
1018 const struct got_error *
1019 got_privsep_recv_send_progress(int *done, off_t *bytes_sent,
1020 int *success, char **refname, char **errmsg, struct imsgbuf *ibuf)
1021 {
1022 const struct got_error *err = NULL;
1023 struct imsg imsg;
1024 size_t datalen;
1025 struct got_imsg_send_ref_status iref_status;
1026
1027 /* Do not reset the current value of 'bytes_sent', it accumulates. */
1028 *done = 0;
1029 *success = 0;
1030 *refname = NULL;
1031 *errmsg = NULL;
1032
1033 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
1034 if (err)
1035 return err;
1036
1037 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1038 switch (imsg.hdr.type) {
1039 case GOT_IMSG_SEND_UPLOAD_PROGRESS:
1040 if (datalen < sizeof(*bytes_sent)) {
1041 err = got_error(GOT_ERR_PRIVSEP_MSG);
1042 break;
1043 }
1044 memcpy(bytes_sent, imsg.data, sizeof(*bytes_sent));
1045 break;
1046 case GOT_IMSG_SEND_REF_STATUS:
1047 if (datalen < sizeof(iref_status)) {
1048 err = got_error(GOT_ERR_PRIVSEP_MSG);
1049 break;
1050 }
1051 memcpy(&iref_status, imsg.data, sizeof(iref_status));
1052 if (datalen != sizeof(iref_status) + iref_status.name_len +
1053 iref_status.errmsg_len) {
1054 err = got_error(GOT_ERR_PRIVSEP_MSG);
1055 break;
1056 }
1057 *success = iref_status.success;
1058 *refname = strndup(imsg.data + sizeof(iref_status),
1059 iref_status.name_len);
1060
1061 if (iref_status.errmsg_len != 0)
1062 *errmsg = strndup(imsg.data + sizeof(iref_status) +
1063 iref_status.name_len, iref_status.errmsg_len);
1064 break;
1065 case GOT_IMSG_SEND_DONE:
1066 if (datalen != 0) {
1067 err = got_error(GOT_ERR_PRIVSEP_MSG);
1068 break;
1069 }
1070 *done = 1;
1071 break;
1072 default:
1073 err = got_error(GOT_ERR_PRIVSEP_MSG);
1074 break;
1075 }
1076
1077 imsg_free(&imsg);
1078 return err;
1079 }
1080
1081 const struct got_error *
1082 got_privsep_send_index_pack_req(struct imsgbuf *ibuf, struct got_object_id *id,
1083 int fd)
1084 {
1085 const struct got_error *err = NULL;
1086
1087 /* Keep in sync with struct got_imsg_index_pack_request */
1088 if (imsg_compose(ibuf, GOT_IMSG_IDXPACK_REQUEST, 0, 0, fd,
1089 id, sizeof(*id)) == -1) {
1090 err = got_error_from_errno("imsg_compose INDEX_REQUEST");
1091 close(fd);
1092 return err;
1093 }
1094 return flush_imsg(ibuf);
1095 }
1096
1097 const struct got_error *
1098 got_privsep_send_index_pack_outfd(struct imsgbuf *ibuf, int fd)
1099 {
1100 return send_fd(ibuf, GOT_IMSG_IDXPACK_OUTFD, fd);
1101 }
1102
1103 const struct got_error *
1104 got_privsep_recv_index_progress(int *done, int *nobj_total,
1105 int *nobj_indexed, int *nobj_loose, int *nobj_resolved,
1106 struct imsgbuf *ibuf)
1107 {
1108 const struct got_error *err = NULL;
1109 struct imsg imsg;
1110 struct got_imsg_index_pack_progress *iprogress;
1111 size_t datalen;
1112
1113 *done = 0;
1114 *nobj_total = 0;
1115 *nobj_indexed = 0;
1116 *nobj_resolved = 0;
1117
1118 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
1119 if (err)
1120 return err;
1121
1122 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1123 switch (imsg.hdr.type) {
1124 case GOT_IMSG_IDXPACK_PROGRESS:
1125 if (datalen < sizeof(*iprogress)) {
1126 err = got_error(GOT_ERR_PRIVSEP_LEN);
1127 break;
1128 }
1129 iprogress = (struct got_imsg_index_pack_progress *)imsg.data;
1130 if (iprogress->nobj_total < 0 || iprogress->nobj_indexed < 0 ||
1131 iprogress->nobj_loose < 0 || iprogress->nobj_resolved < 0) {
1132 err = got_error(GOT_ERR_RANGE);
1133 break;
1134 }
1135 *nobj_total = iprogress->nobj_total;
1136 *nobj_indexed = iprogress->nobj_indexed;
1137 *nobj_loose = iprogress->nobj_loose;
1138 *nobj_resolved = iprogress->nobj_resolved;
1139 break;
1140 case GOT_IMSG_IDXPACK_DONE:
1141 if (datalen != 0) {
1142 err = got_error(GOT_ERR_PRIVSEP_LEN);
1143 break;
1144 }
1145 *done = 1;
1146 break;
1147 default:
1148 err = got_error(GOT_ERR_PRIVSEP_MSG);
1149 break;
1150 }
1151
1152 imsg_free(&imsg);
1153 return err;
1154 }
1155
1156 const struct got_error *
1157 got_privsep_get_imsg_obj(struct got_object **obj, struct imsg *imsg,
1158 struct imsgbuf *ibuf)
1159 {
1160 struct got_imsg_object *iobj;
1161 size_t datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1162
1163 if (datalen != sizeof(*iobj))
1164 return got_error(GOT_ERR_PRIVSEP_LEN);
1165 iobj = imsg->data;
1166
1167 if (iobj->pack_offset < 0)
1168 return got_error(GOT_ERR_PACK_OFFSET);
1169
1170 *obj = calloc(1, sizeof(**obj));
1171 if (*obj == NULL)
1172 return got_error_from_errno("calloc");
1173
1174 memcpy(&(*obj)->id, &iobj->id, sizeof(iobj->id));
1175 (*obj)->type = iobj->type;
1176 (*obj)->flags = iobj->flags;
1177 (*obj)->hdrlen = iobj->hdrlen;
1178 (*obj)->size = iobj->size;
1179 /* path_packfile is handled by caller */
1180 if (iobj->flags & GOT_OBJ_FLAG_PACKED) {
1181 (*obj)->pack_offset = iobj->pack_offset;
1182 (*obj)->pack_idx = iobj->pack_idx;
1183 }
1184 STAILQ_INIT(&(*obj)->deltas.entries);
1185 return NULL;
1186 }
1187
1188 const struct got_error *
1189 got_privsep_recv_obj(struct got_object **obj, struct imsgbuf *ibuf)
1190 {
1191 const struct got_error *err = NULL;
1192 struct imsg imsg;
1193 const size_t min_datalen = sizeof(struct got_imsg_object);
1194
1195 *obj = NULL;
1196
1197 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1198 if (err)
1199 return err;
1200
1201 switch (imsg.hdr.type) {
1202 case GOT_IMSG_OBJECT:
1203 err = got_privsep_get_imsg_obj(obj, &imsg, ibuf);
1204 break;
1205 default:
1206 err = got_error(GOT_ERR_PRIVSEP_MSG);
1207 break;
1208 }
1209
1210 imsg_free(&imsg);
1211
1212 return err;
1213 }
1214
1215 static const struct got_error *
1216 send_commit_logmsg(struct imsgbuf *ibuf, struct got_commit_object *commit,
1217 size_t logmsg_len)
1218 {
1219 const struct got_error *err = NULL;
1220 size_t offset, remain;
1221
1222 offset = 0;
1223 remain = logmsg_len;
1224 while (remain > 0) {
1225 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE, remain);
1226
1227 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_LOGMSG, 0, 0, -1,
1228 commit->logmsg + offset, n) == -1) {
1229 err = got_error_from_errno("imsg_compose "
1230 "COMMIT_LOGMSG");
1231 break;
1232 }
1233
1234 err = flush_imsg(ibuf);
1235 if (err)
1236 break;
1237
1238 offset += n;
1239 remain -= n;
1240 }
1241
1242 return err;
1243 }
1244
1245 const struct got_error *
1246 got_privsep_send_commit(struct imsgbuf *ibuf, struct got_commit_object *commit)
1247 {
1248 const struct got_error *err = NULL;
1249 struct got_imsg_commit_object *icommit;
1250 uint8_t *buf;
1251 size_t len, total;
1252 struct got_object_qid *qid;
1253 size_t author_len = strlen(commit->author);
1254 size_t committer_len = strlen(commit->committer);
1255 size_t logmsg_len = strlen(commit->logmsg);
1256
1257 total = sizeof(*icommit) + author_len + committer_len +
1258 commit->nparents * sizeof(struct got_object_id);
1259
1260 buf = malloc(total);
1261 if (buf == NULL)
1262 return got_error_from_errno("malloc");
1263
1264 icommit = (struct got_imsg_commit_object *)buf;
1265 memcpy(&icommit->tree_id, commit->tree_id, sizeof(icommit->tree_id));
1266 icommit->author_len = author_len;
1267 icommit->author_time = commit->author_time;
1268 icommit->author_gmtoff = commit->author_gmtoff;
1269 icommit->committer_len = committer_len;
1270 icommit->committer_time = commit->committer_time;
1271 icommit->committer_gmtoff = commit->committer_gmtoff;
1272 icommit->logmsg_len = logmsg_len;
1273 icommit->nparents = commit->nparents;
1274
1275 len = sizeof(*icommit);
1276 memcpy(buf + len, commit->author, author_len);
1277 len += author_len;
1278 memcpy(buf + len, commit->committer, committer_len);
1279 len += committer_len;
1280 STAILQ_FOREACH(qid, &commit->parent_ids, entry) {
1281 memcpy(buf + len, &qid->id, sizeof(qid->id));
1282 len += sizeof(qid->id);
1283 }
1284
1285 if (imsg_compose(ibuf, GOT_IMSG_COMMIT, 0, 0, -1, buf, len) == -1) {
1286 err = got_error_from_errno("imsg_compose COMMIT");
1287 goto done;
1288 }
1289
1290 if (logmsg_len == 0 ||
1291 logmsg_len + len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
1292 err = flush_imsg(ibuf);
1293 if (err)
1294 goto done;
1295 }
1296 err = send_commit_logmsg(ibuf, commit, logmsg_len);
1297 done:
1298 free(buf);
1299 return err;
1300 }
1301
1302 static const struct got_error *
1303 get_commit_from_imsg(struct got_commit_object **commit,
1304 struct imsg *imsg, size_t datalen, struct imsgbuf *ibuf)
1305 {
1306 const struct got_error *err = NULL;
1307 struct got_imsg_commit_object *icommit;
1308 size_t len = 0;
1309 int i;
1310
1311 if (datalen < sizeof(*icommit))
1312 return got_error(GOT_ERR_PRIVSEP_LEN);
1313
1314 icommit = imsg->data;
1315 if (datalen != sizeof(*icommit) + icommit->author_len +
1316 icommit->committer_len +
1317 icommit->nparents * sizeof(struct got_object_id))
1318 return got_error(GOT_ERR_PRIVSEP_LEN);
1319
1320 if (icommit->nparents < 0)
1321 return got_error(GOT_ERR_PRIVSEP_LEN);
1322
1323 len += sizeof(*icommit);
1324
1325 *commit = got_object_commit_alloc_partial();
1326 if (*commit == NULL)
1327 return got_error_from_errno(
1328 "got_object_commit_alloc_partial");
1329
1330 memcpy((*commit)->tree_id, &icommit->tree_id,
1331 sizeof(icommit->tree_id));
1332 (*commit)->author_time = icommit->author_time;
1333 (*commit)->author_gmtoff = icommit->author_gmtoff;
1334 (*commit)->committer_time = icommit->committer_time;
1335 (*commit)->committer_gmtoff = icommit->committer_gmtoff;
1336
1337 (*commit)->author = strndup(imsg->data + len, icommit->author_len);
1338 if ((*commit)->author == NULL) {
1339 err = got_error_from_errno("strndup");
1340 goto done;
1341 }
1342 len += icommit->author_len;
1343
1344 (*commit)->committer = strndup(imsg->data + len,
1345 icommit->committer_len);
1346 if ((*commit)->committer == NULL) {
1347 err = got_error_from_errno("strndup");
1348 goto done;
1349 }
1350 len += icommit->committer_len;
1351
1352 if (icommit->logmsg_len == 0) {
1353 (*commit)->logmsg = strdup("");
1354 if ((*commit)->logmsg == NULL) {
1355 err = got_error_from_errno("strdup");
1356 goto done;
1357 }
1358 } else {
1359 size_t offset = 0, remain = icommit->logmsg_len;
1360
1361 (*commit)->logmsg = malloc(icommit->logmsg_len + 1);
1362 if ((*commit)->logmsg == NULL) {
1363 err = got_error_from_errno("malloc");
1364 goto done;
1365 }
1366 while (remain > 0) {
1367 struct imsg imsg_log;
1368 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE,
1369 remain);
1370
1371 err = got_privsep_recv_imsg(&imsg_log, ibuf, n);
1372 if (err)
1373 goto done;
1374
1375 if (imsg_log.hdr.type != GOT_IMSG_COMMIT_LOGMSG) {
1376 err = got_error(GOT_ERR_PRIVSEP_MSG);
1377 goto done;
1378 }
1379
1380 memcpy((*commit)->logmsg + offset,
1381 imsg_log.data, n);
1382 imsg_free(&imsg_log);
1383 offset += n;
1384 remain -= n;
1385 }
1386 (*commit)->logmsg[icommit->logmsg_len] = '\0';
1387 }
1388
1389 for (i = 0; i < icommit->nparents; i++) {
1390 struct got_object_qid *qid;
1391
1392 err = got_object_qid_alloc_partial(&qid);
1393 if (err)
1394 break;
1395 memcpy(&qid->id, imsg->data + len +
1396 i * sizeof(qid->id), sizeof(qid->id));
1397 STAILQ_INSERT_TAIL(&(*commit)->parent_ids, qid, entry);
1398 (*commit)->nparents++;
1399 }
1400 done:
1401 if (err) {
1402 got_object_commit_close(*commit);
1403 *commit = NULL;
1404 }
1405 return err;
1406 }
1407
1408 const struct got_error *
1409 got_privsep_recv_commit(struct got_commit_object **commit, struct imsgbuf *ibuf)
1410 {
1411 const struct got_error *err = NULL;
1412 struct imsg imsg;
1413 size_t datalen;
1414 const size_t min_datalen = sizeof(struct got_imsg_commit_object);
1415
1416 *commit = NULL;
1417
1418 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1419 if (err)
1420 return err;
1421
1422 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1423
1424 switch (imsg.hdr.type) {
1425 case GOT_IMSG_COMMIT:
1426 err = get_commit_from_imsg(commit, &imsg, datalen, ibuf);
1427 break;
1428 default:
1429 err = got_error(GOT_ERR_PRIVSEP_MSG);
1430 break;
1431 }
1432
1433 imsg_free(&imsg);
1434
1435 return err;
1436 }
1437
1438 static const struct got_error *
1439 send_tree_entries_batch(struct imsgbuf *ibuf,
1440 struct got_parsed_tree_entry *entries, int idx0, int idxN, size_t len)
1441 {
1442 struct ibuf *wbuf;
1443 struct got_imsg_tree_entries ientries;
1444 int i;
1445
1446 memset(&ientries, 0, sizeof(ientries));
1447
1448 wbuf = imsg_create(ibuf, GOT_IMSG_TREE_ENTRIES, 0, 0, len);
1449 if (wbuf == NULL)
1450 return got_error_from_errno("imsg_create TREE_ENTRY");
1451
1452 ientries.nentries = idxN - idx0 + 1;
1453 if (imsg_add(wbuf, &ientries, sizeof(ientries)) == -1)
1454 return got_error_from_errno("imsg_add TREE_ENTRY");
1455
1456 for (i = idx0; i <= idxN; i++) {
1457 static const char gap[12]; /* for sha1 inside sha256 align */
1458 struct got_parsed_tree_entry *pte = &entries[i];
1459
1460 /* Keep in sync with struct got_imsg_tree_entry definition! */
1461 if (imsg_add(wbuf, pte->id, pte->digest_len) == -1)
1462 return got_error_from_errno("imsg_add TREE_ENTRY");
1463 if (pte->algo == GOT_HASH_SHA1 &&
1464 imsg_add(wbuf, gap, sizeof(gap)) == -1)
1465 return got_error_from_errno("imsg_add TREE_ENTRY");
1466 if (imsg_add(wbuf, &pte->algo, sizeof(pte->algo)) == -1)
1467 return got_error_from_errno("imsg_add TREE_ENTRY");
1468 if (imsg_add(wbuf, &pte->mode, sizeof(pte->mode)) == -1)
1469 return got_error_from_errno("imsg_add TREE_ENTRY");
1470 if (imsg_add(wbuf, &pte->namelen, sizeof(pte->namelen)) == -1)
1471 return got_error_from_errno("imsg_add TREE_ENTRY");
1472
1473 /* Remaining bytes are the entry's name. */
1474 if (imsg_add(wbuf, pte->name, pte->namelen) == -1)
1475 return got_error_from_errno("imsg_add TREE_ENTRY");
1476 }
1477
1478 imsg_close(ibuf, wbuf);
1479 return NULL;
1480 }
1481
1482 static const struct got_error *
1483 send_tree_entries(struct imsgbuf *ibuf, struct got_parsed_tree_entry *entries,
1484 int nentries)
1485 {
1486 const struct got_error *err = NULL;
1487 int i, j;
1488 size_t entries_len = sizeof(struct got_imsg_tree_entries);
1489
1490 i = 0;
1491 for (j = 0; j < nentries; j++) {
1492 struct got_parsed_tree_entry *pte = &entries[j];
1493 size_t len = sizeof(struct got_imsg_tree_entry) + pte->namelen;
1494
1495 if (j > 0 &&
1496 entries_len + len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
1497 err = send_tree_entries_batch(ibuf, entries,
1498 i, j - 1, entries_len);
1499 if (err)
1500 return err;
1501 i = j;
1502 entries_len = sizeof(struct got_imsg_tree_entries);
1503 }
1504
1505 entries_len += len;
1506 }
1507
1508 if (j > 0) {
1509 err = send_tree_entries_batch(ibuf, entries, i, j - 1,
1510 entries_len);
1511 if (err)
1512 return err;
1513 }
1514
1515 return NULL;
1516 }
1517
1518 const struct got_error *
1519 got_privsep_send_tree(struct imsgbuf *ibuf,
1520 struct got_parsed_tree_entry *entries, int nentries)
1521 {
1522 const struct got_error *err = NULL;
1523 struct got_imsg_tree_object itree;
1524
1525 memset(&itree, 0, sizeof(itree));
1526 itree.nentries = nentries;
1527 if (imsg_compose(ibuf, GOT_IMSG_TREE, 0, 0, -1, &itree, sizeof(itree))
1528 == -1)
1529 return got_error_from_errno("imsg_compose TREE");
1530
1531 err = send_tree_entries(ibuf, entries, nentries);
1532 if (err)
1533 return err;
1534
1535 return flush_imsg(ibuf);
1536 }
1537
1538
1539 static const struct got_error *
1540 recv_tree_entries(void *data, size_t datalen, struct got_tree_object *tree,
1541 int *nentries)
1542 {
1543 const struct got_error *err = NULL;
1544 struct got_imsg_tree_entries *ientries;
1545 struct got_tree_entry *te;
1546 size_t te_offset;
1547 size_t i;
1548
1549 if (datalen <= sizeof(*ientries) ||
1550 datalen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
1551 return got_error(GOT_ERR_PRIVSEP_LEN);
1552
1553 ientries = (struct got_imsg_tree_entries *)data;
1554 if (ientries->nentries > INT_MAX) {
1555 return got_error_msg(GOT_ERR_NO_SPACE,
1556 "too many tree entries");
1557 }
1558
1559 te_offset = sizeof(*ientries);
1560 for (i = 0; i < ientries->nentries; i++) {
1561 struct got_imsg_tree_entry ite;
1562 const char *te_name;
1563 uint8_t *buf = (uint8_t *)data + te_offset;
1564
1565 if (te_offset >= datalen) {
1566 err = got_error(GOT_ERR_PRIVSEP_LEN);
1567 break;
1568 }
1569
1570 /* Might not be aligned, size is ~32 bytes. */
1571 memcpy(&ite, buf, sizeof(ite));
1572
1573 if (ite.namelen >= sizeof(te->name)) {
1574 err = got_error(GOT_ERR_PRIVSEP_LEN);
1575 break;
1576 }
1577 if (te_offset + sizeof(ite) + ite.namelen > datalen) {
1578 err = got_error(GOT_ERR_PRIVSEP_LEN);
1579 break;
1580 }
1581
1582 if (*nentries >= tree->nentries) {
1583 err = got_error(GOT_ERR_PRIVSEP_LEN);
1584 break;
1585 }
1586 te = &tree->entries[*nentries];
1587 te_name = buf + sizeof(ite);
1588 memcpy(te->name, te_name, ite.namelen);
1589 te->name[ite.namelen] = '\0';
1590 memcpy(te->id.hash, ite.id, sizeof(te->id.hash));
1591 memcpy(te->id.hash, ite.id, got_hash_digest_length(ite.algo));
1592 te->id.algo = ite.algo;
1593 te->mode = ite.mode;
1594 te->idx = *nentries;
1595 (*nentries)++;
1596
1597 te_offset += sizeof(ite) + ite.namelen;
1598 }
1599
1600 return err;
1601 }
1602
1603 const struct got_error *
1604 got_privsep_recv_tree(struct got_tree_object **tree, struct imsgbuf *ibuf)
1605 {
1606 const struct got_error *err = NULL;
1607 const size_t min_datalen = sizeof(struct got_imsg_tree_object);
1608 struct got_imsg_tree_object *itree;
1609 int nentries = 0;
1610
1611 *tree = NULL;
1612
1613 while (*tree == NULL || nentries < (*tree)->nentries) {
1614 struct imsg imsg;
1615 size_t datalen;
1616
1617 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1618 if (err)
1619 break;
1620
1621 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1622
1623 switch (imsg.hdr.type) {
1624 case GOT_IMSG_TREE:
1625 /* This message should only appear once. */
1626 if (*tree != NULL) {
1627 err = got_error(GOT_ERR_PRIVSEP_MSG);
1628 break;
1629 }
1630 if (datalen != sizeof(*itree)) {
1631 err = got_error(GOT_ERR_PRIVSEP_LEN);
1632 break;
1633 }
1634 itree = imsg.data;
1635 if (itree->nentries < 0) {
1636 err = got_error(GOT_ERR_PRIVSEP_LEN);
1637 break;
1638 }
1639 *tree = malloc(sizeof(**tree));
1640 if (*tree == NULL) {
1641 err = got_error_from_errno("malloc");
1642 break;
1643 }
1644 (*tree)->entries = calloc(itree->nentries,
1645 sizeof(struct got_tree_entry));
1646 if ((*tree)->entries == NULL) {
1647 err = got_error_from_errno("malloc");
1648 free(*tree);
1649 *tree = NULL;
1650 break;
1651 }
1652 (*tree)->nentries = itree->nentries;
1653 (*tree)->refcnt = 0;
1654 break;
1655 case GOT_IMSG_TREE_ENTRIES:
1656 /* This message should be preceeded by GOT_IMSG_TREE. */
1657 if (*tree == NULL) {
1658 err = got_error(GOT_ERR_PRIVSEP_MSG);
1659 break;
1660 }
1661 err = recv_tree_entries(imsg.data, datalen,
1662 *tree, &nentries);
1663 break;
1664 default:
1665 err = got_error(GOT_ERR_PRIVSEP_MSG);
1666 break;
1667 }
1668
1669 imsg_free(&imsg);
1670 if (err)
1671 break;
1672 }
1673
1674 if (*tree && (*tree)->nentries != nentries) {
1675 if (err == NULL)
1676 err = got_error(GOT_ERR_PRIVSEP_LEN);
1677 got_object_tree_close(*tree);
1678 *tree = NULL;
1679 }
1680
1681 return err;
1682 }
1683
1684 const struct got_error *
1685 got_privsep_send_blob(struct imsgbuf *ibuf, size_t size, size_t hdrlen,
1686 const uint8_t *data)
1687 {
1688 struct got_imsg_blob iblob;
1689
1690 memset(&iblob, 0, sizeof(iblob));
1691 iblob.size = size;
1692 iblob.hdrlen = hdrlen;
1693
1694 if (data) {
1695 uint8_t *buf;
1696
1697 if (size > GOT_PRIVSEP_INLINE_BLOB_DATA_MAX)
1698 return got_error(GOT_ERR_NO_SPACE);
1699
1700 buf = malloc(sizeof(iblob) + size);
1701 if (buf == NULL)
1702 return got_error_from_errno("malloc");
1703
1704 memcpy(buf, &iblob, sizeof(iblob));
1705 memcpy(buf + sizeof(iblob), data, size);
1706 if (imsg_compose(ibuf, GOT_IMSG_BLOB, 0, 0, -1, buf,
1707 sizeof(iblob) + size) == -1) {
1708 free(buf);
1709 return got_error_from_errno("imsg_compose BLOB");
1710 }
1711 free(buf);
1712 } else {
1713 /* Data has already been written to file descriptor. */
1714 if (imsg_compose(ibuf, GOT_IMSG_BLOB, 0, 0, -1, &iblob,
1715 sizeof(iblob)) == -1)
1716 return got_error_from_errno("imsg_compose BLOB");
1717 }
1718
1719
1720 return flush_imsg(ibuf);
1721 }
1722
1723 const struct got_error *
1724 got_privsep_recv_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen,
1725 struct imsgbuf *ibuf)
1726 {
1727 const struct got_error *err = NULL;
1728 struct imsg imsg;
1729 struct got_imsg_blob *iblob;
1730 size_t datalen;
1731
1732 *outbuf = NULL;
1733
1734 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
1735 if (err)
1736 return err;
1737
1738 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1739
1740 switch (imsg.hdr.type) {
1741 case GOT_IMSG_BLOB:
1742 if (datalen < sizeof(*iblob)) {
1743 err = got_error(GOT_ERR_PRIVSEP_LEN);
1744 break;
1745 }
1746 iblob = imsg.data;
1747 *size = iblob->size;
1748 *hdrlen = iblob->hdrlen;
1749
1750 if (datalen == sizeof(*iblob)) {
1751 /* Data has been written to file descriptor. */
1752 break;
1753 }
1754
1755 if (*size > GOT_PRIVSEP_INLINE_BLOB_DATA_MAX ||
1756 *size > datalen + sizeof(*iblob)) {
1757 err = got_error(GOT_ERR_PRIVSEP_LEN);
1758 break;
1759 }
1760
1761 *outbuf = malloc(*size);
1762 if (*outbuf == NULL) {
1763 err = got_error_from_errno("malloc");
1764 break;
1765 }
1766 memcpy(*outbuf, imsg.data + sizeof(*iblob), *size);
1767 break;
1768 default:
1769 err = got_error(GOT_ERR_PRIVSEP_MSG);
1770 break;
1771 }
1772
1773 imsg_free(&imsg);
1774
1775 return err;
1776 }
1777
1778 static const struct got_error *
1779 send_tagmsg(struct imsgbuf *ibuf, struct got_tag_object *tag, size_t tagmsg_len)
1780 {
1781 const struct got_error *err = NULL;
1782 size_t offset, remain;
1783
1784 offset = 0;
1785 remain = tagmsg_len;
1786 while (remain > 0) {
1787 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE, remain);
1788
1789 if (imsg_compose(ibuf, GOT_IMSG_TAG_TAGMSG, 0, 0, -1,
1790 tag->tagmsg + offset, n) == -1) {
1791 err = got_error_from_errno("imsg_compose TAG_TAGMSG");
1792 break;
1793 }
1794
1795 err = flush_imsg(ibuf);
1796 if (err)
1797 break;
1798
1799 offset += n;
1800 remain -= n;
1801 }
1802
1803 return err;
1804 }
1805
1806 const struct got_error *
1807 got_privsep_send_tag(struct imsgbuf *ibuf, struct got_tag_object *tag)
1808 {
1809 const struct got_error *err = NULL;
1810 struct got_imsg_tag_object *itag;
1811 uint8_t *buf;
1812 size_t len, total;
1813 size_t tag_len = strlen(tag->tag);
1814 size_t tagger_len = strlen(tag->tagger);
1815 size_t tagmsg_len = strlen(tag->tagmsg);
1816
1817 total = sizeof(*itag) + tag_len + tagger_len + tagmsg_len;
1818
1819 buf = malloc(total);
1820 if (buf == NULL)
1821 return got_error_from_errno("malloc");
1822
1823 itag = (struct got_imsg_tag_object *)buf;
1824 memcpy(&itag->id, &tag->id, sizeof(itag->id));
1825 itag->obj_type = tag->obj_type;
1826 itag->tag_len = tag_len;
1827 itag->tagger_len = tagger_len;
1828 itag->tagger_time = tag->tagger_time;
1829 itag->tagger_gmtoff = tag->tagger_gmtoff;
1830 itag->tagmsg_len = tagmsg_len;
1831
1832 len = sizeof(*itag);
1833 memcpy(buf + len, tag->tag, tag_len);
1834 len += tag_len;
1835 memcpy(buf + len, tag->tagger, tagger_len);
1836 len += tagger_len;
1837
1838 if (imsg_compose(ibuf, GOT_IMSG_TAG, 0, 0, -1, buf, len) == -1) {
1839 err = got_error_from_errno("imsg_compose TAG");
1840 goto done;
1841 }
1842
1843 if (tagmsg_len == 0 ||
1844 tagmsg_len + len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
1845 err = flush_imsg(ibuf);
1846 if (err)
1847 goto done;
1848 }
1849 err = send_tagmsg(ibuf, tag, tagmsg_len);
1850 done:
1851 free(buf);
1852 return err;
1853 }
1854
1855 const struct got_error *
1856 got_privsep_recv_tag(struct got_tag_object **tag, struct imsgbuf *ibuf)
1857 {
1858 const struct got_error *err = NULL;
1859 struct imsg imsg;
1860 struct got_imsg_tag_object *itag;
1861 size_t len, datalen;
1862 const size_t min_datalen = sizeof(struct got_imsg_tag_object);
1863
1864 *tag = NULL;
1865
1866 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
1867 if (err)
1868 return err;
1869
1870 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1871 len = 0;
1872
1873 switch (imsg.hdr.type) {
1874 case GOT_IMSG_TAG:
1875 if (datalen < sizeof(*itag)) {
1876 err = got_error(GOT_ERR_PRIVSEP_LEN);
1877 break;
1878 }
1879 itag = imsg.data;
1880 if (datalen != sizeof(*itag) + itag->tag_len +
1881 itag->tagger_len) {
1882 err = got_error(GOT_ERR_PRIVSEP_LEN);
1883 break;
1884 }
1885 len += sizeof(*itag);
1886
1887 *tag = calloc(1, sizeof(**tag));
1888 if (*tag == NULL) {
1889 err = got_error_from_errno("calloc");
1890 break;
1891 }
1892
1893 memcpy(&(*tag)->id, &itag->id, sizeof(itag->id));
1894
1895 (*tag)->tag = strndup(imsg.data + len, itag->tag_len);
1896 if ((*tag)->tag == NULL) {
1897 err = got_error_from_errno("strndup");
1898 break;
1899 }
1900 len += itag->tag_len;
1901
1902 (*tag)->obj_type = itag->obj_type;
1903 (*tag)->tagger_time = itag->tagger_time;
1904 (*tag)->tagger_gmtoff = itag->tagger_gmtoff;
1905
1906 (*tag)->tagger = strndup(imsg.data + len, itag->tagger_len);
1907 if ((*tag)->tagger == NULL) {
1908 err = got_error_from_errno("strndup");
1909 break;
1910 }
1911 len += itag->tagger_len;
1912
1913 if (itag->tagmsg_len == 0) {
1914 (*tag)->tagmsg = strdup("");
1915 if ((*tag)->tagmsg == NULL) {
1916 err = got_error_from_errno("strdup");
1917 break;
1918 }
1919 } else {
1920 size_t offset = 0, remain = itag->tagmsg_len;
1921
1922 (*tag)->tagmsg = malloc(itag->tagmsg_len + 1);
1923 if ((*tag)->tagmsg == NULL) {
1924 err = got_error_from_errno("malloc");
1925 break;
1926 }
1927 while (remain > 0) {
1928 struct imsg imsg_log;
1929 size_t n = MIN(MAX_IMSGSIZE - IMSG_HEADER_SIZE,
1930 remain);
1931
1932 err = got_privsep_recv_imsg(&imsg_log, ibuf, n);
1933 if (err)
1934 return err;
1935
1936 if (imsg_log.hdr.type != GOT_IMSG_TAG_TAGMSG)
1937 return got_error(GOT_ERR_PRIVSEP_MSG);
1938
1939 memcpy((*tag)->tagmsg + offset, imsg_log.data,
1940 n);
1941 imsg_free(&imsg_log);
1942 offset += n;
1943 remain -= n;
1944 }
1945 (*tag)->tagmsg[itag->tagmsg_len] = '\0';
1946 }
1947
1948 break;
1949 default:
1950 err = got_error(GOT_ERR_PRIVSEP_MSG);
1951 break;
1952 }
1953
1954 imsg_free(&imsg);
1955
1956 return err;
1957 }
1958
1959 const struct got_error *
1960 got_privsep_init_pack_child(struct imsgbuf *ibuf, struct got_pack *pack,
1961 struct got_packidx *packidx)
1962 {
1963 const struct got_error *err = NULL;
1964 struct got_imsg_packidx ipackidx;
1965 struct got_imsg_pack ipack;
1966 int fd;
1967
1968 memset(&ipackidx, 0, sizeof(ipackidx));
1969 memset(&ipack, 0, sizeof(ipack));
1970
1971 ipackidx.len = packidx->len;
1972 ipackidx.packfile_size = pack->filesize;
1973 ipackidx.algo = packidx->algo;
1974 fd = dup(packidx->fd);
1975 if (fd == -1)
1976 return got_error_from_errno("dup");
1977
1978 if (imsg_compose(ibuf, GOT_IMSG_PACKIDX, 0, 0, fd, &ipackidx,
1979 sizeof(ipackidx)) == -1) {
1980 err = got_error_from_errno("imsg_compose PACKIDX");
1981 close(fd);
1982 return err;
1983 }
1984
1985 if (strlcpy(ipack.path_packfile, pack->path_packfile,
1986 sizeof(ipack.path_packfile)) >= sizeof(ipack.path_packfile))
1987 return got_error(GOT_ERR_NO_SPACE);
1988 ipack.filesize = pack->filesize;
1989 ipack.algo = pack->algo;
1990
1991 fd = dup(pack->fd);
1992 if (fd == -1)
1993 return got_error_from_errno("dup");
1994
1995 if (imsg_compose(ibuf, GOT_IMSG_PACK, 0, 0, fd, &ipack, sizeof(ipack))
1996 == -1) {
1997 err = got_error_from_errno("imsg_compose PACK");
1998 close(fd);
1999 return err;
2000 }
2001
2002 return flush_imsg(ibuf);
2003 }
2004
2005 const struct got_error *
2006 got_privsep_send_packed_obj_req(struct imsgbuf *ibuf, int idx,
2007 struct got_object_id *id)
2008 {
2009 struct got_imsg_packed_object iobj;
2010
2011 memset(&iobj, 0, sizeof(iobj));
2012 iobj.idx = idx;
2013 memcpy(&iobj.id, id, sizeof(iobj.id));
2014
2015 if (imsg_compose(ibuf, GOT_IMSG_PACKED_OBJECT_REQUEST, 0, 0, -1,
2016 &iobj, sizeof(iobj)) == -1)
2017 return got_error_from_errno("imsg_compose "
2018 "PACKED_OBJECT_REQUEST");
2019
2020 return flush_imsg(ibuf);
2021 }
2022
2023 const struct got_error *
2024 got_privsep_send_packed_raw_obj_req(struct imsgbuf *ibuf, int idx,
2025 struct got_object_id *id)
2026 {
2027 struct got_imsg_packed_object iobj;
2028
2029 memset(&iobj, 0, sizeof(iobj));
2030 iobj.idx = idx;
2031 memcpy(&iobj.id, id, sizeof(iobj.id));
2032
2033 if (imsg_compose(ibuf, GOT_IMSG_PACKED_RAW_OBJECT_REQUEST, 0, 0, -1,
2034 &iobj, sizeof(iobj)) == -1)
2035 return got_error_from_errno("imsg_compose "
2036 "PACKED_OBJECT_REQUEST");
2037
2038 return flush_imsg(ibuf);
2039 }
2040
2041 const struct got_error *
2042 got_privsep_send_gitconfig_parse_req(struct imsgbuf *ibuf, int fd)
2043 {
2044 const struct got_error *err = NULL;
2045
2046 if (imsg_compose(ibuf, GOT_IMSG_GITCONFIG_PARSE_REQUEST, 0, 0, fd,
2047 NULL, 0) == -1) {
2048 err = got_error_from_errno("imsg_compose "
2049 "GITCONFIG_PARSE_REQUEST");
2050 close(fd);
2051 return err;
2052 }
2053
2054 return flush_imsg(ibuf);
2055 }
2056
2057 const struct got_error *
2058 got_privsep_send_gitconfig_repository_format_version_req(struct imsgbuf *ibuf)
2059 {
2060 if (imsg_compose(ibuf,
2061 GOT_IMSG_GITCONFIG_REPOSITORY_FORMAT_VERSION_REQUEST, 0, 0, -1,
2062 NULL, 0) == -1)
2063 return got_error_from_errno("imsg_compose "
2064 "GITCONFIG_REPOSITORY_FORMAT_VERSION_REQUEST");
2065
2066 return flush_imsg(ibuf);
2067 }
2068
2069 const struct got_error *
2070 got_privsep_send_gitconfig_repository_extensions_req(struct imsgbuf *ibuf)
2071 {
2072 if (imsg_compose(ibuf,
2073 GOT_IMSG_GITCONFIG_REPOSITORY_EXTENSIONS_REQUEST, 0, 0, -1,
2074 NULL, 0) == -1)
2075 return got_error_from_errno("imsg_compose "
2076 "GITCONFIG_REPOSITORY_EXTENSIONS_REQUEST");
2077
2078 return flush_imsg(ibuf);
2079 }
2080
2081
2082 const struct got_error *
2083 got_privsep_send_gitconfig_author_name_req(struct imsgbuf *ibuf)
2084 {
2085 if (imsg_compose(ibuf,
2086 GOT_IMSG_GITCONFIG_AUTHOR_NAME_REQUEST, 0, 0, -1, NULL, 0) == -1)
2087 return got_error_from_errno("imsg_compose "
2088 "GITCONFIG_AUTHOR_NAME_REQUEST");
2089
2090 return flush_imsg(ibuf);
2091 }
2092
2093 const struct got_error *
2094 got_privsep_send_gitconfig_author_email_req(struct imsgbuf *ibuf)
2095 {
2096 if (imsg_compose(ibuf,
2097 GOT_IMSG_GITCONFIG_AUTHOR_EMAIL_REQUEST, 0, 0, -1, NULL, 0) == -1)
2098 return got_error_from_errno("imsg_compose "
2099 "GITCONFIG_AUTHOR_EMAIL_REQUEST");
2100
2101 return flush_imsg(ibuf);
2102 }
2103
2104 const struct got_error *
2105 got_privsep_send_gitconfig_remotes_req(struct imsgbuf *ibuf)
2106 {
2107 if (imsg_compose(ibuf,
2108 GOT_IMSG_GITCONFIG_REMOTES_REQUEST, 0, 0, -1, NULL, 0) == -1)
2109 return got_error_from_errno("imsg_compose "
2110 "GITCONFIG_REMOTE_REQUEST");
2111
2112 return flush_imsg(ibuf);
2113 }
2114
2115 const struct got_error *
2116 got_privsep_send_gitconfig_owner_req(struct imsgbuf *ibuf)
2117 {
2118 if (imsg_compose(ibuf,
2119 GOT_IMSG_GITCONFIG_OWNER_REQUEST, 0, 0, -1, NULL, 0) == -1)
2120 return got_error_from_errno("imsg_compose "
2121 "GITCONFIG_OWNER_REQUEST");
2122
2123 return flush_imsg(ibuf);
2124 }
2125
2126 const struct got_error *
2127 got_privsep_recv_gitconfig_str(char **str, struct imsgbuf *ibuf)
2128 {
2129 const struct got_error *err = NULL;
2130 struct imsg imsg;
2131 size_t datalen;
2132
2133 *str = NULL;
2134
2135 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2136 if (err)
2137 return err;
2138 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2139
2140 switch (imsg.hdr.type) {
2141 case GOT_IMSG_GITCONFIG_STR_VAL:
2142 if (datalen == 0)
2143 break;
2144 *str = strndup(imsg.data, datalen);
2145 if (*str == NULL) {
2146 err = got_error_from_errno("strndup");
2147 break;
2148 }
2149 break;
2150 default:
2151 err = got_error(GOT_ERR_PRIVSEP_MSG);
2152 break;
2153 }
2154
2155 imsg_free(&imsg);
2156 return err;
2157 }
2158
2159 const struct got_error *
2160 got_privsep_recv_gitconfig_pair(char **key, char **val, struct imsgbuf *ibuf)
2161 {
2162 const struct got_error *err = NULL;
2163 struct got_imsg_gitconfig_pair p;
2164 struct imsg imsg;
2165 size_t datalen;
2166 uint8_t *data;
2167
2168 *key = *val = NULL;
2169
2170 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2171 if (err)
2172 return err;
2173
2174 data = imsg.data;
2175 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2176
2177 if (imsg.hdr.type != GOT_IMSG_GITCONFIG_PAIR) {
2178 err = got_error(GOT_ERR_PRIVSEP_MSG);
2179 goto done;
2180 }
2181
2182 if (datalen < sizeof(p)) {
2183 err = got_error(GOT_ERR_PRIVSEP_LEN);
2184 goto done;
2185 }
2186
2187 memcpy(&p, data, sizeof(p));
2188 data += sizeof(p);
2189
2190 if (datalen != sizeof(p) + p.klen + p.vlen) {
2191 err = got_error(GOT_ERR_PRIVSEP_LEN);
2192 goto done;
2193 }
2194
2195 *key = strndup(data, p.klen);
2196 if (*key == NULL) {
2197 err = got_error_from_errno("strndup");
2198 goto done;
2199 }
2200 data += p.klen;
2201
2202 *val = strndup(data, p.vlen);
2203 if (*val == NULL) {
2204 err = got_error_from_errno("strndup");
2205 goto done;
2206 }
2207
2208 done:
2209 imsg_free(&imsg);
2210 return err;
2211 }
2212
2213 const struct got_error *
2214 got_privsep_recv_gitconfig_int(int *val, struct imsgbuf *ibuf)
2215 {
2216 const struct got_error *err = NULL;
2217 struct imsg imsg;
2218 size_t datalen;
2219 const size_t min_datalen = sizeof(int);
2220
2221 *val = 0;
2222
2223 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
2224 if (err)
2225 return err;
2226 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2227
2228 switch (imsg.hdr.type) {
2229 case GOT_IMSG_GITCONFIG_INT_VAL:
2230 if (datalen != sizeof(*val)) {
2231 err = got_error(GOT_ERR_PRIVSEP_LEN);
2232 break;
2233 }
2234 memcpy(val, imsg.data, sizeof(*val));
2235 break;
2236 default:
2237 err = got_error(GOT_ERR_PRIVSEP_MSG);
2238 break;
2239 }
2240
2241 imsg_free(&imsg);
2242 return err;
2243 }
2244
2245 static void
2246 free_remote_data(struct got_remote_repo *remote)
2247 {
2248 int i;
2249
2250 free(remote->name);
2251 free(remote->fetch_url);
2252 free(remote->send_url);
2253 for (i = 0; i < remote->nfetch_branches; i++)
2254 free(remote->fetch_branches[i]);
2255 free(remote->fetch_branches);
2256 for (i = 0; i < remote->nsend_branches; i++)
2257 free(remote->send_branches[i]);
2258 free(remote->send_branches);
2259 for (i = 0; i < remote->nfetch_refs; i++)
2260 free(remote->fetch_refs[i]);
2261 free(remote->fetch_refs);
2262 }
2263
2264 const struct got_error *
2265 got_privsep_recv_gitconfig_remotes(struct got_remote_repo **remotes,
2266 int *nremotes, struct imsgbuf *ibuf)
2267 {
2268 const struct got_error *err = NULL;
2269 struct imsg imsg;
2270 size_t datalen;
2271 struct got_imsg_remotes iremotes;
2272 struct got_imsg_remote iremote;
2273
2274 *remotes = NULL;
2275 *nremotes = 0;
2276 iremotes.nremotes = 0;
2277
2278 err = got_privsep_recv_imsg(&imsg, ibuf, sizeof(iremotes));
2279 if (err)
2280 return err;
2281 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2282
2283 switch (imsg.hdr.type) {
2284 case GOT_IMSG_GITCONFIG_REMOTES:
2285 if (datalen != sizeof(iremotes)) {
2286 imsg_free(&imsg);
2287 return got_error(GOT_ERR_PRIVSEP_LEN);
2288 }
2289 memcpy(&iremotes, imsg.data, sizeof(iremotes));
2290 if (iremotes.nremotes == 0) {
2291 imsg_free(&imsg);
2292 return NULL;
2293 }
2294 break;
2295 default:
2296 imsg_free(&imsg);
2297 return got_error(GOT_ERR_PRIVSEP_MSG);
2298 }
2299
2300 imsg_free(&imsg);
2301
2302 *remotes = recallocarray(NULL, 0, iremotes.nremotes, sizeof(**remotes));
2303 if (*remotes == NULL)
2304 return got_error_from_errno("recallocarray");
2305
2306 while (*nremotes < iremotes.nremotes) {
2307 struct got_remote_repo *remote;
2308
2309 err = got_privsep_recv_imsg(&imsg, ibuf, sizeof(iremote));
2310 if (err)
2311 break;
2312 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2313
2314 switch (imsg.hdr.type) {
2315 case GOT_IMSG_GITCONFIG_REMOTE:
2316 remote = &(*remotes)[*nremotes];
2317 memset(remote, 0, sizeof(*remote));
2318 if (datalen < sizeof(iremote)) {
2319 err = got_error(GOT_ERR_PRIVSEP_LEN);
2320 break;
2321 }
2322 memcpy(&iremote, imsg.data, sizeof(iremote));
2323 if (iremote.name_len == 0 ||
2324 iremote.fetch_url_len == 0 ||
2325 iremote.send_url_len == 0 ||
2326 (sizeof(iremote) + iremote.name_len +
2327 iremote.fetch_url_len + iremote.send_url_len) > datalen) {
2328 err = got_error(GOT_ERR_PRIVSEP_LEN);
2329 break;
2330 }
2331 remote->name = strndup(imsg.data + sizeof(iremote),
2332 iremote.name_len);
2333 if (remote->name == NULL) {
2334 err = got_error_from_errno("strndup");
2335 break;
2336 }
2337 remote->fetch_url = strndup(imsg.data + sizeof(iremote) +
2338 iremote.name_len, iremote.fetch_url_len);
2339 if (remote->fetch_url == NULL) {
2340 err = got_error_from_errno("strndup");
2341 free_remote_data(remote);
2342 break;
2343 }
2344 remote->send_url = strndup(imsg.data + sizeof(iremote) +
2345 iremote.name_len + iremote.fetch_url_len,
2346 iremote.send_url_len);
2347 if (remote->send_url == NULL) {
2348 err = got_error_from_errno("strndup");
2349 free_remote_data(remote);
2350 break;
2351 }
2352 remote->mirror_references = iremote.mirror_references;
2353 remote->fetch_all_branches = iremote.fetch_all_branches;
2354 remote->nfetch_branches = 0;
2355 remote->fetch_branches = NULL;
2356 remote->nsend_branches = 0;
2357 remote->send_branches = NULL;
2358 remote->nfetch_refs = 0;
2359 remote->fetch_refs = NULL;
2360 (*nremotes)++;
2361 break;
2362 default:
2363 err = got_error(GOT_ERR_PRIVSEP_MSG);
2364 break;
2365 }
2366
2367 imsg_free(&imsg);
2368 if (err)
2369 break;
2370 }
2371
2372 if (err) {
2373 int i;
2374 for (i = 0; i < *nremotes; i++)
2375 free_remote_data(&(*remotes)[i]);
2376 free(*remotes);
2377 *remotes = NULL;
2378 *nremotes = 0;
2379 }
2380 return err;
2381 }
2382
2383 const struct got_error *
2384 got_privsep_send_gotconfig_parse_req(struct imsgbuf *ibuf, int fd)
2385 {
2386 const struct got_error *err = NULL;
2387
2388 if (imsg_compose(ibuf, GOT_IMSG_GOTCONFIG_PARSE_REQUEST, 0, 0, fd,
2389 NULL, 0) == -1) {
2390 err = got_error_from_errno("imsg_compose "
2391 "GOTCONFIG_PARSE_REQUEST");
2392 close(fd);
2393 return err;
2394 }
2395
2396 return flush_imsg(ibuf);
2397 }
2398
2399 const struct got_error *
2400 got_privsep_send_gotconfig_author_req(struct imsgbuf *ibuf)
2401 {
2402 if (imsg_compose(ibuf,
2403 GOT_IMSG_GOTCONFIG_AUTHOR_REQUEST, 0, 0, -1, NULL, 0) == -1)
2404 return got_error_from_errno("imsg_compose "
2405 "GOTCONFIG_AUTHOR_REQUEST");
2406
2407 return flush_imsg(ibuf);
2408 }
2409
2410 const struct got_error *
2411 got_privsep_send_gotconfig_allowed_signers_req(struct imsgbuf *ibuf)
2412 {
2413 if (imsg_compose(ibuf,
2414 GOT_IMSG_GOTCONFIG_ALLOWEDSIGNERS_REQUEST, 0, 0, -1, NULL, 0) == -1)
2415 return got_error_from_errno("imsg_compose "
2416 "GOTCONFIG_ALLOWEDSIGNERS_REQUEST");
2417
2418 return flush_imsg(ibuf);
2419 }
2420
2421 const struct got_error *
2422 got_privsep_send_gotconfig_revoked_signers_req(struct imsgbuf *ibuf)
2423 {
2424 if (imsg_compose(ibuf,
2425 GOT_IMSG_GOTCONFIG_REVOKEDSIGNERS_REQUEST, 0, 0, -1, NULL, 0) == -1)
2426 return got_error_from_errno("imsg_compose "
2427 "GOTCONFIG_REVOKEDSIGNERS_REQUEST");
2428
2429 return flush_imsg(ibuf);
2430 }
2431
2432 const struct got_error *
2433 got_privsep_send_gotconfig_signer_id_req(struct imsgbuf *ibuf)
2434 {
2435 if (imsg_compose(ibuf,
2436 GOT_IMSG_GOTCONFIG_SIGNERID_REQUEST, 0, 0, -1, NULL, 0) == -1)
2437 return got_error_from_errno("imsg_compose "
2438 "GOTCONFIG_SIGNERID_REQUEST");
2439
2440 return flush_imsg(ibuf);
2441 }
2442
2443 const struct got_error *
2444 got_privsep_send_gotconfig_remotes_req(struct imsgbuf *ibuf)
2445 {
2446 if (imsg_compose(ibuf,
2447 GOT_IMSG_GOTCONFIG_REMOTES_REQUEST, 0, 0, -1, NULL, 0) == -1)
2448 return got_error_from_errno("imsg_compose "
2449 "GOTCONFIG_REMOTE_REQUEST");
2450
2451 return flush_imsg(ibuf);
2452 }
2453
2454 const struct got_error *
2455 got_privsep_recv_gotconfig_str(char **str, struct imsgbuf *ibuf)
2456 {
2457 const struct got_error *err = NULL;
2458 struct imsg imsg;
2459 size_t datalen;
2460
2461 *str = NULL;
2462
2463 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2464 if (err)
2465 return err;
2466 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2467
2468 switch (imsg.hdr.type) {
2469 case GOT_IMSG_GOTCONFIG_STR_VAL:
2470 if (datalen == 0)
2471 break;
2472 *str = strndup(imsg.data, datalen);
2473 if (*str == NULL) {
2474 err = got_error_from_errno("strndup");
2475 break;
2476 }
2477 break;
2478 default:
2479 err = got_error(GOT_ERR_PRIVSEP_MSG);
2480 break;
2481 }
2482
2483 imsg_free(&imsg);
2484 return err;
2485 }
2486
2487 const struct got_error *
2488 got_privsep_recv_gotconfig_remotes(struct got_remote_repo **remotes,
2489 int *nremotes, struct imsgbuf *ibuf)
2490 {
2491 const struct got_error *err = NULL;
2492 struct imsg imsg;
2493 size_t datalen;
2494 struct got_imsg_remotes iremotes;
2495 struct got_imsg_remote iremote;
2496 const size_t min_datalen = sizeof(iremotes);
2497
2498 *remotes = NULL;
2499 *nremotes = 0;
2500 iremotes.nremotes = 0;
2501
2502 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
2503 if (err)
2504 return err;
2505 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2506
2507 switch (imsg.hdr.type) {
2508 case GOT_IMSG_GOTCONFIG_REMOTES:
2509 if (datalen != sizeof(iremotes)) {
2510 err = got_error(GOT_ERR_PRIVSEP_LEN);
2511 break;
2512 }
2513 memcpy(&iremotes, imsg.data, sizeof(iremotes));
2514 if (iremotes.nremotes < 0) {
2515 err = got_error(GOT_ERR_PRIVSEP_LEN);
2516 break;
2517 }
2518 if (iremotes.nremotes == 0) {
2519 imsg_free(&imsg);
2520 return NULL;
2521 }
2522 break;
2523 default:
2524 imsg_free(&imsg);
2525 return got_error(GOT_ERR_PRIVSEP_MSG);
2526 }
2527
2528 imsg_free(&imsg);
2529
2530 *remotes = recallocarray(NULL, 0, iremotes.nremotes, sizeof(**remotes));
2531 if (*remotes == NULL)
2532 return got_error_from_errno("recallocarray");
2533
2534 while (*nremotes < iremotes.nremotes) {
2535 struct got_remote_repo *remote;
2536 const size_t min_datalen = sizeof(iremote);
2537 int i;
2538
2539 err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
2540 if (err)
2541 break;
2542 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2543
2544 switch (imsg.hdr.type) {
2545 case GOT_IMSG_GOTCONFIG_REMOTE:
2546 remote = &(*remotes)[*nremotes];
2547 memset(remote, 0, sizeof(*remote));
2548 if (datalen < sizeof(iremote)) {
2549 err = got_error(GOT_ERR_PRIVSEP_LEN);
2550 break;
2551 }
2552 memcpy(&iremote, imsg.data, sizeof(iremote));
2553 if (iremote.name_len == 0 ||
2554 (iremote.fetch_url_len == 0 &&
2555 iremote.send_url_len == 0) ||
2556 (sizeof(iremote) + iremote.name_len +
2557 iremote.fetch_url_len + iremote.send_url_len) >
2558 datalen) {
2559 err = got_error(GOT_ERR_PRIVSEP_LEN);
2560 break;
2561 }
2562 remote->name = strndup(imsg.data + sizeof(iremote),
2563 iremote.name_len);
2564 if (remote->name == NULL) {
2565 err = got_error_from_errno("strndup");
2566 break;
2567 }
2568 remote->fetch_url = strndup(imsg.data +
2569 sizeof(iremote) + iremote.name_len,
2570 iremote.fetch_url_len);
2571 if (remote->fetch_url == NULL) {
2572 err = got_error_from_errno("strndup");
2573 free_remote_data(remote);
2574 break;
2575 }
2576 remote->send_url = strndup(imsg.data +
2577 sizeof(iremote) + iremote.name_len +
2578 iremote.fetch_url_len, iremote.send_url_len);
2579 if (remote->send_url == NULL) {
2580 err = got_error_from_errno("strndup");
2581 free_remote_data(remote);
2582 break;
2583 }
2584 remote->mirror_references = iremote.mirror_references;
2585 remote->fetch_all_branches = iremote.fetch_all_branches;
2586 if (iremote.nfetch_branches > 0) {
2587 remote->fetch_branches = recallocarray(NULL, 0,
2588 iremote.nfetch_branches, sizeof(char *));
2589 if (remote->fetch_branches == NULL) {
2590 err = got_error_from_errno("calloc");
2591 free_remote_data(remote);
2592 break;
2593 }
2594 }
2595 remote->nfetch_branches = 0;
2596 for (i = 0; i < iremote.nfetch_branches; i++) {
2597 char *branch;
2598 err = got_privsep_recv_gotconfig_str(&branch,
2599 ibuf);
2600 if (err) {
2601 free_remote_data(remote);
2602 goto done;
2603 }
2604 remote->fetch_branches[i] = branch;
2605 remote->nfetch_branches++;
2606 }
2607 if (iremote.nsend_branches > 0) {
2608 remote->send_branches = recallocarray(NULL, 0,
2609 iremote.nsend_branches, sizeof(char *));
2610 if (remote->send_branches == NULL) {
2611 err = got_error_from_errno("calloc");
2612 free_remote_data(remote);
2613 break;
2614 }
2615 }
2616 remote->nsend_branches = 0;
2617 for (i = 0; i < iremote.nsend_branches; i++) {
2618 char *branch;
2619 err = got_privsep_recv_gotconfig_str(&branch,
2620 ibuf);
2621 if (err) {
2622 free_remote_data(remote);
2623 goto done;
2624 }
2625 remote->send_branches[i] = branch;
2626 remote->nsend_branches++;
2627 }
2628 if (iremote.nfetch_refs > 0) {
2629 remote->fetch_refs = recallocarray(NULL, 0,
2630 iremote.nfetch_refs, sizeof(char *));
2631 if (remote->fetch_refs == NULL) {
2632 err = got_error_from_errno("calloc");
2633 free_remote_data(remote);
2634 break;
2635 }
2636 }
2637 remote->nfetch_refs = 0;
2638 for (i = 0; i < iremote.nfetch_refs; i++) {
2639 char *ref;
2640 err = got_privsep_recv_gotconfig_str(&ref,
2641 ibuf);
2642 if (err) {
2643 free_remote_data(remote);
2644 goto done;
2645 }
2646 remote->fetch_refs[i] = ref;
2647 remote->nfetch_refs++;
2648 }
2649 (*nremotes)++;
2650 break;
2651 default:
2652 err = got_error(GOT_ERR_PRIVSEP_MSG);
2653 break;
2654 }
2655
2656 imsg_free(&imsg);
2657 if (err)
2658 break;
2659 }
2660 done:
2661 if (err) {
2662 int i;
2663 for (i = 0; i < *nremotes; i++)
2664 free_remote_data(&(*remotes)[i]);
2665 free(*remotes);
2666 *remotes = NULL;
2667 *nremotes = 0;
2668 }
2669 return err;
2670 }
2671
2672 const struct got_error *
2673 got_privsep_send_commit_traversal_request(struct imsgbuf *ibuf,
2674 struct got_object_id *id, int idx, const char *path)
2675 {
2676 struct ibuf *wbuf;
2677 size_t path_len = strlen(path);
2678
2679 wbuf = imsg_create(ibuf, GOT_IMSG_COMMIT_TRAVERSAL_REQUEST, 0, 0,
2680 sizeof(struct got_imsg_commit_traversal_request) + path_len);
2681 if (wbuf == NULL)
2682 return got_error_from_errno(
2683 "imsg_create COMMIT_TRAVERSAL_REQUEST");
2684 /*
2685 * Keep in sync with struct got_imsg_commit_traversal_request
2686 * and struct got_imsg_packed_object.
2687 */
2688 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
2689 return got_error_from_errno("imsg_add "
2690 "COMMIT_TRAVERSAL_REQUEST");
2691 if (imsg_add(wbuf, &idx, sizeof(idx)) == -1)
2692 return got_error_from_errno("imsg_add "
2693 "COMMIT_TRAVERSAL_REQUEST");
2694 if (imsg_add(wbuf, &path_len, sizeof(path_len)) == -1)
2695 return got_error_from_errno("imsg_add "
2696 "COMMIT_TRAVERSAL_REQUEST");
2697 if (imsg_add(wbuf, path, path_len) == -1)
2698 return got_error_from_errno("imsg_add "
2699 "COMMIT_TRAVERSAL_REQUEST");
2700
2701 imsg_close(ibuf, wbuf);
2702 return flush_imsg(ibuf);
2703 }
2704
2705 const struct got_error *
2706 got_privsep_recv_traversed_commits(struct got_commit_object **changed_commit,
2707 struct got_object_id_queue *commit_ids, struct imsgbuf *ibuf)
2708 {
2709 const struct got_error *err = NULL;
2710 struct imsg imsg;
2711 struct got_imsg_traversed_commits *icommits;
2712 struct got_object_id *ids;
2713 size_t datalen;
2714 int i, done = 0;
2715
2716 *changed_commit = NULL;
2717
2718 while (!done) {
2719 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2720 if (err)
2721 return err;
2722
2723 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2724 switch (imsg.hdr.type) {
2725 case GOT_IMSG_TRAVERSED_COMMITS:
2726 icommits = imsg.data;
2727 if (datalen != sizeof(*icommits) +
2728 icommits->ncommits * sizeof(*ids)) {
2729 err = got_error(GOT_ERR_PRIVSEP_LEN);
2730 break;
2731 }
2732 ids = imsg.data + sizeof(*icommits);
2733 for (i = 0; i < icommits->ncommits; i++) {
2734 struct got_object_qid *qid;
2735
2736 err = got_object_qid_alloc_partial(&qid);
2737 if (err)
2738 break;
2739 memcpy(&qid->id, &ids[i], sizeof(ids[i]));
2740 STAILQ_INSERT_TAIL(commit_ids, qid, entry);
2741
2742 }
2743 break;
2744 case GOT_IMSG_COMMIT:
2745 err = get_commit_from_imsg(changed_commit, &imsg,
2746 datalen, ibuf);
2747 break;
2748 case GOT_IMSG_COMMIT_TRAVERSAL_DONE:
2749 done = 1;
2750 break;
2751 default:
2752 err = got_error(GOT_ERR_PRIVSEP_MSG);
2753 break;
2754 }
2755
2756 imsg_free(&imsg);
2757 if (err)
2758 break;
2759 }
2760
2761 if (err)
2762 got_object_id_queue_free(commit_ids);
2763 return err;
2764 }
2765
2766 const struct got_error *
2767 got_privsep_send_enumerated_tree(size_t *totlen, struct imsgbuf *ibuf,
2768 struct got_object_id *tree_id, const char *path,
2769 struct got_parsed_tree_entry *entries, int nentries)
2770 {
2771 const struct got_error *err = NULL;
2772 struct ibuf *wbuf;
2773 size_t path_len = strlen(path);
2774 size_t msglen;
2775
2776 msglen = sizeof(struct got_imsg_enumerated_tree) + path_len;
2777 wbuf = imsg_create(ibuf, GOT_IMSG_ENUMERATED_TREE, 0, 0, msglen);
2778 if (wbuf == NULL)
2779 return got_error_from_errno("imsg_create ENUMERATED_TREE");
2780
2781 if (imsg_add(wbuf, tree_id, sizeof(*tree_id)) == -1)
2782 return got_error_from_errno("imsg_add ENUMERATED_TREE");
2783 if (imsg_add(wbuf, &nentries, sizeof(nentries)) == -1)
2784 return got_error_from_errno("imsg_add ENUMERATED_TREE");
2785 if (imsg_add(wbuf, path, path_len) == -1)
2786 return got_error_from_errno("imsg_add ENUMERATED_TREE");
2787
2788 imsg_close(ibuf, wbuf);
2789
2790 if (entries) {
2791 err = send_tree_entries(ibuf, entries, nentries);
2792 if (err)
2793 return err;
2794 }
2795
2796 return flush_imsg(ibuf);
2797 }
2798
2799 const struct got_error *
2800 got_privsep_send_object_enumeration_request(struct imsgbuf *ibuf)
2801 {
2802 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_ENUMERATION_REQUEST,
2803 0, 0, -1, NULL, 0) == -1)
2804 return got_error_from_errno("imsg_compose "
2805 "OBJECT_ENUMERATION_REQUEST");
2806
2807 return flush_imsg(ibuf);
2808 }
2809
2810 const struct got_error *
2811 got_privsep_send_object_enumeration_done(struct imsgbuf *ibuf)
2812 {
2813 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_ENUMERATION_DONE,
2814 0, 0, -1, NULL, 0) == -1)
2815 return got_error_from_errno("imsg_compose "
2816 "OBJECT_ENUMERATION_DONE");
2817
2818 return flush_imsg(ibuf);
2819 }
2820
2821 const struct got_error *
2822 got_privsep_send_object_enumeration_incomplete(struct imsgbuf *ibuf)
2823 {
2824 if (imsg_compose(ibuf, GOT_IMSG_OBJECT_ENUMERATION_INCOMPLETE,
2825 0, 0, -1, NULL, 0) == -1)
2826 return got_error_from_errno("imsg_compose "
2827 "OBJECT_ENUMERATION_INCOMPLETE");
2828
2829 return flush_imsg(ibuf);
2830 }
2831
2832 const struct got_error *
2833 got_privsep_send_enumerated_commit(struct imsgbuf *ibuf,
2834 struct got_object_id *id, time_t mtime)
2835 {
2836 struct ibuf *wbuf;
2837
2838 wbuf = imsg_create(ibuf, GOT_IMSG_ENUMERATED_COMMIT, 0, 0,
2839 sizeof(struct got_imsg_enumerated_commit));
2840 if (wbuf == NULL)
2841 return got_error_from_errno("imsg_create ENUMERATED_COMMIT");
2842
2843 /* Keep in sync with struct got_imsg_enumerated_commit! */
2844 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
2845 return got_error_from_errno("imsg_add ENUMERATED_COMMIT");
2846 if (imsg_add(wbuf, &mtime, sizeof(mtime)) == -1)
2847 return got_error_from_errno("imsg_add ENUMERATED_COMMIT");
2848
2849 imsg_close(ibuf, wbuf);
2850 /* Don't flush yet, tree entries or ENUMERATION_DONE will follow. */
2851 return NULL;
2852 }
2853
2854 const struct got_error *
2855 got_privsep_recv_enumerated_objects(int *found_all_objects,
2856 struct imsgbuf *ibuf,
2857 got_object_enumerate_commit_cb cb_commit,
2858 got_object_enumerate_tree_cb cb_tree, void *cb_arg,
2859 struct got_repository *repo)
2860 {
2861 const struct got_error *err = NULL;
2862 struct imsg imsg;
2863 struct got_imsg_enumerated_commit *icommit = NULL;
2864 struct got_object_id commit_id;
2865 int have_commit = 0;
2866 time_t mtime = 0;
2867 struct got_tree_object tree;
2868 struct got_imsg_enumerated_tree *itree;
2869 struct got_object_id tree_id;
2870 char *path = NULL, *canon_path = NULL;
2871 size_t datalen, path_len;
2872 int nentries = -1;
2873 int done = 0;
2874
2875 *found_all_objects = 0;
2876 memset(&tree, 0, sizeof(tree));
2877
2878 while (!done) {
2879 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
2880 if (err)
2881 break;
2882
2883 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
2884 switch (imsg.hdr.type) {
2885 case GOT_IMSG_ENUMERATED_COMMIT:
2886 if (have_commit && nentries != -1) {
2887 err = got_error(GOT_ERR_PRIVSEP_MSG);
2888 break;
2889 }
2890 if (datalen != sizeof(*icommit)) {
2891 err = got_error(GOT_ERR_PRIVSEP_LEN);
2892 break;
2893 }
2894 icommit = (struct got_imsg_enumerated_commit *)imsg.data;
2895 memcpy(&commit_id, &icommit->id, sizeof(commit_id));
2896 mtime = icommit->mtime;
2897 have_commit = 1;
2898 break;
2899 case GOT_IMSG_ENUMERATED_TREE:
2900 /* Should be preceeded by GOT_IMSG_ENUMERATED_COMMIT. */
2901 if (!have_commit) {
2902 err = got_error(GOT_ERR_PRIVSEP_MSG);
2903 break;
2904 }
2905 if (datalen < sizeof(*itree)) {
2906 err = got_error(GOT_ERR_PRIVSEP_LEN);
2907 break;
2908 }
2909 itree = imsg.data;
2910 path_len = datalen - sizeof(*itree);
2911 if (path_len == 0) {
2912 err = got_error(GOT_ERR_PRIVSEP_LEN);
2913 break;
2914 }
2915 memcpy(&tree_id, &itree->id, sizeof(tree_id));
2916 free(path);
2917 path = strndup(imsg.data + sizeof(*itree), path_len);
2918 if (path == NULL) {
2919 err = got_error_from_errno("strndup");
2920 break;
2921 }
2922 free(canon_path);
2923 canon_path = malloc(path_len + 1);
2924 if (canon_path == NULL) {
2925 err = got_error_from_errno("malloc");
2926 break;
2927 }
2928 if (!got_path_is_absolute(path)) {
2929 err = got_error(GOT_ERR_BAD_PATH);
2930 break;
2931 }
2932 if (got_path_is_root_dir(path)) {
2933 /* XXX check what got_canonpath() does wrong */
2934 canon_path[0] = '/';
2935 canon_path[1] = '\0';
2936 } else {
2937 err = got_canonpath(path, canon_path,
2938 path_len + 1);
2939 if (err)
2940 break;
2941 }
2942 if (strcmp(path, canon_path) != 0) {
2943 err = got_error(GOT_ERR_BAD_PATH);
2944 break;
2945 }
2946 if (nentries != -1) {
2947 err = got_error(GOT_ERR_PRIVSEP_MSG);
2948 break;
2949 }
2950 if (itree->nentries < -1) {
2951 err = got_error(GOT_ERR_PRIVSEP_MSG);
2952 break;
2953 }
2954 if (itree->nentries == -1) {
2955 /* Tree was not found in pack file. */
2956 err = cb_tree(cb_arg, NULL, mtime, &tree_id,
2957 path, repo);
2958 break;
2959 }
2960 if (itree->nentries > INT_MAX) {
2961 err = got_error(GOT_ERR_PRIVSEP_LEN);
2962 break;
2963 }
2964 tree.entries = calloc(itree->nentries,
2965 sizeof(struct got_tree_entry));
2966 if (tree.entries == NULL) {
2967 err = got_error_from_errno("calloc");
2968 break;
2969 }
2970 if (itree->nentries == 0) {
2971 err = cb_tree(cb_arg, &tree, mtime, &tree_id,
2972 path, repo);
2973 if (err)
2974 break;
2975
2976 /* Prepare for next tree. */
2977 free(tree.entries);
2978 memset(&tree, 0, sizeof(tree));
2979 nentries = -1;
2980 } else {
2981 tree.nentries = itree->nentries;
2982 nentries = 0;
2983 }
2984 break;
2985 case GOT_IMSG_TREE_ENTRIES:
2986 /* Should be preceeded by GOT_IMSG_ENUMERATED_TREE. */
2987 if (nentries <= -1) {
2988 err = got_error(GOT_ERR_PRIVSEP_MSG);
2989 break;
2990 }
2991 err = recv_tree_entries(imsg.data, datalen,
2992 &tree, &nentries);
2993 if (err)
2994 break;
2995 if (tree.nentries == nentries) {
2996 err = cb_tree(cb_arg, &tree, mtime, &tree_id,
2997 path, repo);
2998 if (err)
2999 break;
3000
3001 /* Prepare for next tree. */
3002 free(tree.entries);
3003 memset(&tree, 0, sizeof(tree));
3004 nentries = -1;
3005 }
3006 break;
3007 case GOT_IMSG_TREE_ENUMERATION_DONE:
3008 /* All trees have been found and traversed. */
3009 if (!have_commit || path == NULL || nentries != -1) {
3010 err = got_error(GOT_ERR_PRIVSEP_MSG);
3011 break;
3012 }
3013 err = cb_commit(cb_arg, mtime, &commit_id, repo);
3014 if (err)
3015 break;
3016 have_commit = 0;
3017 break;
3018 case GOT_IMSG_OBJECT_ENUMERATION_DONE:
3019 *found_all_objects = 1;
3020 done = 1;
3021 break;
3022 case GOT_IMSG_OBJECT_ENUMERATION_INCOMPLETE:
3023 done = 1;
3024 break;
3025 default:
3026 err = got_error(GOT_ERR_PRIVSEP_MSG);
3027 break;
3028 }
3029
3030 imsg_free(&imsg);
3031 if (err)
3032 break;
3033 }
3034
3035 free(path);
3036 free(canon_path);
3037 free(tree.entries);
3038 return err;
3039 }
3040
3041 const struct got_error *
3042 got_privsep_send_raw_delta_req(struct imsgbuf *ibuf, int idx,
3043 struct got_object_id *id)
3044 {
3045 struct got_imsg_raw_delta_request dreq;
3046
3047 memset(&dreq, 0, sizeof(dreq));
3048 dreq.idx = idx;
3049 memcpy(&dreq.id, id, sizeof(dreq.id));
3050
3051 if (imsg_compose(ibuf, GOT_IMSG_RAW_DELTA_REQUEST, 0, 0, -1,
3052 &dreq, sizeof(dreq)) == -1)
3053 return got_error_from_errno("imsg_compose RAW_DELTA_REQUEST");
3054
3055 return flush_imsg(ibuf);
3056 }
3057
3058 const struct got_error *
3059 got_privsep_send_raw_delta_outfd(struct imsgbuf *ibuf, int fd)
3060 {
3061 return send_fd(ibuf, GOT_IMSG_RAW_DELTA_OUTFD, fd);
3062 }
3063
3064 const struct got_error *
3065 got_privsep_send_raw_delta(struct imsgbuf *ibuf, uint64_t base_size,
3066 uint64_t result_size, off_t delta_size, off_t delta_compressed_size,
3067 off_t delta_offset, off_t delta_out_offset, struct got_object_id *base_id)
3068 {
3069 struct got_imsg_raw_delta idelta;
3070 int ret;
3071
3072 memset(&idelta, 0, sizeof(idelta));
3073 idelta.base_size = base_size;
3074 idelta.result_size = result_size;
3075 idelta.delta_size = delta_size;
3076 idelta.delta_compressed_size = delta_compressed_size;
3077 idelta.delta_offset = delta_offset;
3078 idelta.delta_out_offset = delta_out_offset;
3079 memcpy(&idelta.base_id, &base_id, sizeof(idelta.base_id));
3080
3081 ret = imsg_compose(ibuf, GOT_IMSG_RAW_DELTA, 0, 0, -1,
3082 &idelta, sizeof(idelta));
3083 if (ret == -1)
3084 return got_error_from_errno("imsg_compose RAW_DELTA");
3085
3086 return flush_imsg(ibuf);
3087 }
3088
3089 const struct got_error *
3090 got_privsep_recv_raw_delta(uint64_t *base_size, uint64_t *result_size,
3091 off_t *delta_size, off_t *delta_compressed_size, off_t *delta_offset,
3092 off_t *delta_out_offset, struct got_object_id **base_id,
3093 struct imsgbuf *ibuf)
3094 {
3095 const struct got_error *err = NULL;
3096 struct imsg imsg;
3097 struct got_imsg_raw_delta *delta;
3098 size_t datalen;
3099
3100 *base_size = 0;
3101 *result_size = 0;
3102 *delta_size = 0;
3103 *delta_compressed_size = 0;
3104 *delta_offset = 0;
3105 *delta_out_offset = 0;
3106 *base_id = NULL;
3107
3108 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3109 if (err)
3110 return err;
3111
3112 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3113
3114 switch (imsg.hdr.type) {
3115 case GOT_IMSG_RAW_DELTA:
3116 if (datalen != sizeof(*delta)) {
3117 err = got_error(GOT_ERR_PRIVSEP_LEN);
3118 break;
3119 }
3120 delta = imsg.data;
3121 *base_size = delta->base_size;
3122 *result_size = delta->result_size;
3123 *delta_size = delta->delta_size;
3124 *delta_compressed_size = delta->delta_compressed_size;
3125 *delta_offset = delta->delta_offset;
3126 *delta_out_offset = delta->delta_out_offset;
3127 *base_id = calloc(1, sizeof(**base_id));
3128 if (*base_id == NULL) {
3129 err = got_error_from_errno("malloc");
3130 break;
3131 }
3132 memcpy(*base_id, &delta->base_id, sizeof(**base_id));
3133 break;
3134 default:
3135 err = got_error(GOT_ERR_PRIVSEP_MSG);
3136 break;
3137 }
3138
3139 imsg_free(&imsg);
3140
3141 if (err) {
3142 free(*base_id);
3143 *base_id = NULL;
3144 }
3145 return err;
3146 }
3147
3148 static const struct got_error *
3149 send_idlist(struct imsgbuf *ibuf, struct got_object_id **ids, size_t nids)
3150 {
3151 const struct got_error *err = NULL;
3152 struct got_imsg_object_idlist idlist;
3153 struct ibuf *wbuf;
3154 size_t i;
3155
3156 memset(&idlist, 0, sizeof(idlist));
3157
3158 if (nids > GOT_IMSG_OBJ_ID_LIST_MAX_NIDS)
3159 return got_error(GOT_ERR_NO_SPACE);
3160
3161 wbuf = imsg_create(ibuf, GOT_IMSG_OBJ_ID_LIST, 0, 0,
3162 sizeof(idlist) + nids * sizeof(**ids));
3163 if (wbuf == NULL) {
3164 err = got_error_from_errno("imsg_create OBJ_ID_LIST");
3165 return err;
3166 }
3167
3168 idlist.nids = nids;
3169 if (imsg_add(wbuf, &idlist, sizeof(idlist)) == -1)
3170 return got_error_from_errno("imsg_add OBJ_ID_LIST");
3171
3172 for (i = 0; i < nids; i++) {
3173 struct got_object_id *id = ids[i];
3174 if (imsg_add(wbuf, id, sizeof(*id)) == -1)
3175 return got_error_from_errno("imsg_add OBJ_ID_LIST");
3176 }
3177
3178 imsg_close(ibuf, wbuf);
3179
3180 return flush_imsg(ibuf);
3181 }
3182
3183 const struct got_error *
3184 got_privsep_send_object_idlist(struct imsgbuf *ibuf,
3185 struct got_object_id **ids, size_t nids)
3186 {
3187 const struct got_error *err = NULL;
3188 struct got_object_id *idlist[GOT_IMSG_OBJ_ID_LIST_MAX_NIDS];
3189 int i, queued = 0;
3190
3191 for (i = 0; i < nids; i++) {
3192 idlist[i % nitems(idlist)] = ids[i];
3193 queued++;
3194 if (queued >= nitems(idlist)) {
3195 err = send_idlist(ibuf, idlist, queued);
3196 if (err)
3197 return err;
3198 queued = 0;
3199 }
3200 }
3201
3202 if (queued > 0) {
3203 err = send_idlist(ibuf, idlist, queued);
3204 if (err)
3205 return err;
3206 }
3207
3208 return NULL;
3209 }
3210
3211 const struct got_error *
3212 got_privsep_send_object_idlist_done(struct imsgbuf *ibuf)
3213 {
3214 if (imsg_compose(ibuf, GOT_IMSG_OBJ_ID_LIST_DONE, 0, 0, -1, NULL, 0)
3215 == -1)
3216 return got_error_from_errno("imsg_compose OBJ_ID_LIST_DONE");
3217
3218 return flush_imsg(ibuf);
3219 }
3220
3221 const struct got_error *
3222 got_privsep_recv_object_idlist(int *done, struct got_object_id **ids,
3223 size_t *nids, struct imsgbuf *ibuf)
3224 {
3225 const struct got_error *err = NULL;
3226 struct imsg imsg;
3227 struct got_imsg_object_idlist *idlist;
3228 size_t datalen;
3229
3230 *ids = NULL;
3231 *done = 0;
3232 *nids = 0;
3233
3234 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3235 if (err)
3236 return err;
3237
3238 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3239 switch (imsg.hdr.type) {
3240 case GOT_IMSG_OBJ_ID_LIST:
3241 if (datalen < sizeof(*idlist)) {
3242 err = got_error(GOT_ERR_PRIVSEP_LEN);
3243 break;
3244 }
3245 idlist = imsg.data;
3246 if (idlist->nids > GOT_IMSG_OBJ_ID_LIST_MAX_NIDS ||
3247 idlist->nids * sizeof(**ids) > datalen - sizeof(*idlist)) {
3248 err = got_error(GOT_ERR_PRIVSEP_LEN);
3249 break;
3250 }
3251 *nids = idlist->nids;
3252 *ids = calloc(*nids, sizeof(**ids));
3253 if (*ids == NULL) {
3254 err = got_error_from_errno("calloc");
3255 break;
3256 }
3257 memcpy(*ids, (uint8_t *)imsg.data + sizeof(*idlist),
3258 *nids * sizeof(**ids));
3259 break;
3260 case GOT_IMSG_OBJ_ID_LIST_DONE:
3261 *done = 1;
3262 break;
3263 default:
3264 err = got_error(GOT_ERR_PRIVSEP_MSG);
3265 break;
3266 }
3267
3268 imsg_free(&imsg);
3269
3270 return err;
3271 }
3272
3273 const struct got_error *
3274 got_privsep_send_delta_reuse_req(struct imsgbuf *ibuf)
3275 {
3276 if (imsg_compose(ibuf, GOT_IMSG_DELTA_REUSE_REQUEST, 0, 0, -1, NULL, 0)
3277 == -1)
3278 return got_error_from_errno("imsg_compose DELTA_REUSE_REQUEST");
3279
3280 return flush_imsg(ibuf);
3281 }
3282
3283 const struct got_error *
3284 got_privsep_send_reused_deltas(struct imsgbuf *ibuf,
3285 struct got_imsg_reused_delta *deltas, size_t ndeltas)
3286 {
3287 const struct got_error *err = NULL;
3288 struct ibuf *wbuf;
3289 struct got_imsg_reused_deltas ideltas;
3290 size_t i;
3291
3292 memset(&ideltas, 0, sizeof(ideltas));
3293
3294 if (ndeltas > GOT_IMSG_REUSED_DELTAS_MAX_NDELTAS)
3295 return got_error(GOT_ERR_NO_SPACE);
3296
3297 wbuf = imsg_create(ibuf, GOT_IMSG_REUSED_DELTAS, 0, 0,
3298 sizeof(ideltas) + ndeltas * sizeof(*deltas));
3299 if (wbuf == NULL) {
3300 err = got_error_from_errno("imsg_create REUSED_DELTAS");
3301 return err;
3302 }
3303
3304 ideltas.ndeltas = ndeltas;
3305 if (imsg_add(wbuf, &ideltas, sizeof(ideltas)) == -1)
3306 return got_error_from_errno("imsg_add REUSED_DELTAS");
3307
3308 for (i = 0; i < ndeltas; i++) {
3309 struct got_imsg_reused_delta *delta = &deltas[i];
3310 if (imsg_add(wbuf, delta, sizeof(*delta)) == -1)
3311 return got_error_from_errno("imsg_add REUSED_DELTAS");
3312 }
3313
3314 imsg_close(ibuf, wbuf);
3315
3316 return flush_imsg(ibuf);
3317 }
3318
3319 const struct got_error *
3320 got_privsep_send_reused_deltas_done(struct imsgbuf *ibuf)
3321 {
3322 if (imsg_compose(ibuf, GOT_IMSG_DELTA_REUSE_DONE, 0, 0, -1, NULL, 0)
3323 == -1)
3324 return got_error_from_errno("imsg_compose DELTA_REUSE_DONE");
3325
3326 return flush_imsg(ibuf);
3327 }
3328
3329 const struct got_error *
3330 got_privsep_recv_reused_deltas(int *done, struct got_imsg_reused_delta *deltas,
3331 size_t *ndeltas, struct imsgbuf *ibuf)
3332 {
3333 const struct got_error *err = NULL;
3334 struct imsg imsg;
3335 struct got_imsg_reused_deltas *ideltas;
3336 size_t datalen;
3337
3338 *done = 0;
3339 *ndeltas = 0;
3340
3341 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3342 if (err)
3343 return err;
3344
3345 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3346 switch (imsg.hdr.type) {
3347 case GOT_IMSG_REUSED_DELTAS:
3348 if (datalen < sizeof(*ideltas)) {
3349 err = got_error(GOT_ERR_PRIVSEP_LEN);
3350 break;
3351 }
3352 ideltas = imsg.data;
3353 if (ideltas->ndeltas > GOT_IMSG_OBJ_ID_LIST_MAX_NIDS ||
3354 ideltas->ndeltas * sizeof(*deltas) >
3355 datalen - sizeof(*ideltas)) {
3356 err = got_error(GOT_ERR_PRIVSEP_LEN);
3357 break;
3358 }
3359 *ndeltas = ideltas->ndeltas;
3360 memcpy(deltas, (uint8_t *)imsg.data + sizeof(*ideltas),
3361 *ndeltas * sizeof(*deltas));
3362 break;
3363 case GOT_IMSG_DELTA_REUSE_DONE:
3364 *done = 1;
3365 break;
3366 default:
3367 err = got_error(GOT_ERR_PRIVSEP_MSG);
3368 break;
3369 }
3370
3371 imsg_free(&imsg);
3372
3373 return err;
3374 }
3375
3376 const struct got_error *
3377 got_privsep_init_commit_painting(struct imsgbuf *ibuf)
3378 {
3379 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_PAINTING_INIT,
3380 0, 0, -1, NULL, 0) == -1)
3381 return got_error_from_errno("imsg_compose "
3382 "COMMIT_PAINTING_INIT");
3383
3384 return flush_imsg(ibuf);
3385 }
3386
3387 const struct got_error *
3388 got_privsep_send_painting_request(struct imsgbuf *ibuf)
3389 {
3390 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_PAINTING_REQUEST, 0, 0, -1,
3391 NULL, 0) == -1)
3392 return got_error_from_errno("imsg_compose "
3393 "COMMIT_PAINTING_REQUEST");
3394
3395 return flush_imsg(ibuf);
3396 }
3397
3398 static const struct got_error *
3399 send_painted_commits(struct got_object_id_queue *ids, int *nids,
3400 size_t remain, int present_in_pack, struct imsgbuf *ibuf)
3401 {
3402 const struct got_error *err = NULL;
3403 struct ibuf *wbuf = NULL;
3404 struct got_object_qid *qid;
3405 size_t msglen;
3406 int ncommits;
3407 intptr_t color;
3408
3409 msglen = MIN(remain, MAX_IMSGSIZE - IMSG_HEADER_SIZE);
3410 ncommits = (msglen - sizeof(struct got_imsg_painted_commits)) /
3411 sizeof(struct got_imsg_painted_commit);
3412
3413 wbuf = imsg_create(ibuf, GOT_IMSG_PAINTED_COMMITS, 0, 0, msglen);
3414 if (wbuf == NULL) {
3415 err = got_error_from_errno("imsg_create PAINTED_COMMITS");
3416 return err;
3417 }
3418
3419 /* Keep in sync with struct got_imsg_painted_commits! */
3420 if (imsg_add(wbuf, &ncommits, sizeof(ncommits)) == -1)
3421 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3422 if (imsg_add(wbuf, &present_in_pack, sizeof(present_in_pack)) == -1)
3423 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3424
3425 while (ncommits > 0) {
3426 qid = STAILQ_FIRST(ids);
3427 STAILQ_REMOVE_HEAD(ids, entry);
3428 ncommits--;
3429 (*nids)--;
3430 color = (intptr_t)qid->data;
3431
3432 /* Keep in sync with struct got_imsg_painted_commit! */
3433 if (imsg_add(wbuf, &qid->id, sizeof(qid->id)) == -1)
3434 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3435 if (imsg_add(wbuf, &color, sizeof(color)) == -1)
3436 return got_error_from_errno("imsg_add PAINTED_COMMITS");
3437
3438 got_object_qid_free(qid);
3439 }
3440
3441 imsg_close(ibuf, wbuf);
3442 return flush_imsg(ibuf);
3443 }
3444
3445 const struct got_error *
3446 got_privsep_send_painted_commits(struct imsgbuf *ibuf,
3447 struct got_object_id_queue *ids, int *nids,
3448 int present_in_pack, int flush)
3449 {
3450 const struct got_error *err;
3451 size_t remain;
3452
3453 if (*nids <= 0)
3454 return NULL;
3455
3456 do {
3457 remain = (sizeof(struct got_imsg_painted_commits)) +
3458 *nids * sizeof(struct got_imsg_painted_commit);
3459 if (flush || remain >= MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
3460 err = send_painted_commits(ids, nids, remain,
3461 present_in_pack, ibuf);
3462 if (err)
3463 return err;
3464 }
3465 } while (flush && *nids > 0);
3466
3467 return NULL;
3468 }
3469
3470 const struct got_error *
3471 got_privsep_send_painting_commits_done(struct imsgbuf *ibuf)
3472 {
3473 if (imsg_compose(ibuf, GOT_IMSG_COMMIT_PAINTING_DONE,
3474 0, 0, -1, NULL, 0)
3475 == -1)
3476 return got_error_from_errno("imsg_compose "
3477 "COMMIT_PAINTING_DONE");
3478
3479 return flush_imsg(ibuf);
3480 }
3481
3482 const struct got_error *
3483 got_privsep_recv_painted_commits(struct got_object_id_queue *new_ids,
3484 got_privsep_recv_painted_commit_cb cb, void *cb_arg, struct imsgbuf *ibuf)
3485 {
3486 const struct got_error *err = NULL;
3487 struct imsg imsg;
3488 struct got_imsg_painted_commits icommits;
3489 struct got_imsg_painted_commit icommit;
3490 size_t datalen;
3491 int i;
3492
3493 for (;;) {
3494 err = got_privsep_recv_imsg(&imsg, ibuf, 0);
3495 if (err)
3496 return err;
3497
3498 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
3499 if (imsg.hdr.type == GOT_IMSG_COMMIT_PAINTING_DONE) {
3500 imsg_free(&imsg);
3501 return NULL;
3502 }
3503 if (imsg.hdr.type != GOT_IMSG_PAINTED_COMMITS){
3504 imsg_free(&imsg);
3505 return got_error(GOT_ERR_PRIVSEP_MSG);
3506 }
3507
3508 if (datalen < sizeof(icommits)){
3509 imsg_free(&imsg);
3510 return got_error(GOT_ERR_PRIVSEP_LEN);
3511 }
3512 memcpy(&icommits, imsg.data, sizeof(icommits));
3513 if (icommits.ncommits * sizeof(icommit) < icommits.ncommits ||
3514 datalen < sizeof(icommits) +
3515 icommits.ncommits * sizeof(icommit)){
3516 imsg_free(&imsg);
3517 return got_error(GOT_ERR_PRIVSEP_LEN);
3518 }
3519
3520 for (i = 0; i < icommits.ncommits; i++) {
3521 memcpy(&icommit,
3522 (uint8_t *)imsg.data + sizeof(icommits) + i * sizeof(icommit),
3523 sizeof(icommit));
3524
3525 if (icommits.present_in_pack) {
3526 struct got_object_id id;
3527 memcpy(&id, &icommit.id, sizeof(id));
3528 err = cb(cb_arg, &id, icommit.color);
3529 if (err)
3530 break;
3531 } else {
3532 struct got_object_qid *qid;
3533 err = got_object_qid_alloc_partial(&qid);
3534 if (err)
3535 break;
3536 memcpy(&qid->id, &icommit.id,
3537 sizeof(qid->id));
3538 qid->data = (void *)icommit.color;
3539 STAILQ_INSERT_TAIL(new_ids, qid, entry);
3540 }
3541 }
3542
3543 imsg_free(&imsg);
3544 if (err)
3545 return err;
3546 }
3547 }
3548
3549 const struct got_error *
3550 got_privsep_unveil_exec_helpers(void)
3551 {
3552 const char *helpers[] = {
3553 GOT_PATH_PROG_READ_PACK,
3554 GOT_PATH_PROG_READ_OBJECT,
3555 GOT_PATH_PROG_READ_COMMIT,
3556 GOT_PATH_PROG_READ_TREE,
3557 GOT_PATH_PROG_READ_BLOB,
3558 GOT_PATH_PROG_READ_TAG,
3559 GOT_PATH_PROG_READ_GITCONFIG,
3560 GOT_PATH_PROG_READ_GOTCONFIG,
3561 GOT_PATH_PROG_READ_PATCH,
3562 GOT_PATH_PROG_FETCH_PACK,
3563 GOT_PATH_PROG_INDEX_PACK,
3564 GOT_PATH_PROG_SEND_PACK,
3565 /* GOT_PATH_PROG_FETCH_HTTP explicitly excluded */
3566 };
3567 size_t i;
3568
3569 for (i = 0; i < nitems(helpers); i++) {
3570 if (unveil(helpers[i], "x") == 0)
3571 continue;
3572 return got_error_from_errno2("unveil", helpers[i]);
3573 }
3574
3575 return NULL;
3576 }
3577
3578 void
3579 got_privsep_exec_child(int imsg_fds[2], const char *path, const char *repo_path)
3580 {
3581 if (close(imsg_fds[0]) == -1) {
3582 fprintf(stderr, "%s: %s\n", getprogname(), strerror(errno));
3583 _exit(1);
3584 }
3585
3586 if (dup2(imsg_fds[1], GOT_IMSG_FD_CHILD) == -1) {
3587 fprintf(stderr, "%s: %s\n", getprogname(), strerror(errno));
3588 _exit(1);
3589 }
3590
3591 closefrom(GOT_IMSG_FD_CHILD + 1);
3592
3593 if (execl(path, path, repo_path, (char *)NULL) == -1) {
3594 fprintf(stderr, "%s: %s: %s\n", getprogname(), path,
3595 strerror(errno));
3596 _exit(1);
3597 }
3598 }
portable version of Game of Trees