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