op public repos

Blob

Date:: Sat Mar 4 08:55:56 2023 UTC
Message:: gotd: remove more (all?) double process names in log
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2022 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/queue.h>
18 #include <sys/types.h>
19 
20 #include <event.h>
21 #include <errno.h>
22 #include <imsg.h>
23 #include <signal.h>
24 #include <stdlib.h>
25 #include <limits.h>
26 #include <poll.h>
27 #include <sha1.h>
28 #include <sha2.h>
29 #include <siphash.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <unistd.h>
33 
34 #include "got_error.h"
35 #include "got_cancel.h"
36 #include "got_object.h"
37 #include "got_repository.h"
38 #include "got_reference.h"
39 #include "got_repository_admin.h"
40 
41 #include "got_lib_delta.h"
42 #include "got_lib_object.h"
43 #include "got_lib_object_idset.h"
44 #include "got_lib_hash.h"
45 #include "got_lib_pack.h"
46 #include "got_lib_ratelimit.h"
47 #include "got_lib_pack_create.h"
48 #include "got_lib_poll.h"
49 
50 #include "log.h"
51 #include "gotd.h"
52 #include "repo_read.h"
53 
54 #ifndef nitems
55 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
56 #endif
57 
58 static struct repo_read {
59 	pid_t pid;
60 	const char *title;
61 	struct got_repository *repo;
62 	int *pack_fds;
63 	int *temp_fds;
64 	int session_fd;
65 	struct gotd_imsgev session_iev;
66 } repo_read;
67 
68 static struct repo_read_client {
69 	uint32_t			 id;
70 	int				 fd;
71 	int				 delta_cache_fd;
72 	int				 report_progress;
73 	int				 pack_pipe;
74 	struct got_object_idset		*want_ids;
75 	struct got_object_idset		*have_ids;
76 } repo_read_client;
77 
78 static volatile sig_atomic_t sigint_received;
79 static volatile sig_atomic_t sigterm_received;
80 
81 static void
82 catch_sigint(int signo)
83 {
84 	sigint_received = 1;
85 }
86 
87 static void
88 catch_sigterm(int signo)
89 {
90 	sigterm_received = 1;
91 }
92 
93 static const struct got_error *
94 check_cancelled(void *arg)
95 {
96 	if (sigint_received || sigterm_received)
97 		return got_error(GOT_ERR_CANCELLED);
98 
99 	return NULL;
100 }
101 
102 static const struct got_error *
103 send_symref(struct got_reference *symref, struct got_object_id *target_id,
104     struct imsgbuf *ibuf)
105 {
106 	const struct got_error *err = NULL;
107 	struct gotd_imsg_symref isymref;
108 	const char *refname = got_ref_get_name(symref);
109 	const char *target = got_ref_get_symref_target(symref);
110 	size_t len;
111 	struct ibuf *wbuf;
112 
113 	memset(&isymref, 0, sizeof(isymref));
114 	isymref.name_len = strlen(refname);
115 	isymref.target_len = strlen(target);
116 	memcpy(isymref.target_id, target_id->sha1, sizeof(isymref.target_id));
117 
118 	len = sizeof(isymref) + isymref.name_len + isymref.target_len;
119 	if (len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
120 		err = got_error(GOT_ERR_NO_SPACE);
121 		goto done;
122 	}
123 
124 	wbuf = imsg_create(ibuf, GOTD_IMSG_SYMREF, 0, 0, len);
125 	if (wbuf == NULL) {
126 		err = got_error_from_errno("imsg_create SYMREF");
127 		goto done;
128 	}
129 
130 	if (imsg_add(wbuf, &isymref, sizeof(isymref)) == -1) {
131 		err = got_error_from_errno("imsg_add SYMREF");
132 		goto done;
133 	}
134 	if (imsg_add(wbuf, refname, isymref.name_len) == -1) {
135 		err = got_error_from_errno("imsg_add SYMREF");
136 		goto done;
137 	}
138 	if (imsg_add(wbuf, target, isymref.target_len) == -1) {
139 		err = got_error_from_errno("imsg_add SYMREF");
140 		goto done;
141 	}
142 
143 	wbuf->fd = -1;
144 	imsg_close(ibuf, wbuf);
145 done:
146 	free(target_id);
147 	return err;
148 }
149 
150 static const struct got_error *
151 send_peeled_tag_ref(struct got_reference *ref, struct got_object *obj,
152     struct imsgbuf *ibuf)
153 {
154 	const struct got_error *err = NULL;
155 	struct got_tag_object *tag;
156 	size_t namelen, len;
157 	char *peeled_refname = NULL;
158 	struct got_object_id *id;
159 	struct ibuf *wbuf;
160 
161 	err = got_object_tag_open(&tag, repo_read.repo, obj);
162 	if (err)
163 		return err;
164 
165 	if (asprintf(&peeled_refname, "%s^{}", got_ref_get_name(ref)) == -1) {
166 		err = got_error_from_errno("asprintf");
167 		goto done;
168 	}
169 
170 	id = got_object_tag_get_object_id(tag);
171 	namelen = strlen(peeled_refname);
172 
173 	len = sizeof(struct gotd_imsg_ref) + namelen;
174 	if (len > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
175 		err = got_error(GOT_ERR_NO_SPACE);
176 		goto done;
177 	}
178 
179 	wbuf = imsg_create(ibuf, GOTD_IMSG_REF, PROC_REPO_READ,
180 	    repo_read.pid, len);
181 	if (wbuf == NULL) {
182 		err = got_error_from_errno("imsg_create MREF");
183 		goto done;
184 	}
185 
186 	/* Keep in sync with struct gotd_imsg_ref definition. */
187 	if (imsg_add(wbuf, id->sha1, SHA1_DIGEST_LENGTH) == -1) {
188 		err = got_error_from_errno("imsg_add REF");
189 		goto done;
190 	}
191 	if (imsg_add(wbuf, &namelen, sizeof(namelen)) == -1) {
192 		err = got_error_from_errno("imsg_add REF");
193 		goto done;
194 	}
195 	if (imsg_add(wbuf, peeled_refname, namelen) == -1) {
196 		err = got_error_from_errno("imsg_add REF");
197 		goto done;
198 	}
199 
200 	wbuf->fd = -1;
201 	imsg_close(ibuf, wbuf);
202 done:
203 	got_object_tag_close(tag);
204 	return err;
205 }
206 
207 static const struct got_error *
208 send_ref(struct got_reference *ref, struct imsgbuf *ibuf)
209 {
210 	const struct got_error *err;
211 	const char *refname = got_ref_get_name(ref);
212 	size_t namelen;
213 	struct got_object_id *id = NULL;
214 	struct got_object *obj = NULL;
215 	size_t len;
216 	struct ibuf *wbuf;
217 
218 	namelen = strlen(refname);
219 
220 	len = sizeof(struct gotd_imsg_ref) + namelen;
221 	if (len > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
222 		return got_error(GOT_ERR_NO_SPACE);
223 
224 	err = got_ref_resolve(&id, repo_read.repo, ref);
225 	if (err)
226 		return err;
227 
228 	wbuf = imsg_create(ibuf, GOTD_IMSG_REF, PROC_REPO_READ,
229 	    repo_read.pid, len);
230 	if (wbuf == NULL) {
231 		err = got_error_from_errno("imsg_create REF");
232 		goto done;
233 	}
234 
235 	/* Keep in sync with struct gotd_imsg_ref definition. */
236 	if (imsg_add(wbuf, id->sha1, SHA1_DIGEST_LENGTH) == -1)
237 		return got_error_from_errno("imsg_add REF");
238 	if (imsg_add(wbuf, &namelen, sizeof(namelen)) == -1)
239 		return got_error_from_errno("imsg_add REF");
240 	if (imsg_add(wbuf, refname, namelen) == -1)
241 		return got_error_from_errno("imsg_add REF");
242 
243 	wbuf->fd = -1;
244 	imsg_close(ibuf, wbuf);
245 
246 	err = got_object_open(&obj, repo_read.repo, id);
247 	if (err)
248 		goto done;
249 	if (obj->type == GOT_OBJ_TYPE_TAG)
250 		err = send_peeled_tag_ref(ref, obj, ibuf);
251 done:
252 	if (obj)
253 		got_object_close(obj);
254 	free(id);
255 	return err;
256 }
257 
258 static const struct got_error *
259 list_refs(struct imsg *imsg)
260 {
261 	const struct got_error *err;
262 	struct repo_read_client *client = &repo_read_client;
263 	struct got_reflist_head refs;
264 	struct got_reflist_entry *re;
265 	struct gotd_imsg_list_refs_internal ireq;
266 	size_t datalen;
267 	struct gotd_imsg_reflist irefs;
268 	struct imsgbuf ibuf;
269 	int client_fd = imsg->fd;
270 	struct got_object_id *head_target_id = NULL;
271 
272 	TAILQ_INIT(&refs);
273 
274 	if (client_fd == -1)
275 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
276 
277 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
278 	if (datalen != sizeof(ireq))
279 		return got_error(GOT_ERR_PRIVSEP_LEN);
280 	memcpy(&ireq, imsg->data, sizeof(ireq));
281 
282 	if (ireq.client_id == 0)
283 		return got_error(GOT_ERR_CLIENT_ID);
284 	if (client->id != 0) {
285 		return got_error_msg(GOT_ERR_CLIENT_ID,
286 		    "duplicate list-refs request");
287 	}
288 	client->id = ireq.client_id;
289 	client->fd = client_fd;
290 
291 	imsg_init(&ibuf, client_fd);
292 
293 	err = got_ref_list(&refs, repo_read.repo, "",
294 	    got_ref_cmp_by_name, NULL);
295 	if (err)
296 		return err;
297 
298 	memset(&irefs, 0, sizeof(irefs));
299 	TAILQ_FOREACH(re, &refs, entry) {
300 		struct got_object_id *id;
301 		int obj_type;
302 
303 		if (got_ref_is_symbolic(re->ref)) {
304 			const char *refname = got_ref_get_name(re->ref);
305 			if (strcmp(refname, GOT_REF_HEAD) != 0)
306 				continue;
307 			err = got_ref_resolve(&head_target_id, repo_read.repo,
308 			    re->ref);
309 			if (err) {
310 				if (err->code != GOT_ERR_NOT_REF)
311 					return err;
312 				/*
313 				 * HEAD points to a non-existent branch.
314 				 * Do not advertise it.
315 				 * Matches git-daemon's behaviour.
316 				 */
317 				head_target_id = NULL;
318 				err = NULL;
319 			} else
320 				irefs.nrefs++;
321 			continue;
322 		}
323 
324 		irefs.nrefs++;
325 
326 		/* Account for a peeled tag refs. */
327 		err = got_ref_resolve(&id, repo_read.repo, re->ref);
328 		if (err)
329 			goto done;
330 		err = got_object_get_type(&obj_type, repo_read.repo, id);
331 		free(id);
332 		if (err)
333 			goto done;
334 		if (obj_type == GOT_OBJ_TYPE_TAG)
335 			irefs.nrefs++;
336 	}
337 
338 	if (imsg_compose(&ibuf, GOTD_IMSG_REFLIST, PROC_REPO_READ,
339 	    repo_read.pid, -1, &irefs, sizeof(irefs)) == -1) {
340 		err = got_error_from_errno("imsg_compose REFLIST");
341 		goto done;
342 	}
343 
344 	/*
345 	 * Send the HEAD symref first. In Git-protocol versions < 2
346 	 * the HEAD symref must be announced on the initial line of
347 	 * the server's ref advertisement.
348 	 * For now, we do not advertise symrefs other than HEAD.
349 	 */
350 	TAILQ_FOREACH(re, &refs, entry) {
351 		if (!got_ref_is_symbolic(re->ref) ||
352 		    strcmp(got_ref_get_name(re->ref), GOT_REF_HEAD) != 0 ||
353 		    head_target_id == NULL)
354 			continue;
355 		err = send_symref(re->ref, head_target_id, &ibuf);
356 		if (err)
357 			goto done;
358 		break;
359 	}
360 	TAILQ_FOREACH(re, &refs, entry) {
361 		if (got_ref_is_symbolic(re->ref))
362 			continue;
363 		err = send_ref(re->ref, &ibuf);
364 		if (err)
365 			goto done;
366 	}
367 
368 	err = gotd_imsg_flush(&ibuf);
369 done:
370 	got_ref_list_free(&refs);
371 	imsg_clear(&ibuf);
372 	return err;
373 }
374 
375 static const struct got_error *
376 append_object_id(struct got_object_id *id, void *data, void *arg)
377 {
378 	struct gotd_object_id_array *array = arg;
379 	const size_t alloc_chunksz = 256;
380 
381 	if (array->ids == NULL) {
382 		array->ids = reallocarray(NULL, alloc_chunksz,
383 		    sizeof(*array->ids));
384 		if (array->ids == NULL)
385 			return got_error_from_errno("reallocarray");
386 		array->nalloc = alloc_chunksz;
387 		array->nids = 0;
388 	} else if (array->nalloc <= array->nids) {
389 		struct got_object_id **new;
390 		new = recallocarray(array->ids, array->nalloc,
391 		    array->nalloc + alloc_chunksz, sizeof(*new));
392 		if (new == NULL)
393 			return got_error_from_errno("recallocarray");
394 		array->ids = new;
395 		array->nalloc += alloc_chunksz;
396 	}
397 
398 	array->ids[array->nids] = id;
399 	array->nids++;
400 	return NULL;
401 }
402 
403 static const struct got_error *
404 recv_want(struct imsg *imsg)
405 {
406 	const struct got_error *err;
407 	struct repo_read_client *client = &repo_read_client;
408 	struct gotd_imsg_want iwant;
409 	size_t datalen;
410 	char hex[SHA1_DIGEST_STRING_LENGTH];
411 	struct got_object_id id;
412 	int obj_type;
413 	struct imsgbuf ibuf;
414 
415 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
416 	if (datalen != sizeof(iwant))
417 		return got_error(GOT_ERR_PRIVSEP_LEN);
418 	memcpy(&iwant, imsg->data, sizeof(iwant));
419 
420 	memset(&id, 0, sizeof(id));
421 	memcpy(id.sha1, iwant.object_id, SHA1_DIGEST_LENGTH);
422 
423 	if (log_getverbose() > 0 &&
424 	    got_sha1_digest_to_str(id.sha1, hex, sizeof(hex)))
425 		log_debug("client wants %s", hex);
426 
427 	imsg_init(&ibuf, client->fd);
428 
429 	err = got_object_get_type(&obj_type, repo_read.repo, &id);
430 	if (err)
431 		return err;
432 
433 	if (obj_type != GOT_OBJ_TYPE_COMMIT &&
434 	    obj_type != GOT_OBJ_TYPE_TAG)
435 		return got_error(GOT_ERR_OBJ_TYPE);
436 
437 	if (!got_object_idset_contains(client->want_ids, &id)) {
438 		err = got_object_idset_add(client->want_ids, &id, NULL);
439 		if (err)
440 			return err;
441 	}
442 
443 	gotd_imsg_send_ack(&id, &ibuf, PROC_REPO_READ, repo_read.pid);
444 	imsg_clear(&ibuf);
445 	return err;
446 }
447 
448 static const struct got_error *
449 recv_have(struct imsg *imsg)
450 {
451 	const struct got_error *err;
452 	struct repo_read_client *client = &repo_read_client;
453 	struct gotd_imsg_have ihave;
454 	size_t datalen;
455 	char hex[SHA1_DIGEST_STRING_LENGTH];
456 	struct got_object_id id;
457 	int obj_type;
458 	struct imsgbuf ibuf;
459 
460 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
461 	if (datalen != sizeof(ihave))
462 		return got_error(GOT_ERR_PRIVSEP_LEN);
463 	memcpy(&ihave, imsg->data, sizeof(ihave));
464 
465 	memset(&id, 0, sizeof(id));
466 	memcpy(id.sha1, ihave.object_id, SHA1_DIGEST_LENGTH);
467 
468 	if (log_getverbose() > 0 &&
469 	    got_sha1_digest_to_str(id.sha1, hex, sizeof(hex)))
470 		log_debug("client has %s", hex);
471 
472 	imsg_init(&ibuf, client->fd);
473 
474 	err = got_object_get_type(&obj_type, repo_read.repo, &id);
475 	if (err) {
476 		if (err->code == GOT_ERR_NO_OBJ) {
477 			gotd_imsg_send_nak(&id, &ibuf,
478 			    PROC_REPO_READ, repo_read.pid);
479 			err = NULL;
480 		}
481 		goto done;
482 	}
483 
484 	if (obj_type != GOT_OBJ_TYPE_COMMIT &&
485 	    obj_type != GOT_OBJ_TYPE_TAG) {
486 		gotd_imsg_send_nak(&id, &ibuf, PROC_REPO_READ, repo_read.pid);
487 		err = got_error(GOT_ERR_OBJ_TYPE);
488 		goto done;
489 	}
490 
491 	if (!got_object_idset_contains(client->have_ids, &id)) {
492 		err = got_object_idset_add(client->have_ids, &id, NULL);
493 		if (err)
494 			goto done;
495 	}
496 
497 	gotd_imsg_send_ack(&id, &ibuf, PROC_REPO_READ, repo_read.pid);
498 done:
499 	imsg_clear(&ibuf);
500 	return err;
501 }
502 
503 struct repo_read_pack_progress_arg {
504 	int report_progress;
505 	struct imsgbuf *ibuf;
506 	int sent_ready;
507 };
508 
509 static const struct got_error *
510 pack_progress(void *arg, int ncolored, int nfound, int ntrees,
511     off_t packfile_size, int ncommits, int nobj_total, int nobj_deltify,
512     int nobj_written)
513 {
514 	struct repo_read_pack_progress_arg *a = arg;
515 	struct gotd_imsg_packfile_progress iprog;
516 	int ret;
517 
518 	if (!a->report_progress)
519 		return NULL;
520 	if (packfile_size > 0 && a->sent_ready)
521 		return NULL;
522 
523 	memset(&iprog, 0, sizeof(iprog));
524 	iprog.ncolored = ncolored;
525 	iprog.nfound = nfound;
526 	iprog.ntrees = ntrees;
527 	iprog.packfile_size = packfile_size;
528 	iprog.ncommits = ncommits;
529 	iprog.nobj_total = nobj_total;
530 	iprog.nobj_deltify = nobj_deltify;
531 	iprog.nobj_written = nobj_written;
532 
533 	/* Using synchronous writes since we are blocking the event loop. */
534 	if (packfile_size == 0) {
535 		ret = imsg_compose(a->ibuf, GOTD_IMSG_PACKFILE_PROGRESS,
536 		    PROC_REPO_READ, repo_read.pid, -1, &iprog, sizeof(iprog));
537 		if (ret == -1) {
538 			return got_error_from_errno("imsg compose "
539 			    "PACKFILE_PROGRESS");
540 		}
541 	} else {
542 		a->sent_ready = 1;
543 		ret = imsg_compose(a->ibuf, GOTD_IMSG_PACKFILE_READY,
544 		    PROC_REPO_READ, repo_read.pid, -1, &iprog, sizeof(iprog));
545 		if (ret == -1) {
546 			return got_error_from_errno("imsg compose "
547 			    "PACKFILE_READY");
548 		}
549 	}
550 
551 	return gotd_imsg_flush(a->ibuf);
552 }
553 
554 static const struct got_error *
555 receive_delta_cache_fd(struct imsg *imsg,
556     struct gotd_imsgev *iev)
557 {
558 	struct repo_read_client *client = &repo_read_client;
559 	struct gotd_imsg_send_packfile ireq;
560 	size_t datalen;
561 
562 	log_debug("receving delta cache file");
563 
564 	if (imsg->fd == -1)
565 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
566 
567 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
568 	if (datalen != sizeof(ireq))
569 		return got_error(GOT_ERR_PRIVSEP_LEN);
570 	memcpy(&ireq, imsg->data, sizeof(ireq));
571 
572 	if (client->delta_cache_fd != -1)
573 		return got_error(GOT_ERR_PRIVSEP_MSG);
574 
575 	client->delta_cache_fd = imsg->fd;
576 	client->report_progress = ireq.report_progress;
577 	return NULL;
578 }
579 
580 static const struct got_error *
581 receive_pack_pipe(struct imsg *imsg, struct gotd_imsgev *iev)
582 {
583 	struct repo_read_client *client = &repo_read_client;
584 	struct gotd_imsg_packfile_pipe ireq;
585 	size_t datalen;
586 
587 	log_debug("receving pack pipe descriptor");
588 
589 	if (imsg->fd == -1)
590 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
591 
592 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
593 	if (datalen != sizeof(ireq))
594 		return got_error(GOT_ERR_PRIVSEP_LEN);
595 	memcpy(&ireq, imsg->data, sizeof(ireq));
596 
597 	if (client->pack_pipe != -1)
598 		return got_error(GOT_ERR_PRIVSEP_MSG);
599 
600 	client->pack_pipe = imsg->fd;
601 	return NULL;
602 }
603 
604 static const struct got_error *
605 send_packfile(struct imsg *imsg, struct gotd_imsgev *iev)
606 {
607 	const struct got_error *err = NULL;
608 	struct repo_read_client *client = &repo_read_client;
609 	struct gotd_imsg_packfile_done idone;
610 	uint8_t packsha1[SHA1_DIGEST_LENGTH];
611 	char hex[SHA1_DIGEST_STRING_LENGTH];
612 	FILE *delta_cache = NULL;
613 	struct imsgbuf ibuf;
614 	struct repo_read_pack_progress_arg pa;
615 	struct got_ratelimit rl;
616 	struct gotd_object_id_array want_ids;
617 	struct gotd_object_id_array have_ids;
618 
619 	log_debug("packfile request received");
620 
621 	memset(&want_ids, 0, sizeof(want_ids));
622 	memset(&have_ids, 0, sizeof(have_ids));
623 
624 	got_ratelimit_init(&rl, 2, 0);
625 
626 	if (client->delta_cache_fd == -1 || client->pack_pipe == -1)
627 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
628 
629 	imsg_init(&ibuf, client->fd);
630 
631 	delta_cache = fdopen(client->delta_cache_fd, "w+");
632 	if (delta_cache == NULL) {
633 		err = got_error_from_errno("fdopen");
634 		goto done;
635 	}
636 	client->delta_cache_fd = -1;
637 
638 	memset(&pa, 0, sizeof(pa));
639 	pa.ibuf = &ibuf;
640 	pa.report_progress = client->report_progress;
641 
642 	err = got_object_idset_for_each(client->want_ids,
643 	    append_object_id, &want_ids);
644 	if (err)
645 		goto done;
646 	err = got_object_idset_for_each(client->have_ids,
647 	   append_object_id, &have_ids);
648 	if (err)
649 		goto done;
650 
651 	err = got_pack_create(packsha1, client->pack_pipe, delta_cache,
652 	    have_ids.ids, have_ids.nids, want_ids.ids, want_ids.nids,
653 	    repo_read.repo, 0, 1, 0, pack_progress, &pa, &rl,
654 	    check_cancelled, NULL);
655 	if (err)
656 		goto done;
657 
658 	if (log_getverbose() > 0 &&
659 	    got_sha1_digest_to_str(packsha1, hex, sizeof(hex)))
660 		log_debug("sent pack-%s.pack", hex);
661 
662 	memset(&idone, 0, sizeof(idone));
663 	idone.client_id = client->id;
664 	if (gotd_imsg_compose_event(iev, GOTD_IMSG_PACKFILE_DONE,
665 	    PROC_REPO_READ, -1, &idone, sizeof(idone)) == -1)
666 		err = got_error_from_errno("imsg compose PACKFILE_DONE");
667 done:
668 	if (delta_cache != NULL && fclose(delta_cache) == EOF && err == NULL)
669 		err = got_error_from_errno("fclose");
670 	imsg_clear(&ibuf);
671 	free(want_ids.ids);
672 	free(have_ids.ids);
673 	return err;
674 }
675 
676 static void
677 repo_read_dispatch_session(int fd, short event, void *arg)
678 {
679 	const struct got_error *err = NULL;
680 	struct gotd_imsgev *iev = arg;
681 	struct imsgbuf *ibuf = &iev->ibuf;
682 	struct imsg imsg;
683 	ssize_t n;
684 	int shut = 0;
685 	struct repo_read_client *client = &repo_read_client;
686 
687 	if (event & EV_READ) {
688 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
689 			fatal("imsg_read error");
690 		if (n == 0)	/* Connection closed. */
691 			shut = 1;
692 	}
693 
694 	if (event & EV_WRITE) {
695 		n = msgbuf_write(&ibuf->w);
696 		if (n == -1 && errno != EAGAIN)
697 			fatal("msgbuf_write");
698 		if (n == 0)	/* Connection closed. */
699 			shut = 1;
700 	}
701 
702 	while (err == NULL && check_cancelled(NULL) == NULL) {
703 		if ((n = imsg_get(ibuf, &imsg)) == -1)
704 			fatal("%s: imsg_get", __func__);
705 		if (n == 0)	/* No more messages. */
706 			break;
707 
708 		if (imsg.hdr.type != GOTD_IMSG_LIST_REFS_INTERNAL &&
709 		    client->id == 0) {
710 			err = got_error(GOT_ERR_PRIVSEP_MSG);
711 			break;
712 		}
713 
714 		switch (imsg.hdr.type) {
715 		case GOTD_IMSG_LIST_REFS_INTERNAL:
716 			err = list_refs(&imsg);
717 			if (err)
718 				log_warnx("ls-refs: %s", err->msg);
719 			break;
720 		case GOTD_IMSG_WANT:
721 			err = recv_want(&imsg);
722 			if (err)
723 				log_warnx("want-line: %s", err->msg);
724 			break;
725 		case GOTD_IMSG_HAVE:
726 			err = recv_have(&imsg);
727 			if (err)
728 				log_warnx("have-line: %s", err->msg);
729 			break;
730 		case GOTD_IMSG_SEND_PACKFILE:
731 			err = receive_delta_cache_fd(&imsg, iev);
732 			if (err)
733 				log_warnx("receiving delta cache: %s",
734 				    err->msg);
735 			break;
736 		case GOTD_IMSG_PACKFILE_PIPE:
737 			err = receive_pack_pipe(&imsg, iev);
738 			if (err) {
739 				log_warnx("receiving pack pipe: %s", err->msg);
740 				break;
741 			}
742 			err = send_packfile(&imsg, iev);
743 			if (err)
744 				log_warnx("sending packfile: %s", err->msg);
745 			break;
746 		default:
747 			log_debug("unexpected imsg %d", imsg.hdr.type);
748 			break;
749 		}
750 
751 		imsg_free(&imsg);
752 	}
753 
754 	if (!shut && check_cancelled(NULL) == NULL) {
755 		if (err &&
756 		    gotd_imsg_send_error_event(iev, PROC_REPO_READ,
757 		        client->id, err) == -1) {
758 			log_warnx("could not send error to parent: %s",
759 			    err->msg);
760 		}
761 		gotd_imsg_event_add(iev);
762 	} else {
763 		/* This pipe is dead. Remove its event handler */
764 		event_del(&iev->ev);
765 		event_loopexit(NULL);
766 	}
767 }
768 
769 static const struct got_error *
770 recv_connect(struct imsg *imsg)
771 {
772 	struct gotd_imsgev *iev = &repo_read.session_iev;
773 	size_t datalen;
774 
775 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
776 	if (datalen != 0)
777 		return got_error(GOT_ERR_PRIVSEP_LEN);
778 	if (imsg->fd == -1)
779 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
780 
781 	if (repo_read.session_fd != -1)
782 		return got_error(GOT_ERR_PRIVSEP_MSG);
783 
784 	repo_read.session_fd = imsg->fd;
785 
786 	imsg_init(&iev->ibuf, repo_read.session_fd);
787 	iev->handler = repo_read_dispatch_session;
788 	iev->events = EV_READ;
789 	iev->handler_arg = NULL;
790 	event_set(&iev->ev, iev->ibuf.fd, EV_READ,
791 	    repo_read_dispatch_session, iev);
792 	gotd_imsg_event_add(iev);
793 
794 	return NULL;
795 }
796 
797 static void
798 repo_read_dispatch(int fd, short event, void *arg)
799 {
800 	const struct got_error *err = NULL;
801 	struct gotd_imsgev *iev = arg;
802 	struct imsgbuf *ibuf = &iev->ibuf;
803 	struct imsg imsg;
804 	ssize_t n;
805 	int shut = 0;
806 	struct repo_read_client *client = &repo_read_client;
807 
808 	if (event & EV_READ) {
809 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
810 			fatal("imsg_read error");
811 		if (n == 0)	/* Connection closed. */
812 			shut = 1;
813 	}
814 
815 	if (event & EV_WRITE) {
816 		n = msgbuf_write(&ibuf->w);
817 		if (n == -1 && errno != EAGAIN)
818 			fatal("msgbuf_write");
819 		if (n == 0)	/* Connection closed. */
820 			shut = 1;
821 	}
822 
823 	while (err == NULL && check_cancelled(NULL) == NULL) {
824 		if ((n = imsg_get(ibuf, &imsg)) == -1)
825 			fatal("%s: imsg_get", __func__);
826 		if (n == 0)	/* No more messages. */
827 			break;
828 
829 		switch (imsg.hdr.type) {
830 		case GOTD_IMSG_CONNECT_REPO_CHILD:
831 			err = recv_connect(&imsg);
832 			break;
833 		default:
834 			log_debug("unexpected imsg %d", imsg.hdr.type);
835 			break;
836 		}
837 
838 		imsg_free(&imsg);
839 	}
840 
841 	if (!shut && check_cancelled(NULL) == NULL) {
842 		if (err &&
843 		    gotd_imsg_send_error_event(iev, PROC_REPO_READ,
844 		        client->id, err) == -1) {
845 			log_warnx("could not send error to parent: %s",
846 			    err->msg);
847 		}
848 		gotd_imsg_event_add(iev);
849 	} else {
850 		/* This pipe is dead. Remove its event handler */
851 		event_del(&iev->ev);
852 		event_loopexit(NULL);
853 	}
854 }
855 
856 void
857 repo_read_main(const char *title, const char *repo_path,
858     int *pack_fds, int *temp_fds)
859 {
860 	const struct got_error *err = NULL;
861 	struct repo_read_client *client = &repo_read_client;
862 	struct gotd_imsgev iev;
863 
864 	client->fd = -1;
865 	client->delta_cache_fd = -1;
866 	client->pack_pipe = -1;
867 	client->have_ids = got_object_idset_alloc();
868 	if (client->have_ids == NULL) {
869 		err = got_error_from_errno("got_object_idset_alloc");
870 		goto done;
871 	}
872 	client->want_ids = got_object_idset_alloc();
873 	if (client->want_ids == NULL) {
874 		err = got_error_from_errno("got_object_idset_alloc");
875 		goto done;
876 	}
877 
878 	repo_read.title = title;
879 	repo_read.pid = getpid();
880 	repo_read.pack_fds = pack_fds;
881 	repo_read.temp_fds = temp_fds;
882 	repo_read.session_fd = -1;
883 	repo_read.session_iev.ibuf.fd = -1;
884 
885 	err = got_repo_open(&repo_read.repo, repo_path, NULL, pack_fds);
886 	if (err)
887 		goto done;
888 	if (!got_repo_is_bare(repo_read.repo)) {
889 		err = got_error_msg(GOT_ERR_NOT_GIT_REPO,
890 		    "bare git repository required");
891 		goto done;
892 	}
893 
894 	got_repo_temp_fds_set(repo_read.repo, temp_fds);
895 
896 	signal(SIGINT, catch_sigint);
897 	signal(SIGTERM, catch_sigterm);
898 	signal(SIGPIPE, SIG_IGN);
899 	signal(SIGHUP, SIG_IGN);
900 
901 	imsg_init(&iev.ibuf, GOTD_FILENO_MSG_PIPE);
902 	iev.handler = repo_read_dispatch;
903 	iev.events = EV_READ;
904 	iev.handler_arg = NULL;
905 	event_set(&iev.ev, iev.ibuf.fd, EV_READ, repo_read_dispatch, &iev);
906 
907 	if (gotd_imsg_compose_event(&iev, GOTD_IMSG_REPO_CHILD_READY,
908 	    PROC_REPO_READ, -1, NULL, 0) == -1) {
909 		err = got_error_from_errno("imsg compose REPO_CHILD_READY");
910 		goto done;
911 	}
912 
913 	event_dispatch();
914 done:
915 	if (err)
916 		log_warnx("%s: %s", title, err->msg);
917 	repo_read_shutdown();
918 }
919 
920 void
921 repo_read_shutdown(void)
922 {
923 	struct repo_read_client *client = &repo_read_client;
924 
925 	log_debug("shutting down");
926 
927 	if (client->have_ids)
928 		got_object_idset_free(client->have_ids);
929 	if (client->want_ids)
930 		got_object_idset_free(client->want_ids);
931 	if (client->fd != -1)
932 		close(client->fd);
933 	if (client->delta_cache_fd != -1)
934 		close(client->delta_cache_fd);
935 	if (client->pack_pipe != -1)
936 		close(client->pack_pipe);
937 
938 	if (repo_read.repo)
939 		got_repo_close(repo_read.repo);
940 	got_repo_pack_fds_close(repo_read.pack_fds);
941 	got_repo_temp_fds_close(repo_read.temp_fds);
942 	if (repo_read.session_fd != -1)
943 		close(repo_read.session_fd);
944 	exit(0);
945 }