Gotweb

Blob

Date:: Tue Sep 21 20:34:22 2021 UTC
Message:: portable: initial Linux compilation This commit modifies the GoT main branch to be able to compile it under linux.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2019 Ori Bernstein <ori@openbsd.org>
3  * Copyright (c) 2021 Stefan Sperling <stsp@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include <sys/types.h>
19 #include <sys/uio.h>
20 #include <sys/time.h>
21 #include <sys/stat.h>
22 
23 #include <stdint.h>
24 #include <errno.h>
25 #include <limits.h>
26 #include <signal.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <ctype.h>
31 #include <sha1.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <zlib.h>
35 #include <err.h>
36 
37 #include "got_error.h"
38 #include "got_object.h"
39 #include "got_path.h"
40 #include "got_version.h"
41 #include "got_fetch.h"
42 #include "got_reference.h"
43 
44 #include "got_lib_sha1.h"
45 #include "got_lib_delta.h"
46 #include "got_lib_object.h"
47 #include "got_lib_object_parse.h"
48 #include "got_lib_privsep.h"
49 #include "got_lib_pack.h"
50 #include "got_lib_pkt.h"
51 #include "got_lib_gitproto.h"
52 
53 #ifndef nitems
54 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
55 #endif
56 
57 struct got_object *indexed;
58 static int chattygot;
59 
60 static const struct got_capability got_capabilities[] = {
61 	{ GOT_CAPA_AGENT, "got/" GOT_VERSION_STR },
62 	{ GOT_CAPA_OFS_DELTA, NULL },
63 #if 0
64 	{ GOT_CAPA_SIDE_BAND_64K, NULL },
65 #endif
66 	{ GOT_CAPA_REPORT_STATUS, NULL },
67 	{ GOT_CAPA_DELETE_REFS, NULL },
68 };
69 
70 static const struct got_error *
71 send_upload_progress(struct imsgbuf *ibuf, off_t bytes)
72 {
73 	if (imsg_compose(ibuf, GOT_IMSG_SEND_UPLOAD_PROGRESS, 0, 0, -1,
74 	    &bytes, sizeof(bytes)) == -1)
75 		return got_error_from_errno(
76 		    "imsg_compose SEND_UPLOAD_PROGRESS");
77 
78 	return got_privsep_flush_imsg(ibuf);
79 }
80 
81 static const struct got_error *
82 send_pack_request(struct imsgbuf *ibuf)
83 {
84 	if (imsg_compose(ibuf, GOT_IMSG_SEND_PACK_REQUEST, 0, 0, -1,
85 	    NULL, 0) == -1)
86 		return got_error_from_errno("imsg_compose SEND_PACK_REQUEST");
87 	return got_privsep_flush_imsg(ibuf);
88 }
89 
90 static const struct got_error *
91 send_done(struct imsgbuf *ibuf)
92 {
93 	if (imsg_compose(ibuf, GOT_IMSG_SEND_DONE, 0, 0, -1, NULL, 0) == -1)
94 		return got_error_from_errno("imsg_compose SEND_DONE");
95 	return got_privsep_flush_imsg(ibuf);
96 }
97 
98 static const struct got_error *
99 recv_packfd(int *packfd, struct imsgbuf *ibuf)
100 {
101 	const struct got_error *err;
102 	struct imsg imsg;
103 
104 	*packfd = -1;
105 
106 	err = got_privsep_recv_imsg(&imsg, ibuf, 0);
107 	if (err)
108 		return err;
109 		
110 	if (imsg.hdr.type == GOT_IMSG_STOP) {
111 		err = got_error(GOT_ERR_CANCELLED);
112 		goto done;
113 	}
114 
115 	if (imsg.hdr.type != GOT_IMSG_SEND_PACKFD) {
116 		err = got_error(GOT_ERR_PRIVSEP_MSG);
117 		goto done;
118 	}
119 
120 	if (imsg.hdr.len - IMSG_HEADER_SIZE != 0) {
121 		err = got_error(GOT_ERR_PRIVSEP_LEN);
122 		goto done;
123 	}
124 
125 	*packfd = imsg.fd;
126 done:
127 	imsg_free(&imsg);
128 	return err;
129 }
130 
131 static const struct got_error *
132 send_pack_file(int sendfd, int packfd, struct imsgbuf *ibuf)
133 {
134 	const struct got_error *err;
135 	unsigned char buf[8192];
136 	ssize_t r, w;
137 	off_t wtotal = 0;
138 
139 	if (lseek(packfd, 0L, SEEK_SET) == -1)
140 		return got_error_from_errno("lseek");
141 
142 	for (;;) {
143 		r = read(packfd, buf, sizeof(buf));
144 		if (r == -1)
145 			return got_error_from_errno("read");
146 		if (r == 0)
147 			break;
148 		w = write(sendfd, buf, r);
149 		if (w == -1)
150 			return got_error_from_errno("write");
151 		if (w != r)
152 			return got_error(GOT_ERR_IO);
153 		wtotal += w;
154 		err = send_upload_progress(ibuf, wtotal);
155 		if (err)
156 			return err;
157 	}
158 
159 	return NULL;
160 }
161 
162 static const struct got_error *
163 send_error(const char *buf, size_t len)
164 {
165 	static char msg[1024];
166 	size_t i;
167 
168 	for (i = 0; i < len && i < sizeof(msg) - 1; i++) {
169 		if (!isprint(buf[i]))
170 			return got_error_msg(GOT_ERR_BAD_PACKET,
171 			    "non-printable error message received from server");
172 		msg[i] = buf[i];
173 	}
174 	msg[i] = '\0';
175 	return got_error_msg(GOT_ERR_SEND_FAILED, msg);
176 }
177 
178 static const struct got_error *
179 send_their_ref(struct imsgbuf *ibuf, struct got_object_id *refid,
180     const char *refname)
181 {
182 	const struct got_error *err = NULL;
183 	struct ibuf *wbuf;
184 	size_t len, reflen = strlen(refname);
185 
186 	len = sizeof(struct got_imsg_send_remote_ref) + reflen;
187 	if (len >= MAX_IMSGSIZE - IMSG_HEADER_SIZE)
188 		return got_error(GOT_ERR_NO_SPACE);
189 
190 	wbuf = imsg_create(ibuf, GOT_IMSG_SEND_REMOTE_REF, 0, 0, len);
191 	if (wbuf == NULL)
192 		return got_error_from_errno("imsg_create SEND_REMOTE_REF");
193 
194 	/* Keep in sync with struct got_imsg_send_remote_ref definition! */
195 	if (imsg_add(wbuf, refid->sha1, SHA1_DIGEST_LENGTH) == -1) {
196 		err = got_error_from_errno("imsg_add SEND_REMOTE_REF");
197 		ibuf_free(wbuf);
198 		return err;
199 	}
200 	if (imsg_add(wbuf, &reflen, sizeof(reflen)) == -1) {
201 		err = got_error_from_errno("imsg_add SEND_REMOTE_REF");
202 		ibuf_free(wbuf);
203 		return err;
204 	}
205 	if (imsg_add(wbuf, refname, reflen) == -1) {
206 		err = got_error_from_errno("imsg_add SEND_REMOTE_REF");
207 		ibuf_free(wbuf);
208 		return err;
209 	}
210 
211 	wbuf->fd = -1;
212 	imsg_close(ibuf, wbuf);
213 	return got_privsep_flush_imsg(ibuf);
214 }
215 
216 static const struct got_error *
217 send_ref_status(struct imsgbuf *ibuf, const char *refname, int success,
218     struct got_pathlist_head *refs, struct got_pathlist_head *delete_refs)
219 
220 {
221 	const struct got_error *err = NULL;
222 	struct ibuf *wbuf;
223 	size_t len, reflen = strlen(refname);
224 	struct got_pathlist_entry *pe;
225 	int ref_valid = 0;
226 	char *eol;
227 
228 	eol = strchr(refname, '\n');
229 	if (eol == NULL) {
230 		return got_error_msg(GOT_ERR_BAD_PACKET,
231 		    "unexpected message from server");
232 	}
233 	*eol = '\0';
234 
235 	TAILQ_FOREACH(pe, refs, entry) {
236 		if (strcmp(refname, pe->path) == 0) {
237 			ref_valid = 1;
238 			break;
239 		}
240 	}
241 	if (!ref_valid) {
242 		TAILQ_FOREACH(pe, delete_refs, entry) {
243 			if (strcmp(refname, pe->path) == 0) {
244 				ref_valid = 1;
245 				break;
246 			}
247 		}
248 	}
249 	if (!ref_valid) {
250 		return got_error_msg(GOT_ERR_BAD_PACKET,
251 		    "unexpected message from server");
252 	}
253 
254 	len = sizeof(struct got_imsg_send_ref_status) + reflen;
255 	if (len >= MAX_IMSGSIZE - IMSG_HEADER_SIZE)
256 		return got_error(GOT_ERR_NO_SPACE);
257 
258 	wbuf = imsg_create(ibuf, GOT_IMSG_SEND_REF_STATUS,
259 	    0, 0, len);
260 	if (wbuf == NULL)
261 		return got_error_from_errno("imsg_create SEND_REF_STATUS");
262 
263 	/* Keep in sync with struct got_imsg_send_ref_status definition! */
264 	if (imsg_add(wbuf, &success, sizeof(success)) == -1) {
265 		err = got_error_from_errno("imsg_add SEND_REF_STATUS");
266 		ibuf_free(wbuf);
267 		return err;
268 	}
269 	if (imsg_add(wbuf, &reflen, sizeof(reflen)) == -1) {
270 		err = got_error_from_errno("imsg_add SEND_REF_STATUS");
271 		ibuf_free(wbuf);
272 		return err;
273 	}
274 	if (imsg_add(wbuf, refname, reflen) == -1) {
275 		err = got_error_from_errno("imsg_add SEND_REF_STATUS");
276 		ibuf_free(wbuf);
277 		return err;
278 	}
279 
280 	wbuf->fd = -1;
281 	imsg_close(ibuf, wbuf);
282 	return got_privsep_flush_imsg(ibuf);
283 }
284 
285 static const struct got_error *
286 describe_refchange(int *n, int *sent_my_capabilites,
287     const char *my_capabilities, char *buf, size_t bufsize,
288     const char *refname, const char *old_hashstr, const char *new_hashstr)
289 {
290 	*n = snprintf(buf, bufsize, "%s %s %s",
291 	    old_hashstr, new_hashstr, refname);
292 	if (*n >= bufsize)
293 		return got_error(GOT_ERR_NO_SPACE);
294 
295 	/*
296 	 * We must announce our capabilities along with the first
297 	 * reference. Unfortunately, the protocol requires an embedded
298 	 * NUL as a separator between reference name and capabilities,
299 	 * which we have to deal with here.
300 	 * It also requires a linefeed for terminating packet data.
301 	 */
302 	if (!*sent_my_capabilites && my_capabilities != NULL) {
303 		int m;
304 		if (*n >= bufsize - 1)
305 			return got_error(GOT_ERR_NO_SPACE);
306 		m = snprintf(buf + *n + 1, /* offset after '\0' */
307 		    bufsize - (*n + 1), "%s\n", my_capabilities);
308 		if (*n + m >= bufsize)
309 			return got_error(GOT_ERR_NO_SPACE);
310 		*n += m;
311 		*sent_my_capabilites = 1;
312 	} else {
313 		*n = strlcat(buf, "\n", bufsize);
314 		if (*n >= bufsize)
315 			return got_error(GOT_ERR_NO_SPACE);
316 	}
317 
318 	return NULL;
319 }
320 
321 static const struct got_error *
322 send_pack(int fd, struct got_pathlist_head *refs,
323     struct got_pathlist_head *delete_refs, struct imsgbuf *ibuf)
324 {
325 	const struct got_error *err = NULL;
326 	char buf[GOT_PKT_MAX];
327 	unsigned char zero_id[SHA1_DIGEST_LENGTH] = { 0 };
328 	char old_hashstr[SHA1_DIGEST_STRING_LENGTH];
329 	char new_hashstr[SHA1_DIGEST_STRING_LENGTH];
330 	struct got_pathlist_head their_refs;
331 	int is_firstpkt = 1;
332 	int n, nsent = 0;
333 	int packfd = -1;
334 	char *id_str = NULL, *refname = NULL;
335 	struct got_object_id *id = NULL;
336 	char *server_capabilities = NULL, *my_capabilities = NULL;
337 	struct got_pathlist_entry *pe;
338 	int sent_my_capabilites = 0;
339 
340 	TAILQ_INIT(&their_refs);
341 
342 	if (TAILQ_EMPTY(refs) && TAILQ_EMPTY(delete_refs))
343 		return got_error(GOT_ERR_SEND_EMPTY);
344 
345 	while (1) {
346 		err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
347 		if (err)
348 			goto done;
349 		if (n == 0)
350 			break;
351 		if (n >= 4 && strncmp(buf, "ERR ", 4) == 0) {
352 			err = send_error(&buf[4], n - 4);
353 			goto done;
354 		}
355 		err = got_gitproto_parse_refline(&id_str, &refname,
356 		    &server_capabilities, buf, n);
357 		if (err)
358 			goto done;
359 		if (is_firstpkt) {
360 			if (chattygot && server_capabilities[0] != '\0')
361 				fprintf(stderr, "%s: server capabilities: %s\n",
362 				    getprogname(), server_capabilities);
363 			err = got_gitproto_match_capabilities(&my_capabilities,
364 			    NULL, server_capabilities, got_capabilities,
365 			    nitems(got_capabilities));
366 			if (err)
367 				goto done;
368 			if (chattygot)
369 				fprintf(stderr, "%s: my capabilities:%s\n",
370 				    getprogname(), my_capabilities);
371 			is_firstpkt = 0;
372 		}
373 		if (strstr(refname, "^{}")) {
374 			if (chattygot) {
375 				fprintf(stderr, "%s: ignoring %s\n",
376 				    getprogname(), refname);
377 			}
378 			continue;
379 		}
380 
381 		id = malloc(sizeof(*id));
382 		if (id == NULL) {
383 			err = got_error_from_errno("malloc");
384 			goto done;
385 		}
386 		if (!got_parse_sha1_digest(id->sha1, id_str)) {
387 			err = got_error(GOT_ERR_BAD_OBJ_ID_STR);
388 			goto done;
389 		}
390 		err = send_their_ref(ibuf, id, refname);
391 		if (err)
392 			goto done;
393 
394 		err = got_pathlist_append(&their_refs, refname, id);
395 		if (chattygot)
396 			fprintf(stderr, "%s: remote has %s %s\n",
397 			    getprogname(), refname, id_str);
398 		free(id_str);
399 		id_str = NULL;
400 		refname = NULL; /* do not free; owned by their_refs */
401 		id = NULL; /* do not free; owned by their_refs */
402 	}
403 
404 	if (!TAILQ_EMPTY(delete_refs)) {
405 		if (my_capabilities == NULL ||
406 		    strstr(my_capabilities, GOT_CAPA_DELETE_REFS) == NULL) {
407 			err = got_error(GOT_ERR_CAPA_DELETE_REFS);
408 			goto done;
409 		}
410 	}
411 
412 	TAILQ_FOREACH(pe, delete_refs, entry) {
413 		const char *refname = pe->path;
414 		struct got_pathlist_entry *their_pe;
415 		struct got_object_id *their_id = NULL;
416 
417 		TAILQ_FOREACH(their_pe, &their_refs, entry) {
418 			const char *their_refname = their_pe->path;
419 			if (got_path_cmp(refname, their_refname,
420 			    strlen(refname), strlen(their_refname)) == 0) {
421 				their_id = their_pe->data;
422 				break;
423 			}
424 		}
425 		if (their_id == NULL) {
426 			err = got_error_fmt(GOT_ERR_NOT_REF,
427 			    "%s does not exist in remote repository",
428 			    refname);
429 			goto done;
430 		}
431 
432 		got_sha1_digest_to_str(their_id->sha1, old_hashstr,
433 		    sizeof(old_hashstr));
434 		got_sha1_digest_to_str(zero_id, new_hashstr,
435 		    sizeof(new_hashstr));
436 		err = describe_refchange(&n, &sent_my_capabilites,
437 		    my_capabilities, buf, sizeof(buf), refname,
438 		    old_hashstr, new_hashstr);
439 		if (err)
440 			goto done;
441 		err = got_pkt_writepkt(fd, buf, n, chattygot);
442 		if (err)
443 			goto done;
444 		if (chattygot) {
445 			fprintf(stderr, "%s: deleting %s %s\n",
446 			    getprogname(), refname, old_hashstr);
447 		}
448 		nsent++;
449 	}
450 
451 	TAILQ_FOREACH(pe, refs, entry) {
452 		const char *refname = pe->path;
453 		struct got_object_id *id = pe->data;
454 		struct got_object_id *their_id = NULL;
455 		struct got_pathlist_entry *their_pe;
456 
457 		TAILQ_FOREACH(their_pe, &their_refs, entry) {
458 			const char *their_refname = their_pe->path;
459 			if (got_path_cmp(refname, their_refname,
460 			    strlen(refname), strlen(their_refname)) == 0) {
461 				their_id = their_pe->data;
462 				break;
463 			}
464 		}
465 		if (their_id) {
466 			if (got_object_id_cmp(id, their_id) == 0) {
467 				if (chattygot) {
468 					fprintf(stderr,
469 					    "%s: no change for %s\n",
470 					    getprogname(), refname);
471 				}
472 				continue;
473 			}
474 			got_sha1_digest_to_str(their_id->sha1, old_hashstr,
475 			    sizeof(old_hashstr));
476 		} else {
477 			got_sha1_digest_to_str(zero_id, old_hashstr,
478 			    sizeof(old_hashstr));
479 		}
480 		got_sha1_digest_to_str(id->sha1, new_hashstr,
481 		    sizeof(new_hashstr));
482 		err = describe_refchange(&n, &sent_my_capabilites,
483 		    my_capabilities, buf, sizeof(buf), refname,
484 		    old_hashstr, new_hashstr);
485 		if (err)
486 			goto done;
487 		err = got_pkt_writepkt(fd, buf, n, chattygot);
488 		if (err)
489 			goto done;
490 		if (chattygot) {
491 			if (their_id) {
492 				fprintf(stderr, "%s: updating %s %s -> %s\n",
493 				    getprogname(), refname, old_hashstr,
494 				    new_hashstr);
495 			} else {
496 				fprintf(stderr, "%s: creating %s %s\n",
497 				    getprogname(), refname, new_hashstr);
498 			}
499 		}
500 		nsent++;
501 	}
502 	err = got_pkt_flushpkt(fd, chattygot);
503 	if (err)
504 		goto done;
505 
506 	err = send_pack_request(ibuf);
507 	if (err)
508 		goto done;
509 
510 	err = recv_packfd(&packfd, ibuf);
511 	if (err)
512 		goto done;
513 
514 	if (packfd != -1) {
515 		err = send_pack_file(fd, packfd, ibuf);
516 		if (err)
517 			goto done;
518 	}
519 
520 	err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
521 	if (err)
522 		goto done;
523 	if (n >= 4 && strncmp(buf, "ERR ", 4) == 0) {
524 		err = send_error(&buf[4], n - 4);
525 		goto done;
526 	} else if (n < 10 || strncmp(buf, "unpack ok\n", 10) != 0) {
527 		err = got_error_msg(GOT_ERR_BAD_PACKET,
528 		    "unexpected message from server");
529 		goto done;
530 	}
531 
532 	while (nsent > 0) {
533 		err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
534 		if (err)
535 			goto done;
536 		if (n < 3) {
537 			err = got_error_msg(GOT_ERR_BAD_PACKET,
538 			    "unexpected message from server");
539 			goto done;
540 		} else if (strncmp(buf, "ok ", 3) == 0) {
541 			err = send_ref_status(ibuf, buf + 3, 1,
542 			    refs, delete_refs);
543 			if (err)
544 				goto done;
545 		} else if (strncmp(buf, "ng ", 3) == 0) {
546 			err = send_ref_status(ibuf, buf + 3, 0,
547 			    refs, delete_refs);
548 			if (err)
549 				goto done;
550 		} else {
551 			err = got_error_msg(GOT_ERR_BAD_PACKET,
552 			    "unexpected message from server");
553 			goto done;
554 		}
555 		nsent--;
556 	}
557 
558 	err = send_done(ibuf);
559 done:
560 	TAILQ_FOREACH(pe, &their_refs, entry) {
561 		free((void *)pe->path);
562 		free(pe->data);
563 	}
564 	got_pathlist_free(&their_refs);
565 	free(id_str);
566 	free(id);
567 	free(refname);
568 	free(server_capabilities);
569 	return err;
570 }
571 
572 int
573 main(int argc, char **argv)
574 {
575 	const struct got_error *err = NULL;
576 	int sendfd, i;
577 	struct imsgbuf ibuf;
578 	struct imsg imsg;
579 	struct got_pathlist_head refs;
580 	struct got_pathlist_head delete_refs;
581 	struct got_pathlist_entry *pe;
582 	struct got_imsg_send_request send_req;
583 	struct got_imsg_send_ref href;
584 	size_t datalen;
585 #if 0
586 	static int attached;
587 	while (!attached)
588 		sleep (1);
589 #endif
590 
591 	TAILQ_INIT(&refs);
592 	TAILQ_INIT(&delete_refs);
593 
594 	imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
595 #ifndef PROFILE
596 	/* revoke access to most system calls */
597 	if (pledge("stdio recvfd", NULL) == -1) {
598 		err = got_error_from_errno("pledge");
599 		got_privsep_send_error(&ibuf, err);
600 		return 1;
601 	}
602 #endif
603 	if ((err = got_privsep_recv_imsg(&imsg, &ibuf, 0)) != 0) {
604 		if (err->code == GOT_ERR_PRIVSEP_PIPE)
605 			err = NULL;
606 		goto done;
607 	}
608 	if (imsg.hdr.type == GOT_IMSG_STOP)
609 		goto done;
610 	if (imsg.hdr.type != GOT_IMSG_SEND_REQUEST) {
611 		err = got_error(GOT_ERR_PRIVSEP_MSG);
612 		goto done;
613 	}
614 	datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
615 	if (datalen < sizeof(send_req)) {
616 		err = got_error(GOT_ERR_PRIVSEP_LEN);
617 		goto done;
618 	}
619 	memcpy(&send_req, imsg.data, sizeof(send_req));
620 	sendfd = imsg.fd;
621 	imsg_free(&imsg);
622 
623 	if (send_req.verbosity > 0)
624 		chattygot += send_req.verbosity;
625 
626 	for (i = 0; i < send_req.nrefs; i++) {
627 		struct got_object_id *id;
628 		char *refname;
629 
630 		if ((err = got_privsep_recv_imsg(&imsg, &ibuf, 0)) != 0) {
631 			if (err->code == GOT_ERR_PRIVSEP_PIPE)
632 				err = NULL;
633 			goto done;
634 		}
635 		if (imsg.hdr.type == GOT_IMSG_STOP)
636 			goto done;
637 		if (imsg.hdr.type != GOT_IMSG_SEND_REF) {
638 			err = got_error(GOT_ERR_PRIVSEP_MSG);
639 			goto done;
640 		}
641 		datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
642 		if (datalen < sizeof(href)) {
643 			err = got_error(GOT_ERR_PRIVSEP_LEN);
644 			goto done;
645 		}
646 		memcpy(&href, imsg.data, sizeof(href));
647 		if (datalen - sizeof(href) < href.name_len) {
648 			err = got_error(GOT_ERR_PRIVSEP_LEN);
649 			goto done;
650 		}
651 		refname = malloc(href.name_len + 1);
652 		if (refname == NULL) {
653 			err = got_error_from_errno("malloc");
654 			goto done;
655 		}
656 		memcpy(refname, imsg.data + sizeof(href), href.name_len);
657 		refname[href.name_len] = '\0';
658 
659 		/*
660 		 * Prevent sending of references that won't make any
661 		 * sense outside the local repository's context.
662 		 */
663 		if (strncmp(refname, "refs/got/", 9) == 0 ||
664 		    strncmp(refname, "refs/remotes/", 13) == 0) {
665 			err = got_error_fmt(GOT_ERR_SEND_BAD_REF,
666 			    "%s", refname);
667 			goto done;
668 		}
669 
670 		id = malloc(sizeof(*id));
671 		if (id == NULL) {
672 			free(refname);
673 			err = got_error_from_errno("malloc");
674 			goto done;
675 		}
676 		memcpy(id->sha1, href.id, SHA1_DIGEST_LENGTH);
677 		if (href.delete)
678 			err = got_pathlist_append(&delete_refs, refname, id);
679 		else
680 			err = got_pathlist_append(&refs, refname, id);
681 		if (err) {
682 			free(refname);
683 			free(id);
684 			goto done;
685 		}
686 
687 		imsg_free(&imsg);
688 	}
689 
690 	err = send_pack(sendfd, &refs, &delete_refs, &ibuf);
691 done:
692 	TAILQ_FOREACH(pe, &refs, entry) {
693 		free((char *)pe->path);
694 		free(pe->data);
695 	}
696 	got_pathlist_free(&refs);
697 	TAILQ_FOREACH(pe, &delete_refs, entry) {
698 		free((char *)pe->path);
699 		free(pe->data);
700 	}
701 	got_pathlist_free(&delete_refs);
702 	if (sendfd != -1 && close(sendfd) == -1 && err == NULL)
703 		err = got_error_from_errno("close");
704 	if (err != NULL && err->code != GOT_ERR_CANCELLED)  {
705 		fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
706 		got_privsep_send_error(&ibuf, err);
707 	}
708 
709 	exit(0);
710 }