Gotweb

Blob

Date:: Wed Aug 23 11:28:31 2023 UTC
Message:: portable: gotd/gitwrapper: update for libs Bring gotd and gitwrapper closer to how libraries are detected.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2022, 2023 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 "got_compat.h"
18 
19 #include <sys/types.h>
20 #include <sys/queue.h>
21 #include <sys/socket.h>
22 #include <sys/stat.h>
23 #include <sys/uio.h>
24 
25 #include <errno.h>
26 #include <event.h>
27 #include <limits.h>
28 #include <signal.h>
29 #include <stdint.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <imsg.h>
34 #include <unistd.h>
35 
36 #include "got_compat.h"
37 
38 #include "got_error.h"
39 #include "got_repository.h"
40 #include "got_object.h"
41 #include "got_path.h"
42 #include "got_reference.h"
43 #include "got_opentemp.h"
44 
45 #include "got_lib_hash.h"
46 #include "got_lib_delta.h"
47 #include "got_lib_object.h"
48 #include "got_lib_object_cache.h"
49 #include "got_lib_pack.h"
50 #include "got_lib_repository.h"
51 #include "got_lib_gitproto.h"
52 
53 #include "gotd.h"
54 #include "log.h"
55 #include "session.h"
56 
57 
58 static struct gotd_session {
59 	pid_t pid;
60 	const char *title;
61 	struct got_repository *repo;
62 	int *pack_fds;
63 	int *temp_fds;
64 	struct gotd_imsgev parent_iev;
65 	struct timeval request_timeout;
66 	enum gotd_procid proc_id;
67 } gotd_session;
68 
69 static struct gotd_session_client {
70 	enum gotd_session_state		 state;
71 	int				 is_writing;
72 	struct gotd_client_capability	*capabilities;
73 	size_t				 ncapa_alloc;
74 	size_t				 ncapabilities;
75 	uint32_t			 id;
76 	int				 fd;
77 	int				 delta_cache_fd;
78 	struct gotd_imsgev		 iev;
79 	struct gotd_imsgev		 repo_child_iev;
80 	struct event			 tmo;
81 	uid_t				 euid;
82 	gid_t				 egid;
83 	char				*packfile_path;
84 	char				*packidx_path;
85 	int				 nref_updates;
86 	int				 accept_flush_pkt;
87 	int				 flush_disconnect;
88 } gotd_session_client;
89 
90 void gotd_session_sighdlr(int sig, short event, void *arg);
91 static void gotd_session_shutdown(void);
92 
93 static void
94 disconnect(struct gotd_session_client *client)
95 {
96 	log_debug("uid %d: disconnecting", client->euid);
97 
98 	if (gotd_imsg_compose_event(&gotd_session.parent_iev,
99 	    GOTD_IMSG_DISCONNECT, gotd_session.proc_id, -1, NULL, 0) == -1)
100 		log_warn("imsg compose DISCONNECT");
101 
102 	imsg_clear(&client->repo_child_iev.ibuf);
103 	event_del(&client->repo_child_iev.ev);
104 	evtimer_del(&client->tmo);
105 	close(client->fd);
106 	if (client->delta_cache_fd != -1)
107 		close(client->delta_cache_fd);
108 	if (client->packfile_path) {
109 		if (unlink(client->packfile_path) == -1 && errno != ENOENT)
110 			log_warn("unlink %s: ", client->packfile_path);
111 		free(client->packfile_path);
112 	}
113 	if (client->packidx_path) {
114 		if (unlink(client->packidx_path) == -1 && errno != ENOENT)
115 			log_warn("unlink %s: ", client->packidx_path);
116 		free(client->packidx_path);
117 	}
118 	free(client->capabilities);
119 
120 	gotd_session_shutdown();
121 }
122 
123 static void
124 disconnect_on_error(struct gotd_session_client *client,
125     const struct got_error *err)
126 {
127 	struct imsgbuf ibuf;
128 
129 	if (err->code != GOT_ERR_EOF) {
130 		log_warnx("uid %d: %s", client->euid, err->msg);
131 		imsg_init(&ibuf, client->fd);
132 		gotd_imsg_send_error(&ibuf, 0, gotd_session.proc_id, err);
133 		imsg_clear(&ibuf);
134 	}
135 
136 	disconnect(client);
137 }
138 
139 static void
140 gotd_request_timeout(int fd, short events, void *arg)
141 {
142 	struct gotd_session_client *client = arg;
143 
144 	log_debug("disconnecting uid %d due to timeout", client->euid);
145 	disconnect(client);
146 }
147 
148 void
149 gotd_session_sighdlr(int sig, short event, void *arg)
150 {
151 	/*
152 	 * Normal signal handler rules don't apply because libevent
153 	 * decouples for us.
154 	 */
155 
156 	switch (sig) {
157 	case SIGHUP:
158 		log_info("%s: ignoring SIGHUP", __func__);
159 		break;
160 	case SIGUSR1:
161 		log_info("%s: ignoring SIGUSR1", __func__);
162 		break;
163 	case SIGTERM:
164 	case SIGINT:
165 		gotd_session_shutdown();
166 		/* NOTREACHED */
167 		break;
168 	default:
169 		fatalx("unexpected signal");
170 	}
171 }
172 
173 static const struct got_error *
174 recv_packfile_done(uint32_t *client_id, struct imsg *imsg)
175 {
176 	struct gotd_imsg_packfile_done idone;
177 	size_t datalen;
178 
179 	log_debug("packfile-done received");
180 
181 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
182 	if (datalen != sizeof(idone))
183 		return got_error(GOT_ERR_PRIVSEP_LEN);
184 	memcpy(&idone, imsg->data, sizeof(idone));
185 
186 	*client_id = idone.client_id;
187 	return NULL;
188 }
189 
190 static const struct got_error *
191 recv_packfile_install(uint32_t *client_id, struct imsg *imsg)
192 {
193 	struct gotd_imsg_packfile_install inst;
194 	size_t datalen;
195 
196 	log_debug("packfile-install received");
197 
198 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
199 	if (datalen != sizeof(inst))
200 		return got_error(GOT_ERR_PRIVSEP_LEN);
201 	memcpy(&inst, imsg->data, sizeof(inst));
202 
203 	*client_id = inst.client_id;
204 	return NULL;
205 }
206 
207 static const struct got_error *
208 recv_ref_updates_start(uint32_t *client_id, struct imsg *imsg)
209 {
210 	struct gotd_imsg_ref_updates_start istart;
211 	size_t datalen;
212 
213 	log_debug("ref-updates-start received");
214 
215 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
216 	if (datalen != sizeof(istart))
217 		return got_error(GOT_ERR_PRIVSEP_LEN);
218 	memcpy(&istart, imsg->data, sizeof(istart));
219 
220 	*client_id = istart.client_id;
221 	return NULL;
222 }
223 
224 static const struct got_error *
225 recv_ref_update(uint32_t *client_id, struct imsg *imsg)
226 {
227 	struct gotd_imsg_ref_update iref;
228 	size_t datalen;
229 
230 	log_debug("ref-update received");
231 
232 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
233 	if (datalen < sizeof(iref))
234 		return got_error(GOT_ERR_PRIVSEP_LEN);
235 	memcpy(&iref, imsg->data, sizeof(iref));
236 
237 	*client_id = iref.client_id;
238 	return NULL;
239 }
240 
241 static const struct got_error *
242 send_ref_update_ok(struct gotd_session_client *client,
243     struct gotd_imsg_ref_update *iref, const char *refname)
244 {
245 	struct gotd_imsg_ref_update_ok iok;
246 	struct gotd_imsgev *iev = &client->iev;
247 	struct ibuf *wbuf;
248 	size_t len;
249 
250 	memset(&iok, 0, sizeof(iok));
251 	iok.client_id = client->id;
252 	memcpy(iok.old_id, iref->old_id, SHA1_DIGEST_LENGTH);
253 	memcpy(iok.new_id, iref->new_id, SHA1_DIGEST_LENGTH);
254 	iok.name_len = strlen(refname);
255 
256 	len = sizeof(iok) + iok.name_len;
257 	wbuf = imsg_create(&iev->ibuf, GOTD_IMSG_REF_UPDATE_OK,
258 	    gotd_session.proc_id, gotd_session.pid, len);
259 	if (wbuf == NULL)
260 		return got_error_from_errno("imsg_create REF_UPDATE_OK");
261 
262 	if (imsg_add(wbuf, &iok, sizeof(iok)) == -1)
263 		return got_error_from_errno("imsg_add REF_UPDATE_OK");
264 	if (imsg_add(wbuf, refname, iok.name_len) == -1)
265 		return got_error_from_errno("imsg_add REF_UPDATE_OK");
266 
267 	wbuf->fd = -1;
268 	imsg_close(&iev->ibuf, wbuf);
269 	gotd_imsg_event_add(iev);
270 	return NULL;
271 }
272 
273 static void
274 send_refs_updated(struct gotd_session_client *client)
275 {
276 	if (gotd_imsg_compose_event(&client->iev, GOTD_IMSG_REFS_UPDATED,
277 	    gotd_session.proc_id, -1, NULL, 0) == -1)
278 		log_warn("imsg compose REFS_UPDATED");
279 }
280 
281 static const struct got_error *
282 send_ref_update_ng(struct gotd_session_client *client,
283     struct gotd_imsg_ref_update *iref, const char *refname,
284     const char *reason)
285 {
286 	const struct got_error *ng_err;
287 	struct gotd_imsg_ref_update_ng ing;
288 	struct gotd_imsgev *iev = &client->iev;
289 	struct ibuf *wbuf;
290 	size_t len;
291 
292 	memset(&ing, 0, sizeof(ing));
293 	ing.client_id = client->id;
294 	memcpy(ing.old_id, iref->old_id, SHA1_DIGEST_LENGTH);
295 	memcpy(ing.new_id, iref->new_id, SHA1_DIGEST_LENGTH);
296 	ing.name_len = strlen(refname);
297 
298 	ng_err = got_error_fmt(GOT_ERR_REF_BUSY, "%s", reason);
299 	ing.reason_len = strlen(ng_err->msg);
300 
301 	len = sizeof(ing) + ing.name_len + ing.reason_len;
302 	wbuf = imsg_create(&iev->ibuf, GOTD_IMSG_REF_UPDATE_NG,
303 	    gotd_session.proc_id, gotd_session.pid, len);
304 	if (wbuf == NULL)
305 		return got_error_from_errno("imsg_create REF_UPDATE_NG");
306 
307 	if (imsg_add(wbuf, &ing, sizeof(ing)) == -1)
308 		return got_error_from_errno("imsg_add REF_UPDATE_NG");
309 	if (imsg_add(wbuf, refname, ing.name_len) == -1)
310 		return got_error_from_errno("imsg_add REF_UPDATE_NG");
311 	if (imsg_add(wbuf, ng_err->msg, ing.reason_len) == -1)
312 		return got_error_from_errno("imsg_add REF_UPDATE_NG");
313 
314 	wbuf->fd = -1;
315 	imsg_close(&iev->ibuf, wbuf);
316 	gotd_imsg_event_add(iev);
317 	return NULL;
318 }
319 
320 static const struct got_error *
321 install_pack(struct gotd_session_client *client, const char *repo_path,
322     struct imsg *imsg)
323 {
324 	const struct got_error *err = NULL;
325 	struct gotd_imsg_packfile_install inst;
326 	char hex[SHA1_DIGEST_STRING_LENGTH];
327 	size_t datalen;
328 	char *packfile_path = NULL, *packidx_path = NULL;
329 
330 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
331 	if (datalen != sizeof(inst))
332 		return got_error(GOT_ERR_PRIVSEP_LEN);
333 	memcpy(&inst, imsg->data, sizeof(inst));
334 
335 	if (client->packfile_path == NULL)
336 		return got_error_msg(GOT_ERR_BAD_REQUEST,
337 		    "client has no pack file");
338 	if (client->packidx_path == NULL)
339 		return got_error_msg(GOT_ERR_BAD_REQUEST,
340 		    "client has no pack file index");
341 
342 	if (got_sha1_digest_to_str(inst.pack_sha1, hex, sizeof(hex)) == NULL)
343 		return got_error_msg(GOT_ERR_NO_SPACE,
344 		    "could not convert pack file SHA1 to hex");
345 
346 	if (asprintf(&packfile_path, "/%s/%s/pack-%s.pack",
347 	    repo_path, GOT_OBJECTS_PACK_DIR, hex) == -1) {
348 		err = got_error_from_errno("asprintf");
349 		goto done;
350 	}
351 
352 	if (asprintf(&packidx_path, "/%s/%s/pack-%s.idx",
353 	    repo_path, GOT_OBJECTS_PACK_DIR, hex) == -1) {
354 		err = got_error_from_errno("asprintf");
355 		goto done;
356 	}
357 
358 	if (rename(client->packfile_path, packfile_path) == -1) {
359 		err = got_error_from_errno3("rename", client->packfile_path,
360 		    packfile_path);
361 		goto done;
362 	}
363 
364 	free(client->packfile_path);
365 	client->packfile_path = NULL;
366 
367 	if (rename(client->packidx_path, packidx_path) == -1) {
368 		err = got_error_from_errno3("rename", client->packidx_path,
369 		    packidx_path);
370 		goto done;
371 	}
372 
373 	free(client->packidx_path);
374 	client->packidx_path = NULL;
375 done:
376 	free(packfile_path);
377 	free(packidx_path);
378 	return err;
379 }
380 
381 static const struct got_error *
382 begin_ref_updates(struct gotd_session_client *client, struct imsg *imsg)
383 {
384 	struct gotd_imsg_ref_updates_start istart;
385 	size_t datalen;
386 
387 	if (client->nref_updates != -1)
388 		return got_error(GOT_ERR_PRIVSEP_MSG);
389 
390 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
391 	if (datalen != sizeof(istart))
392 		return got_error(GOT_ERR_PRIVSEP_LEN);
393 	memcpy(&istart, imsg->data, sizeof(istart));
394 
395 	if (istart.nref_updates <= 0)
396 		return got_error(GOT_ERR_PRIVSEP_MSG);
397 
398 	client->nref_updates = istart.nref_updates;
399 	return NULL;
400 }
401 
402 static const struct got_error *
403 update_ref(int *shut, struct gotd_session_client *client,
404     const char *repo_path, struct imsg *imsg)
405 {
406 	const struct got_error *err = NULL;
407 	struct got_repository *repo = NULL;
408 	struct got_reference *ref = NULL;
409 	struct gotd_imsg_ref_update iref;
410 	struct got_object_id old_id, new_id;
411 	struct got_object_id *id = NULL;
412 	struct got_object *obj = NULL;
413 	char *refname = NULL;
414 	size_t datalen;
415 	int locked = 0;
416 	char hex1[SHA1_DIGEST_STRING_LENGTH];
417 	char hex2[SHA1_DIGEST_STRING_LENGTH];
418 
419 	log_debug("update-ref from uid %d", client->euid);
420 
421 	if (client->nref_updates <= 0)
422 		return got_error(GOT_ERR_PRIVSEP_MSG);
423 
424 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
425 	if (datalen < sizeof(iref))
426 		return got_error(GOT_ERR_PRIVSEP_LEN);
427 	memcpy(&iref, imsg->data, sizeof(iref));
428 	if (datalen != sizeof(iref) + iref.name_len)
429 		return got_error(GOT_ERR_PRIVSEP_LEN);
430 	refname = strndup(imsg->data + sizeof(iref), iref.name_len);
431 	if (refname == NULL)
432 		return got_error_from_errno("strndup");
433 
434 	log_debug("updating ref %s for uid %d", refname, client->euid);
435 
436 	err = got_repo_open(&repo, repo_path, NULL, NULL);
437 	if (err)
438 		goto done;
439 
440 	memcpy(old_id.sha1, iref.old_id, SHA1_DIGEST_LENGTH);
441 	memcpy(new_id.sha1, iref.new_id, SHA1_DIGEST_LENGTH);
442 	err = got_object_open(&obj, repo,
443 	    iref.delete_ref ? &old_id : &new_id);
444 	if (err)
445 		goto done;
446 
447 	if (iref.ref_is_new) {
448 		err = got_ref_open(&ref, repo, refname, 0);
449 		if (err) {
450 			if (err->code != GOT_ERR_NOT_REF)
451 				goto done;
452 			err = got_ref_alloc(&ref, refname, &new_id);
453 			if (err)
454 				goto done;
455 			err = got_ref_write(ref, repo); /* will lock/unlock */
456 			if (err)
457 				goto done;
458 		} else {
459 			err = got_ref_resolve(&id, repo, ref);
460 			if (err)
461 				goto done;
462 			got_object_id_hex(&new_id, hex1, sizeof(hex1));
463 			got_object_id_hex(id, hex2, sizeof(hex2));
464 			err = got_error_fmt(GOT_ERR_REF_BUSY,
465 			    "Addition %s: %s failed; %s: %s has been "
466 			    "created by someone else while transaction "
467 			    "was in progress",
468 			    got_ref_get_name(ref), hex1,
469 			    got_ref_get_name(ref), hex2);
470 			goto done;
471 		}
472 	} else if (iref.delete_ref) {
473 		err = got_ref_open(&ref, repo, refname, 1 /* lock */);
474 		if (err)
475 			goto done;
476 		locked = 1;
477 
478 		err = got_ref_resolve(&id, repo, ref);
479 		if (err)
480 			goto done;
481 
482 		if (got_object_id_cmp(id, &old_id) != 0) {
483 			got_object_id_hex(&old_id, hex1, sizeof(hex1));
484 			got_object_id_hex(id, hex2, sizeof(hex2));
485 			err = got_error_fmt(GOT_ERR_REF_BUSY,
486 			    "Deletion %s: %s failed; %s: %s has been "
487 			    "created by someone else while transaction "
488 			    "was in progress",
489 			    got_ref_get_name(ref), hex1,
490 			    got_ref_get_name(ref), hex2);
491 			goto done;
492 		}
493 
494 		err = got_ref_delete(ref, repo);
495 		if (err)
496 			goto done;
497 
498 		free(id);
499 		id = NULL;
500 	} else {
501 		err = got_ref_open(&ref, repo, refname, 1 /* lock */);
502 		if (err)
503 			goto done;
504 		locked = 1;
505 
506 		err = got_ref_resolve(&id, repo, ref);
507 		if (err)
508 			goto done;
509 
510 		if (got_object_id_cmp(id, &old_id) != 0) {
511 			got_object_id_hex(&old_id, hex1, sizeof(hex1));
512 			got_object_id_hex(id, hex2, sizeof(hex2));
513 			err = got_error_fmt(GOT_ERR_REF_BUSY,
514 			    "Update %s: %s failed; %s: %s has been "
515 			    "created by someone else while transaction "
516 			    "was in progress",
517 			    got_ref_get_name(ref), hex1,
518 			    got_ref_get_name(ref), hex2);
519 			goto done;
520 		}
521 
522 		if (got_object_id_cmp(&new_id, &old_id) != 0) {
523 			err = got_ref_change_ref(ref, &new_id);
524 			if (err)
525 				goto done;
526 
527 			err = got_ref_write(ref, repo);
528 			if (err)
529 				goto done;
530 		}
531 
532 		free(id);
533 		id = NULL;
534 	}
535 done:
536 	if (err) {
537 		if (err->code == GOT_ERR_LOCKFILE_TIMEOUT) {
538 			err = got_error_fmt(GOT_ERR_LOCKFILE_TIMEOUT,
539 			    "could not acquire exclusive file lock for %s",
540 			    refname);
541 		}
542 		send_ref_update_ng(client, &iref, refname, err->msg);
543 	} else
544 		send_ref_update_ok(client, &iref, refname);
545 
546 	if (client->nref_updates > 0) {
547 		client->nref_updates--;
548 		if (client->nref_updates == 0) {
549 			send_refs_updated(client);
550 			client->flush_disconnect = 1;
551 		}
552 
553 	}
554 	if (locked) {
555 		const struct got_error *unlock_err;
556 		unlock_err = got_ref_unlock(ref);
557 		if (unlock_err && err == NULL)
558 			err = unlock_err;
559 	}
560 	if (ref)
561 		got_ref_close(ref);
562 	if (obj)
563 		got_object_close(obj);
564 	if (repo)
565 		got_repo_close(repo);
566 	free(refname);
567 	free(id);
568 	return err;
569 }
570 
571 static void
572 session_dispatch_repo_child(int fd, short event, void *arg)
573 {
574 	struct gotd_imsgev *iev = arg;
575 	struct imsgbuf *ibuf = &iev->ibuf;
576 	struct gotd_session_client *client = &gotd_session_client;
577 	ssize_t n;
578 	int shut = 0;
579 	struct imsg imsg;
580 
581 	if (event & EV_READ) {
582 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
583 			fatal("imsg_read error");
584 		if (n == 0) {
585 			/* Connection closed. */
586 			shut = 1;
587 			goto done;
588 		}
589 	}
590 
591 	if (event & EV_WRITE) {
592 		n = msgbuf_write(&ibuf->w);
593 		if (n == -1 && errno != EAGAIN)
594 			fatal("msgbuf_write");
595 		if (n == 0) {
596 			/* Connection closed. */
597 			shut = 1;
598 			goto done;
599 		}
600 	}
601 
602 	for (;;) {
603 		const struct got_error *err = NULL;
604 		uint32_t client_id = 0;
605 		int do_disconnect = 0;
606 		int do_ref_updates = 0, do_ref_update = 0;
607 		int do_packfile_install = 0;
608 
609 		if ((n = imsg_get(ibuf, &imsg)) == -1)
610 			fatal("%s: imsg_get error", __func__);
611 		if (n == 0)	/* No more messages. */
612 			break;
613 
614 		switch (imsg.hdr.type) {
615 		case GOTD_IMSG_ERROR:
616 			do_disconnect = 1;
617 			err = gotd_imsg_recv_error(&client_id, &imsg);
618 			break;
619 		case GOTD_IMSG_PACKFILE_DONE:
620 			do_disconnect = 1;
621 			err = recv_packfile_done(&client_id, &imsg);
622 			break;
623 		case GOTD_IMSG_PACKFILE_INSTALL:
624 			err = recv_packfile_install(&client_id, &imsg);
625 			if (err == NULL)
626 				do_packfile_install = 1;
627 			break;
628 		case GOTD_IMSG_REF_UPDATES_START:
629 			err = recv_ref_updates_start(&client_id, &imsg);
630 			if (err == NULL)
631 				do_ref_updates = 1;
632 			break;
633 		case GOTD_IMSG_REF_UPDATE:
634 			err = recv_ref_update(&client_id, &imsg);
635 			if (err == NULL)
636 				do_ref_update = 1;
637 			break;
638 		default:
639 			log_debug("unexpected imsg %d", imsg.hdr.type);
640 			break;
641 		}
642 
643 		if (do_disconnect) {
644 			if (err)
645 				disconnect_on_error(client, err);
646 			else
647 				disconnect(client);
648 		} else {
649 			if (do_packfile_install)
650 				err = install_pack(client,
651 				    gotd_session.repo->path, &imsg);
652 			else if (do_ref_updates)
653 				err = begin_ref_updates(client, &imsg);
654 			else if (do_ref_update)
655 				err = update_ref(&shut, client,
656 				    gotd_session.repo->path, &imsg);
657 			if (err)
658 				log_warnx("uid %d: %s", client->euid, err->msg);
659 		}
660 		imsg_free(&imsg);
661 	}
662 done:
663 	if (!shut) {
664 		gotd_imsg_event_add(iev);
665 	} else {
666 		/* This pipe is dead. Remove its event handler */
667 		event_del(&iev->ev);
668 		event_loopexit(NULL);
669 	}
670 }
671 
672 static const struct got_error *
673 recv_capabilities(struct gotd_session_client *client, struct imsg *imsg)
674 {
675 	struct gotd_imsg_capabilities icapas;
676 	size_t datalen;
677 
678 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
679 	if (datalen != sizeof(icapas))
680 		return got_error(GOT_ERR_PRIVSEP_LEN);
681 	memcpy(&icapas, imsg->data, sizeof(icapas));
682 
683 	client->ncapa_alloc = icapas.ncapabilities;
684 	client->capabilities = calloc(client->ncapa_alloc,
685 	    sizeof(*client->capabilities));
686 	if (client->capabilities == NULL) {
687 		client->ncapa_alloc = 0;
688 		return got_error_from_errno("calloc");
689 	}
690 
691 	log_debug("expecting %zu capabilities from uid %d",
692 	    client->ncapa_alloc, client->euid);
693 	return NULL;
694 }
695 
696 static const struct got_error *
697 recv_capability(struct gotd_session_client *client, struct imsg *imsg)
698 {
699 	struct gotd_imsg_capability icapa;
700 	struct gotd_client_capability *capa;
701 	size_t datalen;
702 	char *key, *value = NULL;
703 
704 	if (client->capabilities == NULL ||
705 	    client->ncapabilities >= client->ncapa_alloc) {
706 		return got_error_msg(GOT_ERR_BAD_REQUEST,
707 		    "unexpected capability received");
708 	}
709 
710 	memset(&icapa, 0, sizeof(icapa));
711 
712 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
713 	if (datalen < sizeof(icapa))
714 		return got_error(GOT_ERR_PRIVSEP_LEN);
715 	memcpy(&icapa, imsg->data, sizeof(icapa));
716 
717 	if (datalen != sizeof(icapa) + icapa.key_len + icapa.value_len)
718 		return got_error(GOT_ERR_PRIVSEP_LEN);
719 
720 	key = strndup(imsg->data + sizeof(icapa), icapa.key_len);
721 	if (key == NULL)
722 		return got_error_from_errno("strndup");
723 	if (icapa.value_len > 0) {
724 		value = strndup(imsg->data + sizeof(icapa) + icapa.key_len,
725 		    icapa.value_len);
726 		if (value == NULL) {
727 			free(key);
728 			return got_error_from_errno("strndup");
729 		}
730 	}
731 
732 	capa = &client->capabilities[client->ncapabilities++];
733 	capa->key = key;
734 	capa->value = value;
735 
736 	if (value)
737 		log_debug("uid %d: capability %s=%s", client->euid, key, value);
738 	else
739 		log_debug("uid %d: capability %s", client->euid, key);
740 
741 	return NULL;
742 }
743 
744 static const struct got_error *
745 ensure_client_is_reading(struct gotd_session_client *client)
746 {
747 	if (client->is_writing) {
748 		return got_error_fmt(GOT_ERR_BAD_PACKET,
749 		    "uid %d made a read-request but is not reading from "
750 		    "a repository", client->euid);
751 	}
752 
753 	return NULL;
754 }
755 
756 static const struct got_error *
757 ensure_client_is_writing(struct gotd_session_client *client)
758 {
759 	if (!client->is_writing) {
760 		return got_error_fmt(GOT_ERR_BAD_PACKET,
761 		    "uid %d made a write-request but is not writing to "
762 		    "a repository", client->euid);
763 	}
764 
765 	return NULL;
766 }
767 
768 static const struct got_error *
769 forward_want(struct gotd_session_client *client, struct imsg *imsg)
770 {
771 	struct gotd_imsg_want ireq;
772 	struct gotd_imsg_want iwant;
773 	size_t datalen;
774 
775 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
776 	if (datalen != sizeof(ireq))
777 		return got_error(GOT_ERR_PRIVSEP_LEN);
778 
779 	memcpy(&ireq, imsg->data, datalen);
780 
781 	memset(&iwant, 0, sizeof(iwant));
782 	memcpy(iwant.object_id, ireq.object_id, SHA1_DIGEST_LENGTH);
783 	iwant.client_id = client->id;
784 
785 	if (gotd_imsg_compose_event(&client->repo_child_iev, GOTD_IMSG_WANT,
786 	    gotd_session.proc_id, -1, &iwant, sizeof(iwant)) == -1)
787 		return got_error_from_errno("imsg compose WANT");
788 
789 	return NULL;
790 }
791 
792 static const struct got_error *
793 forward_ref_update(struct gotd_session_client *client, struct imsg *imsg)
794 {
795 	const struct got_error *err = NULL;
796 	struct gotd_imsg_ref_update ireq;
797 	struct gotd_imsg_ref_update *iref = NULL;
798 	size_t datalen;
799 
800 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
801 	if (datalen < sizeof(ireq))
802 		return got_error(GOT_ERR_PRIVSEP_LEN);
803 	memcpy(&ireq, imsg->data, sizeof(ireq));
804 	if (datalen != sizeof(ireq) + ireq.name_len)
805 		return got_error(GOT_ERR_PRIVSEP_LEN);
806 
807 	iref = malloc(datalen);
808 	if (iref == NULL)
809 		return got_error_from_errno("malloc");
810 	memcpy(iref, imsg->data, datalen);
811 
812 	iref->client_id = client->id;
813 	if (gotd_imsg_compose_event(&client->repo_child_iev,
814 	    GOTD_IMSG_REF_UPDATE, gotd_session.proc_id, -1,
815 	    iref, datalen) == -1)
816 		err = got_error_from_errno("imsg compose REF_UPDATE");
817 	free(iref);
818 	return err;
819 }
820 
821 static const struct got_error *
822 forward_have(struct gotd_session_client *client, struct imsg *imsg)
823 {
824 	struct gotd_imsg_have ireq;
825 	struct gotd_imsg_have ihave;
826 	size_t datalen;
827 
828 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
829 	if (datalen != sizeof(ireq))
830 		return got_error(GOT_ERR_PRIVSEP_LEN);
831 
832 	memcpy(&ireq, imsg->data, datalen);
833 
834 	memset(&ihave, 0, sizeof(ihave));
835 	memcpy(ihave.object_id, ireq.object_id, SHA1_DIGEST_LENGTH);
836 	ihave.client_id = client->id;
837 
838 	if (gotd_imsg_compose_event(&client->repo_child_iev, GOTD_IMSG_HAVE,
839 	    gotd_session.proc_id, -1, &ihave, sizeof(ihave)) == -1)
840 		return got_error_from_errno("imsg compose HAVE");
841 
842 	return NULL;
843 }
844 
845 static int
846 client_has_capability(struct gotd_session_client *client, const char *capastr)
847 {
848 	struct gotd_client_capability *capa;
849 	size_t i;
850 
851 	if (client->ncapabilities == 0)
852 		return 0;
853 
854 	for (i = 0; i < client->ncapabilities; i++) {
855 		capa = &client->capabilities[i];
856 		if (strcmp(capa->key, capastr) == 0)
857 			return 1;
858 	}
859 
860 	return 0;
861 }
862 
863 static const struct got_error *
864 recv_packfile(struct gotd_session_client *client)
865 {
866 	const struct got_error *err = NULL;
867 	struct gotd_imsg_recv_packfile ipack;
868 	struct gotd_imsg_packfile_pipe ipipe;
869 	struct gotd_imsg_packidx_file ifile;
870 	char *basepath = NULL, *pack_path = NULL, *idx_path = NULL;
871 	int packfd = -1, idxfd = -1;
872 	int pipe[2] = { -1, -1 };
873 
874 	if (client->packfile_path) {
875 		return got_error_fmt(GOT_ERR_PRIVSEP_MSG,
876 		    "uid %d already has a pack file", client->euid);
877 	}
878 
879 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe) == -1)
880 		return got_error_from_errno("socketpair");
881 
882 	memset(&ipipe, 0, sizeof(ipipe));
883 	ipipe.client_id = client->id;
884 
885 	/* Send pack pipe end 0 to repo child process. */
886 	if (gotd_imsg_compose_event(&client->repo_child_iev,
887 	    GOTD_IMSG_PACKFILE_PIPE, gotd_session.proc_id, pipe[0],
888 	        &ipipe, sizeof(ipipe)) == -1) {
889 		err = got_error_from_errno("imsg compose PACKFILE_PIPE");
890 		pipe[0] = -1;
891 		goto done;
892 	}
893 	pipe[0] = -1;
894 
895 	/* Send pack pipe end 1 to gotsh(1) (expects just an fd, no data). */
896 	if (gotd_imsg_compose_event(&client->iev,
897 	    GOTD_IMSG_PACKFILE_PIPE, gotd_session.proc_id, pipe[1],
898 	    NULL, 0) == -1)
899 		err = got_error_from_errno("imsg compose PACKFILE_PIPE");
900 	pipe[1] = -1;
901 
902 	if (asprintf(&basepath, "%s/%s/receiving-from-uid-%d.pack",
903 	    got_repo_get_path(gotd_session.repo), GOT_OBJECTS_PACK_DIR,
904 	    client->euid) == -1) {
905 		err = got_error_from_errno("asprintf");
906 		goto done;
907 	}
908 
909 	err = got_opentemp_named_fd(&pack_path, &packfd, basepath, "");
910 	if (err)
911 		goto done;
912 	if (fchmod(packfd, GOT_DEFAULT_PACK_MODE) == -1) {
913 		err = got_error_from_errno2("fchmod", pack_path);
914 		goto done;
915 	}
916 
917 	free(basepath);
918 	if (asprintf(&basepath, "%s/%s/receiving-from-uid-%d.idx",
919 	    got_repo_get_path(gotd_session.repo), GOT_OBJECTS_PACK_DIR,
920 	    client->euid) == -1) {
921 		err = got_error_from_errno("asprintf");
922 		basepath = NULL;
923 		goto done;
924 	}
925 	err = got_opentemp_named_fd(&idx_path, &idxfd, basepath, "");
926 	if (err)
927 		goto done;
928 	if (fchmod(idxfd, GOT_DEFAULT_PACK_MODE) == -1) {
929 		err = got_error_from_errno2("fchmod", idx_path);
930 		goto done;
931 	}
932 
933 	memset(&ifile, 0, sizeof(ifile));
934 	ifile.client_id = client->id;
935 	if (gotd_imsg_compose_event(&client->repo_child_iev,
936 	    GOTD_IMSG_PACKIDX_FILE, gotd_session.proc_id,
937 	    idxfd, &ifile, sizeof(ifile)) == -1) {
938 		err = got_error_from_errno("imsg compose PACKIDX_FILE");
939 		idxfd = -1;
940 		goto done;
941 	}
942 	idxfd = -1;
943 
944 	memset(&ipack, 0, sizeof(ipack));
945 	ipack.client_id = client->id;
946 	if (client_has_capability(client, GOT_CAPA_REPORT_STATUS))
947 		ipack.report_status = 1;
948 
949 	if (gotd_imsg_compose_event(&client->repo_child_iev,
950 	    GOTD_IMSG_RECV_PACKFILE, gotd_session.proc_id, packfd,
951 	    &ipack, sizeof(ipack)) == -1) {
952 		err = got_error_from_errno("imsg compose RECV_PACKFILE");
953 		packfd = -1;
954 		goto done;
955 	}
956 	packfd = -1;
957 
958 done:
959 	free(basepath);
960 	if (pipe[0] != -1 && close(pipe[0]) == -1 && err == NULL)
961 		err = got_error_from_errno("close");
962 	if (pipe[1] != -1 && close(pipe[1]) == -1 && err == NULL)
963 		err = got_error_from_errno("close");
964 	if (packfd != -1 && close(packfd) == -1 && err == NULL)
965 		err = got_error_from_errno("close");
966 	if (idxfd != -1 && close(idxfd) == -1 && err == NULL)
967 		err = got_error_from_errno("close");
968 	if (err) {
969 		free(pack_path);
970 		free(idx_path);
971 	} else {
972 		client->packfile_path = pack_path;
973 		client->packidx_path = idx_path;
974 	}
975 	return err;
976 }
977 
978 static const struct got_error *
979 send_packfile(struct gotd_session_client *client)
980 {
981 	const struct got_error *err = NULL;
982 	struct gotd_imsg_send_packfile ipack;
983 	struct gotd_imsg_packfile_pipe ipipe;
984 	int pipe[2];
985 
986 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe) == -1)
987 		return got_error_from_errno("socketpair");
988 
989 	memset(&ipack, 0, sizeof(ipack));
990 	memset(&ipipe, 0, sizeof(ipipe));
991 
992 	ipack.client_id = client->id;
993 	if (client_has_capability(client, GOT_CAPA_SIDE_BAND_64K))
994 		ipack.report_progress = 1;
995 
996 	client->delta_cache_fd = got_opentempfd();
997 	if (client->delta_cache_fd == -1)
998 		return got_error_from_errno("got_opentempfd");
999 
1000 	if (gotd_imsg_compose_event(&client->repo_child_iev,
1001 	    GOTD_IMSG_SEND_PACKFILE, PROC_GOTD, client->delta_cache_fd,
1002 	    &ipack, sizeof(ipack)) == -1) {
1003 		err = got_error_from_errno("imsg compose SEND_PACKFILE");
1004 		close(pipe[0]);
1005 		close(pipe[1]);
1006 		return err;
1007 	}
1008 
1009 	ipipe.client_id = client->id;
1010 
1011 	/* Send pack pipe end 0 to repo child process. */
1012 	if (gotd_imsg_compose_event(&client->repo_child_iev,
1013 	    GOTD_IMSG_PACKFILE_PIPE, PROC_GOTD,
1014 	    pipe[0], &ipipe, sizeof(ipipe)) == -1) {
1015 		err = got_error_from_errno("imsg compose PACKFILE_PIPE");
1016 		close(pipe[1]);
1017 		return err;
1018 	}
1019 
1020 	/* Send pack pipe end 1 to gotsh(1) (expects just an fd, no data). */
1021 	if (gotd_imsg_compose_event(&client->iev,
1022 	    GOTD_IMSG_PACKFILE_PIPE, PROC_GOTD, pipe[1], NULL, 0) == -1)
1023 		err = got_error_from_errno("imsg compose PACKFILE_PIPE");
1024 
1025 	return err;
1026 }
1027 
1028 static void
1029 session_dispatch_client(int fd, short events, void *arg)
1030 {
1031 	struct gotd_imsgev *iev = arg;
1032 	struct imsgbuf *ibuf = &iev->ibuf;
1033 	struct gotd_session_client *client = &gotd_session_client;
1034 	const struct got_error *err = NULL;
1035 	struct imsg imsg;
1036 	ssize_t n;
1037 
1038 	if (events & EV_WRITE) {
1039 		while (ibuf->w.queued) {
1040 			n = msgbuf_write(&ibuf->w);
1041 			if (n == -1 && errno == EPIPE) {
1042 				/*
1043 				 * The client has closed its socket.
1044 				 * This can happen when Git clients are
1045 				 * done sending pack file data.
1046 				 */
1047 				msgbuf_clear(&ibuf->w);
1048 				continue;
1049 			} else if (n == -1 && errno != EAGAIN) {
1050 				err = got_error_from_errno("imsg_flush");
1051 				disconnect_on_error(client, err);
1052 				return;
1053 			}
1054 			if (n == 0) {
1055 				/* Connection closed. */
1056 				err = got_error(GOT_ERR_EOF);
1057 				disconnect_on_error(client, err);
1058 				return;
1059 			}
1060 		}
1061 
1062 		if (client->flush_disconnect) {
1063 			disconnect(client);
1064 			return;
1065 		}
1066 	}
1067 
1068 	if ((events & EV_READ) == 0)
1069 		return;
1070 
1071 	memset(&imsg, 0, sizeof(imsg));
1072 
1073 	while (err == NULL) {
1074 		err = gotd_imsg_recv(&imsg, ibuf, 0);
1075 		if (err) {
1076 			if (err->code == GOT_ERR_PRIVSEP_READ)
1077 				err = NULL;
1078 			else if (err->code == GOT_ERR_EOF &&
1079 			    client->state == GOTD_STATE_EXPECT_CAPABILITIES) {
1080 				/*
1081 				 * The client has closed its socket before
1082 				 * sending its capability announcement.
1083 				 * This can happen when Git clients have
1084 				 * no ref-updates to send.
1085 				 */
1086 				disconnect_on_error(client, err);
1087 				return;
1088 			}
1089 			break;
1090 		}
1091 
1092 		evtimer_del(&client->tmo);
1093 
1094 		switch (imsg.hdr.type) {
1095 		case GOTD_IMSG_CAPABILITIES:
1096 			if (client->state != GOTD_STATE_EXPECT_CAPABILITIES) {
1097 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1098 				    "unexpected capabilities received");
1099 				break;
1100 			}
1101 			log_debug("receiving capabilities from uid %d",
1102 			    client->euid);
1103 			err = recv_capabilities(client, &imsg);
1104 			break;
1105 		case GOTD_IMSG_CAPABILITY:
1106 			if (client->state != GOTD_STATE_EXPECT_CAPABILITIES) {
1107 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1108 				    "unexpected capability received");
1109 				break;
1110 			}
1111 			err = recv_capability(client, &imsg);
1112 			if (err || client->ncapabilities < client->ncapa_alloc)
1113 				break;
1114 			if (!client->is_writing) {
1115 				client->state = GOTD_STATE_EXPECT_WANT;
1116 				client->accept_flush_pkt = 1;
1117 				log_debug("uid %d: expecting want-lines",
1118 				    client->euid);
1119 			} else if (client->is_writing) {
1120 				client->state = GOTD_STATE_EXPECT_REF_UPDATE;
1121 				client->accept_flush_pkt = 1;
1122 				log_debug("uid %d: expecting ref-update-lines",
1123 				    client->euid);
1124 			} else
1125 				fatalx("client %d is both reading and writing",
1126 				    client->euid);
1127 			break;
1128 		case GOTD_IMSG_WANT:
1129 			if (client->state != GOTD_STATE_EXPECT_WANT) {
1130 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1131 				    "unexpected want-line received");
1132 				break;
1133 			}
1134 			log_debug("received want-line from uid %d",
1135 			    client->euid);
1136 			err = ensure_client_is_reading(client);
1137 			if (err)
1138 				break;
1139 			client->accept_flush_pkt = 1;
1140 			err = forward_want(client, &imsg);
1141 			break;
1142 		case GOTD_IMSG_REF_UPDATE:
1143 			if (client->state != GOTD_STATE_EXPECT_REF_UPDATE &&
1144 			    client->state !=
1145 			    GOTD_STATE_EXPECT_MORE_REF_UPDATES) {
1146 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1147 				    "unexpected ref-update-line received");
1148 				break;
1149 			}
1150 			log_debug("received ref-update-line from uid %d",
1151 			    client->euid);
1152 			err = ensure_client_is_writing(client);
1153 			if (err)
1154 				break;
1155 			err = forward_ref_update(client, &imsg);
1156 			if (err)
1157 				break;
1158 			client->state = GOTD_STATE_EXPECT_MORE_REF_UPDATES;
1159 			client->accept_flush_pkt = 1;
1160 			break;
1161 		case GOTD_IMSG_HAVE:
1162 			if (client->state != GOTD_STATE_EXPECT_HAVE) {
1163 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1164 				    "unexpected have-line received");
1165 				break;
1166 			}
1167 			log_debug("received have-line from uid %d",
1168 			    client->euid);
1169 			err = ensure_client_is_reading(client);
1170 			if (err)
1171 				break;
1172 			err = forward_have(client, &imsg);
1173 			if (err)
1174 				break;
1175 			client->accept_flush_pkt = 1;
1176 			break;
1177 		case GOTD_IMSG_FLUSH:
1178 			if (client->state == GOTD_STATE_EXPECT_WANT ||
1179 			    client->state == GOTD_STATE_EXPECT_HAVE) {
1180 				err = ensure_client_is_reading(client);
1181 				if (err)
1182 					break;
1183 			} else if (client->state ==
1184 			    GOTD_STATE_EXPECT_MORE_REF_UPDATES) {
1185 				err = ensure_client_is_writing(client);
1186 				if (err)
1187 					break;
1188 			} else if (client->state != GOTD_STATE_EXPECT_DONE) {
1189 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1190 				    "unexpected flush-pkt received");
1191 				break;
1192 			}
1193 			if (!client->accept_flush_pkt) {
1194 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1195 				    "unexpected flush-pkt received");
1196 				break;
1197 			}
1198 
1199 			/*
1200 			 * Accept just one flush packet at a time.
1201 			 * Future client state transitions will set this flag
1202 			 * again if another flush packet is expected.
1203 			 */
1204 			client->accept_flush_pkt = 0;
1205 
1206 			log_debug("received flush-pkt from uid %d",
1207 			    client->euid);
1208 			if (client->state == GOTD_STATE_EXPECT_WANT) {
1209 				client->state = GOTD_STATE_EXPECT_HAVE;
1210 				log_debug("uid %d: expecting have-lines",
1211 				    client->euid);
1212 			} else if (client->state == GOTD_STATE_EXPECT_HAVE) {
1213 				client->state = GOTD_STATE_EXPECT_DONE;
1214 				client->accept_flush_pkt = 1;
1215 				log_debug("uid %d: expecting 'done'",
1216 				    client->euid);
1217 			} else if (client->state ==
1218 			    GOTD_STATE_EXPECT_MORE_REF_UPDATES) {
1219 				client->state = GOTD_STATE_EXPECT_PACKFILE;
1220 				log_debug("uid %d: expecting packfile",
1221 				    client->euid);
1222 				err = recv_packfile(client);
1223 			} else if (client->state != GOTD_STATE_EXPECT_DONE) {
1224 				/* should not happen, see above */
1225 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1226 				    "unexpected client state");
1227 				break;
1228 			}
1229 			break;
1230 		case GOTD_IMSG_DONE:
1231 			if (client->state != GOTD_STATE_EXPECT_HAVE &&
1232 			    client->state != GOTD_STATE_EXPECT_DONE) {
1233 				err = got_error_msg(GOT_ERR_BAD_REQUEST,
1234 				    "unexpected flush-pkt received");
1235 				break;
1236 			}
1237 			log_debug("received 'done' from uid %d", client->euid);
1238 			err = ensure_client_is_reading(client);
1239 			if (err)
1240 				break;
1241 			client->state = GOTD_STATE_DONE;
1242 			client->accept_flush_pkt = 1;
1243 			err = send_packfile(client);
1244 			break;
1245 		default:
1246 			log_debug("unexpected imsg %d", imsg.hdr.type);
1247 			err = got_error(GOT_ERR_PRIVSEP_MSG);
1248 			break;
1249 		}
1250 
1251 		imsg_free(&imsg);
1252 	}
1253 
1254 	if (err) {
1255 		if (err->code != GOT_ERR_EOF ||
1256 		    client->state != GOTD_STATE_EXPECT_PACKFILE)
1257 			disconnect_on_error(client, err);
1258 	} else {
1259 		gotd_imsg_event_add(iev);
1260 		evtimer_add(&client->tmo, &gotd_session.request_timeout);
1261 	}
1262 }
1263 
1264 static const struct got_error *
1265 list_refs_request(void)
1266 {
1267 	static const struct got_error *err;
1268 	struct gotd_session_client *client = &gotd_session_client;
1269 	struct gotd_imsgev *iev = &client->repo_child_iev;
1270 	struct gotd_imsg_list_refs_internal ilref;
1271 	int fd;
1272 
1273 	if (client->state != GOTD_STATE_EXPECT_LIST_REFS)
1274 		return got_error(GOT_ERR_PRIVSEP_MSG);
1275 
1276 	memset(&ilref, 0, sizeof(ilref));
1277 	ilref.client_id = client->id;
1278 
1279 	fd = dup(client->fd);
1280 	if (fd == -1)
1281 		return got_error_from_errno("dup");
1282 
1283 	if (gotd_imsg_compose_event(iev, GOTD_IMSG_LIST_REFS_INTERNAL,
1284 	    gotd_session.proc_id, fd, &ilref, sizeof(ilref)) == -1) {
1285 		err = got_error_from_errno("imsg compose LIST_REFS_INTERNAL");
1286 		close(fd);
1287 		return err;
1288 	}
1289 
1290 	client->state = GOTD_STATE_EXPECT_CAPABILITIES;
1291 	log_debug("uid %d: expecting capabilities", client->euid);
1292 	return NULL;
1293 }
1294 
1295 static const struct got_error *
1296 recv_connect(struct imsg *imsg)
1297 {
1298 	struct gotd_session_client *client = &gotd_session_client;
1299 	struct gotd_imsg_connect iconnect;
1300 	size_t datalen;
1301 
1302 	if (client->state != GOTD_STATE_EXPECT_LIST_REFS)
1303 		return got_error(GOT_ERR_PRIVSEP_MSG);
1304 
1305 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1306 	if (datalen != sizeof(iconnect))
1307 		return got_error(GOT_ERR_PRIVSEP_LEN);
1308 	memcpy(&iconnect, imsg->data, sizeof(iconnect));
1309 
1310 	if (imsg->fd == -1)
1311 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
1312 
1313 	client->fd = imsg->fd;
1314 	client->euid = iconnect.euid;
1315 	client->egid = iconnect.egid;
1316 
1317 	imsg_init(&client->iev.ibuf, client->fd);
1318 	client->iev.handler = session_dispatch_client;
1319 	client->iev.events = EV_READ;
1320 	client->iev.handler_arg = NULL;
1321 	event_set(&client->iev.ev, client->iev.ibuf.fd, EV_READ,
1322 	    session_dispatch_client, &client->iev);
1323 	gotd_imsg_event_add(&client->iev);
1324 	evtimer_set(&client->tmo, gotd_request_timeout, client);
1325 
1326 	return NULL;
1327 }
1328 
1329 static const struct got_error *
1330 recv_repo_child(struct imsg *imsg)
1331 {
1332 	struct gotd_imsg_connect_repo_child ichild;
1333 	struct gotd_session_client *client = &gotd_session_client;
1334 	size_t datalen;
1335 
1336 	if (client->state != GOTD_STATE_EXPECT_LIST_REFS)
1337 		return got_error(GOT_ERR_PRIVSEP_MSG);
1338 
1339 	/* We should already have received a pipe to the listener. */
1340 	if (client->fd == -1)
1341 		return got_error(GOT_ERR_PRIVSEP_MSG);
1342 
1343 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1344 	if (datalen != sizeof(ichild))
1345 		return got_error(GOT_ERR_PRIVSEP_LEN);
1346 
1347 	memcpy(&ichild, imsg->data, sizeof(ichild));
1348 
1349 	client->id = ichild.client_id;
1350 	if (ichild.proc_id == PROC_REPO_WRITE)
1351 		client->is_writing = 1;
1352 	else if (ichild.proc_id == PROC_REPO_READ)
1353 		client->is_writing = 0;
1354 	else
1355 		return got_error_msg(GOT_ERR_PRIVSEP_MSG,
1356 		    "bad child process type");
1357 
1358 	if (imsg->fd == -1)
1359 		return got_error(GOT_ERR_PRIVSEP_NO_FD);
1360 
1361 	imsg_init(&client->repo_child_iev.ibuf, imsg->fd);
1362 	client->repo_child_iev.handler = session_dispatch_repo_child;
1363 	client->repo_child_iev.events = EV_READ;
1364 	client->repo_child_iev.handler_arg = NULL;
1365 	event_set(&client->repo_child_iev.ev, client->repo_child_iev.ibuf.fd,
1366 	    EV_READ, session_dispatch_repo_child, &client->repo_child_iev);
1367 	gotd_imsg_event_add(&client->repo_child_iev);
1368 
1369 	/* The "recvfd" pledge promise is no longer needed. */
1370 	if (pledge("stdio rpath wpath cpath sendfd fattr flock", NULL) == -1)
1371 		fatal("pledge");
1372 
1373 	return NULL;
1374 }
1375 
1376 static void
1377 session_dispatch(int fd, short event, void *arg)
1378 {
1379 	struct gotd_imsgev *iev = arg;
1380 	struct imsgbuf *ibuf = &iev->ibuf;
1381 	struct gotd_session_client *client = &gotd_session_client;
1382 	ssize_t n;
1383 	int shut = 0;
1384 	struct imsg imsg;
1385 
1386 	if (event & EV_READ) {
1387 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
1388 			fatal("imsg_read error");
1389 		if (n == 0) {
1390 			/* Connection closed. */
1391 			shut = 1;
1392 			goto done;
1393 		}
1394 	}
1395 
1396 	if (event & EV_WRITE) {
1397 		n = msgbuf_write(&ibuf->w);
1398 		if (n == -1 && errno != EAGAIN)
1399 			fatal("msgbuf_write");
1400 		if (n == 0) {
1401 			/* Connection closed. */
1402 			shut = 1;
1403 			goto done;
1404 		}
1405 	}
1406 
1407 	for (;;) {
1408 		const struct got_error *err = NULL;
1409 		uint32_t client_id = 0;
1410 		int do_disconnect = 0, do_list_refs = 0;
1411 
1412 		if ((n = imsg_get(ibuf, &imsg)) == -1)
1413 			fatal("%s: imsg_get error", __func__);
1414 		if (n == 0)	/* No more messages. */
1415 			break;
1416 
1417 		switch (imsg.hdr.type) {
1418 		case GOTD_IMSG_ERROR:
1419 			do_disconnect = 1;
1420 			err = gotd_imsg_recv_error(&client_id, &imsg);
1421 			break;
1422 		case GOTD_IMSG_CONNECT:
1423 			err = recv_connect(&imsg);
1424 			break;
1425 		case GOTD_IMSG_DISCONNECT:
1426 			do_disconnect = 1;
1427 			break;
1428 		case GOTD_IMSG_CONNECT_REPO_CHILD:
1429 			err = recv_repo_child(&imsg);
1430 			if (err)
1431 				break;
1432 			do_list_refs = 1;
1433 			break;
1434 		default:
1435 			log_debug("unexpected imsg %d", imsg.hdr.type);
1436 			break;
1437 		}
1438 		imsg_free(&imsg);
1439 
1440 		if (do_disconnect) {
1441 			if (err)
1442 				disconnect_on_error(client, err);
1443 			else
1444 				disconnect(client);
1445 		} else if (do_list_refs)
1446 			err = list_refs_request();
1447 
1448 		if (err)
1449 			log_warnx("uid %d: %s", client->euid, err->msg);
1450 	}
1451 done:
1452 	if (!shut) {
1453 		gotd_imsg_event_add(iev);
1454 	} else {
1455 		/* This pipe is dead. Remove its event handler */
1456 		event_del(&iev->ev);
1457 		event_loopexit(NULL);
1458 	}
1459 }
1460 
1461 void
1462 session_main(const char *title, const char *repo_path,
1463     int *pack_fds, int *temp_fds, struct timeval *request_timeout,
1464     enum gotd_procid proc_id)
1465 {
1466 	const struct got_error *err = NULL;
1467 	struct event evsigint, evsigterm, evsighup, evsigusr1;
1468 
1469 	gotd_session.title = title;
1470 	gotd_session.pid = getpid();
1471 	gotd_session.pack_fds = pack_fds;
1472 	gotd_session.temp_fds = temp_fds;
1473 	memcpy(&gotd_session.request_timeout, request_timeout,
1474 	    sizeof(gotd_session.request_timeout));
1475 	gotd_session.proc_id = proc_id;
1476 
1477 	err = got_repo_open(&gotd_session.repo, repo_path, NULL, pack_fds);
1478 	if (err)
1479 		goto done;
1480 	if (!got_repo_is_bare(gotd_session.repo)) {
1481 		err = got_error_msg(GOT_ERR_NOT_GIT_REPO,
1482 		    "bare git repository required");
1483 		goto done;
1484 	}
1485 
1486 	got_repo_temp_fds_set(gotd_session.repo, temp_fds);
1487 
1488 	signal_set(&evsigint, SIGINT, gotd_session_sighdlr, NULL);
1489 	signal_set(&evsigterm, SIGTERM, gotd_session_sighdlr, NULL);
1490 	signal_set(&evsighup, SIGHUP, gotd_session_sighdlr, NULL);
1491 	signal_set(&evsigusr1, SIGUSR1, gotd_session_sighdlr, NULL);
1492 	signal(SIGPIPE, SIG_IGN);
1493 
1494 	signal_add(&evsigint, NULL);
1495 	signal_add(&evsigterm, NULL);
1496 	signal_add(&evsighup, NULL);
1497 	signal_add(&evsigusr1, NULL);
1498 
1499 	gotd_session_client.state = GOTD_STATE_EXPECT_LIST_REFS;
1500 	gotd_session_client.fd = -1;
1501 	gotd_session_client.nref_updates = -1;
1502 	gotd_session_client.delta_cache_fd = -1;
1503 	gotd_session_client.accept_flush_pkt = 1;
1504 
1505 	imsg_init(&gotd_session.parent_iev.ibuf, GOTD_FILENO_MSG_PIPE);
1506 	gotd_session.parent_iev.handler = session_dispatch;
1507 	gotd_session.parent_iev.events = EV_READ;
1508 	gotd_session.parent_iev.handler_arg = NULL;
1509 	event_set(&gotd_session.parent_iev.ev, gotd_session.parent_iev.ibuf.fd,
1510 	    EV_READ, session_dispatch, &gotd_session.parent_iev);
1511 	if (gotd_imsg_compose_event(&gotd_session.parent_iev,
1512 	    GOTD_IMSG_CLIENT_SESSION_READY, gotd_session.proc_id,
1513 	    -1, NULL, 0) == -1) {
1514 		err = got_error_from_errno("imsg compose CLIENT_SESSION_READY");
1515 		goto done;
1516 	}
1517 
1518 	event_dispatch();
1519 done:
1520 	if (err)
1521 		log_warnx("%s: %s", title, err->msg);
1522 	gotd_session_shutdown();
1523 }
1524 
1525 void
1526 gotd_session_shutdown(void)
1527 {
1528 	log_debug("shutting down");
1529 	if (gotd_session.repo)
1530 		got_repo_close(gotd_session.repo);
1531 	got_repo_pack_fds_close(gotd_session.pack_fds);
1532 	got_repo_temp_fds_close(gotd_session.temp_fds);
1533 	exit(0);
1534 }