op public repos

Blob

Date:: Sat Sep 8 14:40:28 2018 UTC
Message:: implement fork+exec (and by the way, fix the build...)
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/types.h>
18 #include <sys/queue.h>
19 #include <sys/uio.h>
20 
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <stdint.h>
26 #include <poll.h>
27 #include <imsg.h>
28 #include <sha1.h>
29 #include <zlib.h>
30 #include <time.h>
31 
32 #include "got_object.h"
33 #include "got_error.h"
34 
35 #include "got_lib_sha1.h"
36 #include "got_lib_delta.h"
37 #include "got_lib_inflate.h"
38 #include "got_lib_object.h"
39 #include "got_lib_object_parse.h"
40 #include "got_lib_privsep.h"
41 
42 #ifndef MIN
43 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
44 #endif
45 
46 static const struct got_error *
47 poll_fd(int fd, int events, int timeout)
48 {
49 	struct pollfd pfd[1];
50 	int n;
51 
52 	pfd[0].fd = fd;
53 	pfd[0].events = events;
54 
55 	n = poll(pfd, 1, timeout);
56 	if (n == -1)
57 		return got_error_from_errno();
58 	if (n == 0)
59 		return got_error(GOT_ERR_TIMEOUT);
60 	if (pfd[0].revents & (POLLERR | POLLNVAL))
61 		return got_error_from_errno();
62 	if (pfd[0].revents & (events | POLLHUP))
63 		return NULL;
64 
65 	return got_error(GOT_ERR_INTERRUPT);
66 }
67 
68 static const struct got_error *
69 read_imsg(struct imsgbuf *ibuf)
70 {
71 	const struct got_error *err;
72 	size_t n;
73 
74 	err = poll_fd(ibuf->fd, POLLIN, INFTIM);
75 	if (err)
76 		return err;
77 
78 	n = imsg_read(ibuf);
79 	if (n == -1) {
80 		if (errno == EAGAIN) /* Could be a file-descriptor leak. */
81 			return got_error(GOT_ERR_PRIVSEP_NO_FD);
82 		return got_error(GOT_ERR_PRIVSEP_READ);
83 	}
84 	if (n == 0)
85 		return got_error(GOT_ERR_PRIVSEP_PIPE);
86 
87 	return NULL;
88 }
89 
90 const struct got_error *
91 got_privsep_recv_imsg(struct imsg *imsg, struct imsgbuf *ibuf, size_t min_datalen)
92 {
93 	const struct got_error *err;
94 	ssize_t n;
95 
96 	err = read_imsg(ibuf);
97 	if (err)
98 		return err;
99 
100 	n = imsg_get(ibuf, imsg);
101 	if (n == 0)
102 		return got_error(GOT_ERR_PRIVSEP_READ);
103 
104 	if (imsg->hdr.len < IMSG_HEADER_SIZE + min_datalen)
105 		return got_error(GOT_ERR_PRIVSEP_LEN);
106 
107 	return NULL;
108 }
109 
110 static const struct got_error *
111 recv_imsg_error(struct imsg *imsg, size_t datalen)
112 {
113 	struct got_imsg_error ierr;
114 
115 	if (datalen != sizeof(ierr))
116 		return got_error(GOT_ERR_PRIVSEP_LEN);
117 
118 	memcpy(&ierr, imsg->data, sizeof(ierr));
119 	if (ierr.code == GOT_ERR_ERRNO) {
120 		static struct got_error serr;
121 		serr.code = GOT_ERR_ERRNO;
122 		serr.msg = strerror(ierr.errno_code);
123 		return &serr;
124 	}
125 
126 	return got_error(ierr.code);
127 }
128 
129 /* Attempt to send an error in an imsg. Complain on stderr as a last resort. */
130 void
131 got_privsep_send_error(struct imsgbuf *ibuf, const struct got_error *err)
132 {
133 	const struct got_error *poll_err;
134 	struct got_imsg_error ierr;
135 	int ret;
136 
137 	ierr.code = err->code;
138 	if (err->code == GOT_ERR_ERRNO)
139 		ierr.errno_code = errno;
140 	else
141 		ierr.errno_code = 0;
142 	ret = imsg_compose(ibuf, GOT_IMSG_ERROR, 0, 0, -1, &ierr, sizeof(ierr));
143 	if (ret != -1) {
144 		fprintf(stderr, "%s: error %d \"%s\": imsg_compose: %s\n",
145 		    getprogname(), err->code, err->msg, strerror(errno));
146 		return;
147 	}
148 
149 	poll_err = poll_fd(ibuf->fd, POLLOUT, INFTIM);
150 	if (poll_err) {
151 		fprintf(stderr, "%s: error %d \"%s\": poll: %s\n",
152 		    getprogname(), err->code, err->msg, poll_err->msg);
153 		return;
154 	}
155 
156 	ret = imsg_flush(ibuf);
157 	if (ret == -1) {
158 		fprintf(stderr, "%s: error %d \"%s\": imsg_flush: %s\n",
159 		    getprogname(), err->code, err->msg, strerror(errno));
160 		return;
161 	}
162 }
163 
164 static const struct got_error *
165 flush_imsg(struct imsgbuf *ibuf)
166 {
167 	const struct got_error *err;
168 
169 	err = poll_fd(ibuf->fd, POLLOUT, INFTIM);
170 	if (err)
171 		return err;
172 
173 	if (imsg_flush(ibuf) == -1)
174 		return got_error_from_errno();
175 
176 	return NULL;
177 }
178 
179 const struct got_error *
180 got_privsep_send_stop(int fd)
181 {
182 	const struct got_error *err = NULL;
183 	struct imsgbuf ibuf;
184 
185 	imsg_init(&ibuf, fd);
186 
187 	if (imsg_compose(&ibuf, GOT_IMSG_STOP, 0, 0, -1, NULL, 0) == -1)
188 		return got_error_from_errno();
189 
190 	err = flush_imsg(&ibuf);
191 	imsg_clear(&ibuf);
192 	return err;
193 }
194 
195 const struct got_error *
196 got_privsep_send_obj_req(struct imsgbuf *ibuf, int fd, struct got_object *obj)
197 {
198 	struct got_imsg_object iobj, *iobjp = NULL;
199 	size_t iobj_size = 0;
200 	int imsg_code = GOT_IMSG_OBJECT_REQUEST;
201 
202 	if (obj) {
203 		switch (obj->type) {
204 		case GOT_OBJ_TYPE_TREE:
205 			imsg_code = GOT_IMSG_TREE_REQUEST;
206 			break;
207 		case GOT_OBJ_TYPE_COMMIT:
208 			imsg_code = GOT_IMSG_COMMIT_REQUEST;
209 			break;
210 		default:
211 			return got_error(GOT_ERR_OBJ_TYPE);
212 		}
213 
214 		iobj.type = obj->type;
215 		iobj.flags = obj->flags;
216 		iobj.hdrlen = obj->hdrlen;
217 		iobj.size = obj->size;
218 		iobj.ndeltas = 0;
219 
220 		iobjp = &iobj;
221 		iobj_size = sizeof(iobj);
222 	}
223 
224 	if (imsg_compose(ibuf, imsg_code, 0, 0, fd, iobjp, iobj_size) == -1)
225 		return got_error_from_errno();
226 
227 	return flush_imsg(ibuf);
228 }
229 
230 const struct got_error *
231 got_privsep_send_blob_req(struct imsgbuf *ibuf, int outfd, int infd)
232 {
233 	const struct got_error *err = NULL;
234 
235 	if (imsg_compose(ibuf, GOT_IMSG_BLOB_REQUEST, 0, 0, infd, NULL, 0)
236 	    == -1) {
237 		close(infd);
238 		close(outfd);
239 		return got_error_from_errno();
240 	}
241 
242 	err = flush_imsg(ibuf);
243 	if (err) {
244 		close(outfd);
245 		return err;
246 	}
247 
248 	if (imsg_compose(ibuf, GOT_IMSG_BLOB_OUTFD, 0, 0, outfd, NULL, 0)
249 	    == -1) {
250 		close(outfd);
251 		return got_error_from_errno();
252 	}
253 
254 	return flush_imsg(ibuf);
255 }
256 
257 const struct got_error *
258 got_privsep_send_obj(struct imsgbuf *ibuf, struct got_object *obj, int ndeltas)
259 {
260 	struct got_imsg_object iobj;
261 
262 	iobj.type = obj->type;
263 	iobj.flags = obj->flags;
264 	iobj.hdrlen = obj->hdrlen;
265 	iobj.size = obj->size;
266 	iobj.ndeltas = ndeltas;
267 
268 	if (ndeltas > 0) {
269 		/* TODO: Handle deltas */
270 	}
271 
272 	if (imsg_compose(ibuf, GOT_IMSG_OBJECT, 0, 0, -1, &iobj, sizeof(iobj))
273 	    == -1)
274 		return got_error_from_errno();
275 
276 	return flush_imsg(ibuf);
277 }
278 
279 const struct got_error *
280 got_privsep_recv_obj(struct got_object **obj, struct imsgbuf *ibuf)
281 {
282 	const struct got_error *err = NULL;
283 	struct imsg imsg;
284 	struct got_imsg_object iobj;
285 	size_t datalen;
286 	int i;
287 	const size_t min_datalen =
288 	    MIN(sizeof(struct got_imsg_error), sizeof(struct got_imsg_object));
289 
290 	*obj = NULL;
291 
292 	err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
293 	if (err)
294 		return err;
295 
296 	datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
297 
298 	switch (imsg.hdr.type) {
299 	case GOT_IMSG_ERROR:
300 		err = recv_imsg_error(&imsg, datalen);
301 		break;
302 	case GOT_IMSG_OBJECT:
303 		if (datalen != sizeof(iobj)) {
304 			err = got_error(GOT_ERR_PRIVSEP_LEN);
305 			break;
306 		}
307 
308 		memcpy(&iobj, imsg.data, sizeof(iobj));
309 		if (iobj.ndeltas < 0 ||
310 		    iobj.ndeltas > GOT_DELTA_CHAIN_RECURSION_MAX) {
311 			err = got_error(GOT_ERR_PRIVSEP_LEN);
312 			break;
313 		}
314 
315 		*obj = calloc(1, sizeof(**obj));
316 		if (*obj == NULL) {
317 			err = got_error_from_errno();
318 			break;
319 		}
320 
321 		(*obj)->type = iobj.type;
322 		(*obj)->hdrlen = iobj.hdrlen;
323 		(*obj)->size = iobj.size;
324 		for (i = 0; i < iobj.ndeltas; i++) {
325 			/* TODO: Handle deltas */
326 		}
327 		break;
328 	default:
329 		err = got_error(GOT_ERR_PRIVSEP_MSG);
330 		break;
331 	}
332 
333 	imsg_free(&imsg);
334 
335 	return err;
336 }
337 
338 const struct got_error *
339 got_privsep_send_commit(struct imsgbuf *ibuf, struct got_commit_object *commit)
340 {
341 	const struct got_error *err = NULL;
342 	struct got_imsg_commit_object icommit;
343 	uint8_t *buf;
344 	size_t len, total;
345 	struct got_object_qid *qid;
346 
347 	memcpy(icommit.tree_id, commit->tree_id->sha1, sizeof(icommit.tree_id));
348 	icommit.author_len = strlen(commit->author);
349 	memcpy(&icommit.tm_author, &commit->tm_author,
350 	    sizeof(icommit.tm_author));
351 	icommit.committer_len = strlen(commit->committer);
352 	memcpy(&icommit.tm_committer, &commit->tm_committer,
353 	    sizeof(icommit.tm_committer));
354 	icommit.logmsg_len = strlen(commit->logmsg);
355 	icommit.nparents = commit->nparents;
356 
357 	total = sizeof(icommit) + icommit.author_len +
358 	    icommit.committer_len + icommit.logmsg_len +
359 	    icommit.nparents * SHA1_DIGEST_LENGTH;
360 	/* XXX TODO support very large log messages properly */
361 	if (total > MAX_IMSGSIZE)
362 		return got_error(GOT_ERR_NO_SPACE);
363 
364 	buf = malloc(total);
365 	if (buf == NULL)
366 		return got_error_from_errno();
367 
368 	len = 0;
369 	memcpy(buf + len, &icommit, sizeof(icommit));
370 	len += sizeof(icommit);
371 	memcpy(buf + len, commit->author, icommit.author_len);
372 	len += icommit.author_len;
373 	memcpy(buf + len, commit->committer, icommit.committer_len);
374 	len += icommit.committer_len;
375 	memcpy(buf + len, commit->logmsg, icommit.logmsg_len);
376 	len += icommit.logmsg_len;
377 	SIMPLEQ_FOREACH(qid, &commit->parent_ids, entry) {
378 		memcpy(buf + len, qid->id, SHA1_DIGEST_LENGTH);
379 		len += SHA1_DIGEST_LENGTH;
380 	}
381 
382 	if (imsg_compose(ibuf, GOT_IMSG_COMMIT, 0, 0, -1, buf, len) == -1) {
383 		err = got_error_from_errno();
384 		goto done;
385 	}
386 
387 	err = flush_imsg(ibuf);
388 done:
389 	free(buf);
390 	return err;
391 }
392 const struct got_error *
393 got_privsep_recv_commit(struct got_commit_object **commit, struct imsgbuf *ibuf)
394 {
395 	const struct got_error *err = NULL;
396 	struct imsg imsg;
397 	struct got_imsg_commit_object icommit;
398 	size_t len, datalen;
399 	int i;
400 	const size_t min_datalen =
401 	    MIN(sizeof(struct got_imsg_error),
402 	    sizeof(struct got_imsg_commit_object));
403 	uint8_t *data;
404 
405 	*commit = NULL;
406 
407 	err = got_privsep_recv_imsg(&imsg, ibuf, min_datalen);
408 	if (err)
409 		return err;
410 
411 	data = imsg.data;
412 	datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
413 	len = 0;
414 
415 	switch (imsg.hdr.type) {
416 	case GOT_IMSG_ERROR:
417 		err = recv_imsg_error(&imsg, datalen);
418 		break;
419 	case GOT_IMSG_COMMIT:
420 		if (datalen < sizeof(icommit)) {
421 			err = got_error(GOT_ERR_PRIVSEP_LEN);
422 			break;
423 		}
424 
425 		memcpy(&icommit, data, sizeof(icommit));
426 		if (datalen != sizeof(icommit) + icommit.author_len +
427 		    icommit.committer_len + icommit.logmsg_len +
428 		    icommit.nparents * SHA1_DIGEST_LENGTH) {
429 			err = got_error(GOT_ERR_PRIVSEP_LEN);
430 			break;
431 		}
432 		if (icommit.nparents < 0) {
433 			err = got_error(GOT_ERR_PRIVSEP_LEN);
434 			break;
435 		}
436 		len += sizeof(icommit);
437 
438 		*commit = got_object_commit_alloc_partial();
439 		if (*commit == NULL) {
440 			err = got_error_from_errno();
441 			break;
442 		}
443 
444 		memcpy((*commit)->tree_id->sha1, icommit.tree_id,
445 		    SHA1_DIGEST_LENGTH);
446 		memcpy(&(*commit)->tm_author, &icommit.tm_author,
447 		    sizeof((*commit)->tm_author));
448 		memcpy(&(*commit)->tm_committer, &icommit.tm_committer,
449 		    sizeof((*commit)->tm_committer));
450 
451 		if (icommit.author_len == 0) {
452 			(*commit)->author = strdup("");
453 			if ((*commit)->author == NULL) {
454 				err = got_error_from_errno();
455 				break;
456 			}
457 		} else {
458 			(*commit)->author = malloc(icommit.author_len + 1);
459 			if ((*commit)->author == NULL) {
460 				err = got_error_from_errno();
461 				break;
462 			}
463 			memcpy((*commit)->author, data + len,
464 			    icommit.author_len);
465 			(*commit)->author[icommit.author_len] = '\0';
466 		}
467 		len += icommit.author_len;
468 
469 		if (icommit.committer_len == 0) {
470 			(*commit)->committer = strdup("");
471 			if ((*commit)->committer == NULL) {
472 				err = got_error_from_errno();
473 				break;
474 			}
475 		} else {
476 			(*commit)->committer =
477 			    malloc(icommit.committer_len + 1);
478 			if ((*commit)->committer == NULL) {
479 				err = got_error_from_errno();
480 				break;
481 			}
482 			memcpy((*commit)->committer, data + len,
483 			    icommit.committer_len);
484 			(*commit)->committer[icommit.committer_len] = '\0';
485 		}
486 		len += icommit.committer_len;
487 
488 		if (icommit.logmsg_len == 0) {
489 			(*commit)->logmsg = strdup("");
490 			if ((*commit)->logmsg == NULL) {
491 				err = got_error_from_errno();
492 				break;
493 			}
494 		} else {
495 			(*commit)->logmsg = malloc(icommit.logmsg_len + 1);
496 			if ((*commit)->logmsg == NULL) {
497 				err = got_error_from_errno();
498 				break;
499 			}
500 			memcpy((*commit)->logmsg, data + len,
501 			    icommit.logmsg_len);
502 			(*commit)->logmsg[icommit.logmsg_len] = '\0';
503 		}
504 		len += icommit.logmsg_len;
505 
506 		for (i = 0; i < icommit.nparents; i++) {
507 			struct got_object_qid *qid;
508 
509 			qid = calloc(1, sizeof(*qid));
510 			if (qid == NULL) {
511 				err = got_error_from_errno();
512 				break;
513 			}
514 			qid->id = calloc(1, sizeof(*qid->id));
515 			if (qid->id == NULL) {
516 				err = got_error_from_errno();
517 				free(qid);
518 				break;
519 			}
520 
521 			memcpy(qid->id, data + len + i * SHA1_DIGEST_LENGTH,
522 			    sizeof(*qid->id));
523 			SIMPLEQ_INSERT_TAIL(&(*commit)->parent_ids, qid, entry);
524 			(*commit)->nparents++;
525 		}
526 		break;
527 	default:
528 		err = got_error(GOT_ERR_PRIVSEP_MSG);
529 		break;
530 	}
531 
532 	imsg_free(&imsg);
533 
534 	return err;
535 }
536 
537 const struct got_error *
538 got_privsep_send_tree(struct imsgbuf *ibuf, struct got_tree_object *tree)
539 {
540 	const struct got_error *err = NULL;
541 	struct got_imsg_tree_object itree;
542 	struct got_tree_entry *te;
543 
544 	itree.nentries = tree->entries.nentries;
545 	if (imsg_compose(ibuf, GOT_IMSG_TREE, 0, 0, -1, &itree, sizeof(itree))
546 	    == -1)
547 		return got_error_from_errno();
548 
549 	err = flush_imsg(ibuf);
550 	if (err)
551 		return err;
552 
553 	SIMPLEQ_FOREACH(te, &tree->entries.head, entry) {
554 		struct got_imsg_tree_entry ite;
555 		uint8_t *buf = NULL;
556 		size_t len = sizeof(ite) + strlen(te->name);
557 
558 		if (len > MAX_IMSGSIZE)
559 			return got_error(GOT_ERR_NO_SPACE);
560 
561 		buf = malloc(len);
562 		if (buf == NULL)
563 			return got_error_from_errno();
564 
565 		memcpy(ite.id, te->id->sha1, sizeof(ite.id));
566 		ite.mode = te->mode;
567 		memcpy(buf, &ite, sizeof(ite));
568 		memcpy(buf + sizeof(ite), te->name, strlen(te->name));
569 
570 		if (imsg_compose(ibuf, GOT_IMSG_TREE_ENTRY, 0, 0, -1,
571 		    buf, len) == -1)
572 			err = got_error_from_errno();
573 		free(buf);
574 		if (err)
575 			return err;
576 
577 		err = flush_imsg(ibuf);
578 		if (err)
579 			return err;
580 	}
581 
582 	return NULL;
583 }
584 
585 const struct got_error *
586 got_privsep_recv_tree(struct got_tree_object **tree, struct imsgbuf *ibuf)
587 {
588 	const struct got_error *err = NULL;
589 	const size_t min_datalen =
590 	    MIN(sizeof(struct got_imsg_error),
591 	    sizeof(struct got_imsg_tree_object));
592 	struct got_imsg_tree_object itree = { 0 };
593 	int nentries = 0;
594 
595 	*tree = NULL;
596 get_more:
597 	err = read_imsg(ibuf);
598 	if (err)
599 		goto done;
600 
601 	while (1) {
602 		struct imsg imsg;
603 		size_t n;
604 		size_t datalen;
605 		struct got_imsg_tree_entry ite;
606 		struct got_tree_entry *te = NULL;
607 
608 		n = imsg_get(ibuf, &imsg);
609 		if (n == 0) {
610 			if (*tree && (*tree)->entries.nentries != nentries)
611 				goto get_more;
612 			break;
613 		}
614 
615 		if (imsg.hdr.len < IMSG_HEADER_SIZE + min_datalen)
616 			return got_error(GOT_ERR_PRIVSEP_LEN);
617 
618 		datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
619 
620 		switch (imsg.hdr.type) {
621 		case GOT_IMSG_ERROR:
622 			err = recv_imsg_error(&imsg, datalen);
623 			break;
624 		case GOT_IMSG_TREE:
625 			/* This message should only appear once. */
626 			if (*tree != NULL) {
627 				err = got_error(GOT_ERR_PRIVSEP_MSG);
628 				break;
629 			}
630 			if (datalen != sizeof(itree)) {
631 				err = got_error(GOT_ERR_PRIVSEP_LEN);
632 				break;
633 			}
634 			memcpy(&itree, imsg.data, sizeof(itree));
635 			*tree = calloc(1, sizeof(**tree));
636 			if (*tree == NULL) {
637 				err = got_error_from_errno();
638 				break;
639 			}
640 			(*tree)->entries.nentries = itree.nentries;
641 			SIMPLEQ_INIT(&(*tree)->entries.head);
642 			break;
643 		case GOT_IMSG_TREE_ENTRY:
644 			/* This message should be preceeded by GOT_IMSG_TREE. */
645 			if (*tree == NULL) {
646 				err = got_error(GOT_ERR_PRIVSEP_MSG);
647 				break;
648 			}
649 			if (datalen < sizeof(ite) || datalen > MAX_IMSGSIZE) {
650 				err = got_error(GOT_ERR_PRIVSEP_LEN);
651 				break;
652 			}
653 
654 			/* Remaining data contains the entry's name. */
655 			datalen -= sizeof(ite);
656 			memcpy(&ite, imsg.data, sizeof(ite));
657 			if (datalen == 0 || datalen > MAX_IMSGSIZE) {
658 				err = got_error(GOT_ERR_PRIVSEP_LEN);
659 				break;
660 			}
661 
662 			te = got_alloc_tree_entry_partial();
663 			if (te == NULL) {
664 				err = got_error_from_errno();
665 				break;
666 			}
667 			te->name = malloc(datalen + 1);
668 			if (te->name == NULL) {
669 				free(te);
670 				err = got_error_from_errno();
671 				break;
672 			}
673 			memcpy(te->name, imsg.data + sizeof(ite), datalen);
674 			te->name[datalen] = '\0';
675 
676 			memcpy(te->id->sha1, ite.id, SHA1_DIGEST_LENGTH);
677 			te->mode = ite.mode;
678 			SIMPLEQ_INSERT_TAIL(&(*tree)->entries.head, te, entry);
679 			nentries++;
680 			break;
681 		default:
682 			err = got_error(GOT_ERR_PRIVSEP_MSG);
683 			break;
684 		}
685 
686 		imsg_free(&imsg);
687 	}
688 done:
689 	if (*tree && (*tree)->entries.nentries != nentries) {
690 		if (err == NULL)
691 			err = got_error(GOT_ERR_PRIVSEP_LEN);
692 		got_object_tree_close(*tree);
693 		*tree = NULL;
694 	}
695 
696 	return err;
697 }
698 
699 const struct got_error *
700 got_privsep_send_blob(struct imsgbuf *ibuf, size_t size)
701 {
702 	struct got_imsg_blob iblob;
703 
704 	iblob.size = size;
705 	/* Data has already been written to file descriptor. */
706 
707 	if (imsg_compose(ibuf, GOT_IMSG_BLOB, 0, 0, -1, &iblob, sizeof(iblob))
708 	    == -1)
709 		return got_error_from_errno();
710 
711 	return flush_imsg(ibuf);
712 }
713 
714 const struct got_error *
715 got_privsep_recv_blob(size_t *size, struct imsgbuf *ibuf)
716 {
717 	const struct got_error *err = NULL;
718 	struct imsg imsg;
719 	struct got_imsg_blob iblob;
720 	size_t datalen;
721 
722 	err = got_privsep_recv_imsg(&imsg, ibuf, 0);
723 	if (err)
724 		return err;
725 
726 	datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
727 
728 	switch (imsg.hdr.type) {
729 	case GOT_IMSG_ERROR:
730 		err = recv_imsg_error(&imsg, datalen);
731 		break;
732 	case GOT_IMSG_BLOB:
733 		if (datalen != sizeof(iblob))
734 			err = got_error(GOT_ERR_PRIVSEP_LEN);
735 		memcpy(&iblob, imsg.data, sizeof(iblob));
736 		*size = iblob.size;
737 		/* Data has been written to file descriptor. */
738 		break;
739 	default:
740 		err = got_error(GOT_ERR_PRIVSEP_MSG);
741 		break;
742 	}
743 
744 	imsg_free(&imsg);
745 
746 	return err;
747 }