2 * Copyright (c) 2019 Ori Bernstein <ori@openbsd.org>
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.
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.
17 #include <sys/types.h>
18 #include <sys/queue.h>
38 #include "got_error.h"
39 #include "got_object.h"
41 #include "got_version.h"
42 #include "got_fetch.h"
43 #include "got_reference.h"
45 #include "got_lib_sha1.h"
46 #include "got_lib_delta.h"
47 #include "got_lib_object.h"
48 #include "got_lib_object_parse.h"
49 #include "got_lib_privsep.h"
50 #include "got_lib_pack.h"
51 #include "got_lib_pkt.h"
52 #include "got_lib_gitproto.h"
53 #include "got_lib_ratelimit.h"
56 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
60 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
63 struct got_object *indexed;
66 static const struct got_capability got_capabilities[] = {
67 { GOT_CAPA_AGENT, "got/" GOT_VERSION_STR },
68 { GOT_CAPA_OFS_DELTA, NULL },
69 { GOT_CAPA_SIDE_BAND_64K, NULL },
73 match_remote_ref(struct got_pathlist_head *have_refs,
74 struct got_object_id *my_id, const char *refname)
76 struct got_pathlist_entry *pe;
78 /* XXX zero-hash signifies we don't have this ref;
79 * we should use a flag instead */
80 memset(my_id, 0, sizeof(*my_id));
82 TAILQ_FOREACH(pe, have_refs, entry) {
83 struct got_object_id *id = pe->data;
84 if (strcmp(pe->path, refname) == 0) {
85 memcpy(my_id, id, sizeof(*my_id));
92 match_branch(const char *branch, const char *wanted_branch)
94 if (strncmp(branch, "refs/heads/", 11) != 0)
97 if (strncmp(wanted_branch, "refs/heads/", 11) == 0)
100 return (strcmp(branch + 11, wanted_branch) == 0);
104 match_wanted_ref(const char *refname, const char *wanted_ref)
106 if (strncmp(refname, "refs/", 5) != 0)
111 * Prevent fetching of references that won't make any
112 * sense outside of the remote repository's context.
114 if (strncmp(refname, "got/", 4) == 0)
116 if (strncmp(refname, "remotes/", 8) == 0)
119 if (strncmp(wanted_ref, "refs/", 5) == 0)
122 /* Allow prefix match. */
123 if (got_path_is_child(refname, wanted_ref, strlen(wanted_ref)))
126 /* Allow exact match. */
127 return (strcmp(refname, wanted_ref) == 0);
130 static const struct got_error *
131 send_fetch_server_progress(struct imsgbuf *ibuf, const char *msg, size_t msglen)
133 if (msglen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
134 return got_error(GOT_ERR_NO_SPACE);
139 if (imsg_compose(ibuf, GOT_IMSG_FETCH_SERVER_PROGRESS, 0, 0, -1,
141 return got_error_from_errno(
142 "imsg_compose FETCH_SERVER_PROGRESS");
144 return got_privsep_flush_imsg(ibuf);
147 static const struct got_error *
148 send_fetch_download_progress(struct imsgbuf *ibuf, off_t bytes,
149 struct got_ratelimit *rl)
151 const struct got_error *err;
155 err = got_ratelimit_check(&elapsed, rl);
160 if (imsg_compose(ibuf, GOT_IMSG_FETCH_DOWNLOAD_PROGRESS, 0, 0, -1,
161 &bytes, sizeof(bytes)) == -1)
162 return got_error_from_errno(
163 "imsg_compose FETCH_DOWNLOAD_PROGRESS");
165 return got_privsep_flush_imsg(ibuf);
168 static const struct got_error *
169 send_fetch_done(struct imsgbuf *ibuf, uint8_t *pack_sha1)
171 if (imsg_compose(ibuf, GOT_IMSG_FETCH_DONE, 0, 0, -1,
172 pack_sha1, SHA1_DIGEST_LENGTH) == -1)
173 return got_error_from_errno("imsg_compose FETCH");
174 return got_privsep_flush_imsg(ibuf);
177 static const struct got_error *
178 fetch_progress(struct imsgbuf *ibuf, const char *buf, size_t len)
186 * Truncate messages which exceed the maximum imsg payload size.
187 * Server may send up to 64k.
189 if (len > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
190 len = MAX_IMSGSIZE - IMSG_HEADER_SIZE;
192 /* Only allow printable ASCII. */
193 for (i = 0; i < len; i++) {
194 if (isprint((unsigned char)buf[i]) ||
195 isspace((unsigned char)buf[i]))
197 return got_error_msg(GOT_ERR_BAD_PACKET,
198 "non-printable progress message received from server");
201 return send_fetch_server_progress(ibuf, buf, len);
204 static const struct got_error *
205 fetch_error(const char *buf, size_t len)
207 static char msg[1024];
210 for (i = 0; i < len && i < sizeof(msg) - 1; i++) {
211 if (!isprint((unsigned char)buf[i]))
212 return got_error_msg(GOT_ERR_BAD_PACKET,
213 "non-printable error message received from server");
217 return got_error_msg(GOT_ERR_FETCH_FAILED, msg);
220 static const struct got_error *
221 send_fetch_symrefs(struct imsgbuf *ibuf, struct got_pathlist_head *symrefs)
224 size_t len, nsymrefs = 0;
225 struct got_pathlist_entry *pe;
227 len = sizeof(struct got_imsg_fetch_symrefs);
228 TAILQ_FOREACH(pe, symrefs, entry) {
229 const char *target = pe->data;
230 len += sizeof(struct got_imsg_fetch_symref) +
231 pe->path_len + strlen(target);
235 if (len >= MAX_IMSGSIZE - IMSG_HEADER_SIZE)
236 return got_error(GOT_ERR_NO_SPACE);
238 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_SYMREFS, 0, 0, len);
240 return got_error_from_errno("imsg_create FETCH_SYMREFS");
242 /* Keep in sync with struct got_imsg_fetch_symrefs definition! */
243 if (imsg_add(wbuf, &nsymrefs, sizeof(nsymrefs)) == -1)
244 return got_error_from_errno("imsg_add FETCH_SYMREFS");
246 TAILQ_FOREACH(pe, symrefs, entry) {
247 const char *name = pe->path;
248 size_t name_len = pe->path_len;
249 const char *target = pe->data;
250 size_t target_len = strlen(target);
252 /* Keep in sync with struct got_imsg_fetch_symref definition! */
253 if (imsg_add(wbuf, &name_len, sizeof(name_len)) == -1)
254 return got_error_from_errno("imsg_add FETCH_SYMREFS");
255 if (imsg_add(wbuf, &target_len, sizeof(target_len)) == -1)
256 return got_error_from_errno("imsg_add FETCH_SYMREFS");
257 if (imsg_add(wbuf, name, name_len) == -1)
258 return got_error_from_errno("imsg_add FETCH_SYMREFS");
259 if (imsg_add(wbuf, target, target_len) == -1)
260 return got_error_from_errno("imsg_add FETCH_SYMREFS");
264 imsg_close(ibuf, wbuf);
265 return got_privsep_flush_imsg(ibuf);
268 static const struct got_error *
269 send_fetch_ref(struct imsgbuf *ibuf, struct got_object_id *refid,
273 size_t len, reflen = strlen(refname);
275 len = sizeof(struct got_imsg_fetch_ref) + reflen;
276 if (len >= MAX_IMSGSIZE - IMSG_HEADER_SIZE)
277 return got_error(GOT_ERR_NO_SPACE);
279 wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_REF, 0, 0, len);
281 return got_error_from_errno("imsg_create FETCH_REF");
283 /* Keep in sync with struct got_imsg_fetch_ref definition! */
284 if (imsg_add(wbuf, refid, sizeof(*refid)) == -1)
285 return got_error_from_errno("imsg_add FETCH_REF");
286 if (imsg_add(wbuf, refname, reflen) == -1)
287 return got_error_from_errno("imsg_add FETCH_REF");
290 imsg_close(ibuf, wbuf);
291 return got_privsep_flush_imsg(ibuf);
294 static const struct got_error *
295 fetch_ref(struct imsgbuf *ibuf, struct got_pathlist_head *have_refs,
296 struct got_object_id *have, struct got_object_id *want,
297 const char *refname, const char *id_str)
299 const struct got_error *err;
300 char *theirs = NULL, *mine = NULL;
302 if (!got_parse_sha1_digest(want->sha1, id_str)) {
303 err = got_error(GOT_ERR_BAD_OBJ_ID_STR);
307 match_remote_ref(have_refs, have, refname);
308 err = send_fetch_ref(ibuf, want, refname);
313 fprintf(stderr, "%s: %s will be fetched\n",
314 getprogname(), refname);
316 err = got_object_id_str(&theirs, want);
319 err = got_object_id_str(&mine, have);
322 fprintf(stderr, "%s: remote: %s\n%s: local: %s\n",
323 getprogname(), theirs, getprogname(), mine);
331 static const struct got_error *
332 fetch_pack(int fd, int packfd, uint8_t *pack_sha1,
333 struct got_pathlist_head *have_refs, int fetch_all_branches,
334 struct got_pathlist_head *wanted_branches,
335 struct got_pathlist_head *wanted_refs, int list_refs_only,
336 const char *worktree_branch, int no_head, struct imsgbuf *ibuf)
338 const struct got_error *err = NULL;
339 char buf[GOT_PKT_MAX];
340 char hashstr[SHA1_DIGEST_STRING_LENGTH];
341 struct got_object_id *have, *want;
342 int is_firstpkt = 1, nref = 0, refsz = 16;
343 int i, n, nwant = 0, nhave = 0, acked = 0;
344 off_t packsz = 0, last_reported_packsz = 0;
345 char *id_str = NULL, *refname = NULL;
346 char *server_capabilities = NULL, *my_capabilities = NULL;
347 const char *default_branch = NULL;
348 struct got_pathlist_head symrefs;
349 struct got_pathlist_entry *pe;
350 int sent_my_capabilites = 0, have_sidebands = 0;
352 uint8_t sha1_buf[SHA1_DIGEST_LENGTH];
353 size_t sha1_buf_len = 0;
355 struct got_ratelimit rl;
357 TAILQ_INIT(&symrefs);
359 got_ratelimit_init(&rl, 0, 500);
361 have = malloc(refsz * sizeof(have[0]));
363 return got_error_from_errno("malloc");
364 want = malloc(refsz * sizeof(want[0]));
366 err = got_error_from_errno("malloc");
370 err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
375 if (n >= 4 && strncmp(buf, "ERR ", 4) == 0) {
376 err = fetch_error(&buf[4], n - 4);
381 err = got_gitproto_parse_refline(&id_str, &refname,
382 &server_capabilities, buf, n);
386 if (refsz == nref + 1) {
387 struct got_object_id *h, *w;
390 h = reallocarray(have, refsz, sizeof(have[0]));
392 err = got_error_from_errno("reallocarray");
396 w = reallocarray(want, refsz, sizeof(want[0]));
398 err = got_error_from_errno("reallocarray");
405 if (chattygot && server_capabilities[0] != '\0')
406 fprintf(stderr, "%s: server capabilities: %s\n",
407 getprogname(), server_capabilities);
408 err = got_gitproto_match_capabilities(&my_capabilities,
409 &symrefs, server_capabilities,
410 got_capabilities, nitems(got_capabilities));
414 fprintf(stderr, "%s: my capabilities:%s\n",
415 getprogname(), my_capabilities != NULL ?
416 my_capabilities : "");
417 err = send_fetch_symrefs(ibuf, &symrefs);
421 if (!fetch_all_branches) {
422 TAILQ_FOREACH(pe, &symrefs, entry) {
423 const char *name = pe->path;
424 const char *symref_target = pe->data;
425 if (strcmp(name, GOT_REF_HEAD) != 0)
427 default_branch = symref_target;
434 if (strstr(refname, "^{}")) {
436 fprintf(stderr, "%s: ignoring %s\n",
437 getprogname(), refname);
442 /* always fetch remote HEAD unless -b was specified */
443 if (!no_head && default_branch &&
444 strcmp(refname, default_branch) == 0 &&
445 strncmp(default_branch, "refs/heads/", 11) == 0) {
446 err = fetch_ref(ibuf, have_refs, &have[nref],
447 &want[nref], default_branch, id_str);
454 if (list_refs_only || strncmp(refname, "refs/tags/", 10) == 0) {
455 err = fetch_ref(ibuf, have_refs, &have[nref],
456 &want[nref], refname, id_str);
460 } else if (strncmp(refname, "refs/heads/", 11) == 0) {
461 if (fetch_all_branches) {
462 err = fetch_ref(ibuf, have_refs, &have[nref],
463 &want[nref], refname, id_str);
469 TAILQ_FOREACH(pe, wanted_branches, entry) {
470 if (match_branch(refname, pe->path))
473 if (pe != NULL || (worktree_branch != NULL &&
474 match_branch(refname, worktree_branch))) {
475 err = fetch_ref(ibuf, have_refs, &have[nref],
476 &want[nref], refname, id_str);
480 } else if (chattygot) {
481 fprintf(stderr, "%s: ignoring %s\n",
482 getprogname(), refname);
485 TAILQ_FOREACH(pe, wanted_refs, entry) {
486 if (match_wanted_ref(refname, pe->path))
490 err = fetch_ref(ibuf, have_refs, &have[nref],
491 &want[nref], refname, id_str);
495 } else if (chattygot) {
496 fprintf(stderr, "%s: ignoring %s\n",
497 getprogname(), refname);
505 /* Abort if we haven't found anything to fetch. */
507 struct got_pathlist_entry *pe;
508 static char msg[PATH_MAX + 33];
510 pe = TAILQ_FIRST(wanted_branches);
512 snprintf(msg, sizeof(msg),
513 "branch \"%s\" not found on server", pe->path);
514 err = got_error_msg(GOT_ERR_FETCH_NO_BRANCH, msg);
518 pe = TAILQ_FIRST(wanted_refs);
520 snprintf(msg, sizeof(msg),
521 "reference \"%s\" not found on server", pe->path);
522 err = got_error_msg(GOT_ERR_FETCH_NO_BRANCH, msg);
526 err = got_error(GOT_ERR_FETCH_NO_BRANCH);
530 for (i = 0; i < nref; i++) {
531 if (got_object_id_cmp(&have[i], &want[i]) == 0)
533 got_sha1_digest_to_str(want[i].sha1, hashstr, sizeof(hashstr));
534 n = snprintf(buf, sizeof(buf), "want %s%s\n", hashstr,
535 sent_my_capabilites || my_capabilities == NULL ?
536 "" : my_capabilities);
537 if (n < 0 || (size_t)n >= sizeof(buf)) {
538 err = got_error(GOT_ERR_NO_SPACE);
541 err = got_pkt_writepkt(fd, buf, n, chattygot);
544 sent_my_capabilites = 1;
547 err = got_pkt_flushpkt(fd, chattygot);
554 TAILQ_FOREACH(pe, have_refs, entry) {
555 struct got_object_id *id = pe->data;
556 got_sha1_digest_to_str(id->sha1, hashstr, sizeof(hashstr));
557 n = snprintf(buf, sizeof(buf), "have %s\n", hashstr);
558 if (n < 0 || (size_t)n >= sizeof(buf)) {
559 err = got_error(GOT_ERR_NO_SPACE);
562 err = got_pkt_writepkt(fd, buf, n, chattygot);
568 while (nhave > 0 && !acked) {
569 struct got_object_id common_id;
571 /* The server should ACK the object IDs we need. */
572 err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
575 if (n >= 4 && strncmp(buf, "ERR ", 4) == 0) {
576 err = fetch_error(&buf[4], n - 4);
579 if (n >= 4 && strncmp(buf, "NAK\n", 4) == 0) {
580 /* Server has not located our objects yet. */
583 if (n < 4 + SHA1_DIGEST_STRING_LENGTH ||
584 strncmp(buf, "ACK ", 4) != 0) {
585 err = got_error_msg(GOT_ERR_BAD_PACKET,
586 "unexpected message from server");
589 if (!got_parse_sha1_digest(common_id.sha1, buf + 4)) {
590 err = got_error_msg(GOT_ERR_BAD_PACKET,
591 "bad object ID in ACK packet from server");
597 n = strlcpy(buf, "done\n", sizeof(buf));
598 err = got_pkt_writepkt(fd, buf, n, chattygot);
603 err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
606 if (n != 4 || strncmp(buf, "NAK\n", n) != 0) {
607 err = got_error_msg(GOT_ERR_BAD_PACKET,
608 "unexpected message from server");
614 fprintf(stderr, "%s: fetching...\n", getprogname());
616 if (my_capabilities != NULL &&
617 strstr(my_capabilities, GOT_CAPA_SIDE_BAND_64K) != NULL)
624 if (have_sidebands) {
625 err = got_pkt_readhdr(&datalen, fd, chattygot);
631 /* Read sideband channel ID (one byte). */
632 r = read(fd, buf, 1);
634 err = got_error_from_errno("read");
638 err = got_error_msg(GOT_ERR_BAD_PACKET,
642 if (datalen > sizeof(buf) - 5) {
643 err = got_error_msg(GOT_ERR_BAD_PACKET,
644 "bad packet length");
647 datalen--; /* sideband ID has been read */
648 if (buf[0] == GOT_SIDEBAND_PACKFILE_DATA) {
649 /* Read packfile data. */
650 err = got_pkt_readn(&r, fd, buf, datalen);
654 err = got_error_msg(GOT_ERR_BAD_PACKET,
658 } else if (buf[0] == GOT_SIDEBAND_PROGRESS_INFO) {
659 err = got_pkt_readn(&r, fd, buf, datalen);
663 err = got_error_msg(GOT_ERR_BAD_PACKET,
667 err = fetch_progress(ibuf, buf, r);
671 } else if (buf[0] == GOT_SIDEBAND_ERROR_INFO) {
672 err = got_pkt_readn(&r, fd, buf, datalen);
676 err = got_error_msg(GOT_ERR_BAD_PACKET,
680 err = fetch_error(buf, r);
682 } else if (buf[0] == 'A') {
683 err = got_pkt_readn(&r, fd, buf, datalen);
687 err = got_error_msg(GOT_ERR_BAD_PACKET,
692 * Git server responds with ACK after 'done'
693 * even though multi_ack is disabled?!?
696 if (strncmp(buf, "CK ", 3) == 0)
697 continue; /* ignore */
698 err = got_error_msg(GOT_ERR_BAD_PACKET,
699 "unexpected message from server");
702 err = got_error_msg(GOT_ERR_BAD_PACKET,
703 "unknown side-band received from server");
707 /* No sideband channel. Every byte is packfile data. */
708 err = got_pkt_readn(&r, fd, buf, sizeof buf);
716 * An expected SHA1 checksum sits at the end of the pack file.
717 * Since we don't know the file size ahead of time we have to
718 * keep SHA1_DIGEST_LENGTH bytes buffered and avoid mixing
719 * those bytes into our SHA1 checksum computation until we
720 * know for sure that additional pack file data bytes follow.
722 * We can assume r > 0 since otherwise the loop would exit.
724 if (r < SHA1_DIGEST_LENGTH) {
725 if (sha1_buf_len < SHA1_DIGEST_LENGTH) {
727 * If there's enough buffered + read data to
728 * fill up the buffer then shift a sufficient
729 * amount of bytes out at the front to make
730 * room, mixing those bytes into the checksum.
732 if (sha1_buf_len > 0 &&
733 sha1_buf_len + r > SHA1_DIGEST_LENGTH) {
734 size_t nshift = MIN(sha1_buf_len + r -
735 SHA1_DIGEST_LENGTH, sha1_buf_len);
736 SHA1Update(&sha1_ctx, sha1_buf, nshift);
737 memmove(sha1_buf, sha1_buf + nshift,
738 sha1_buf_len - nshift);
739 sha1_buf_len -= nshift;
742 /* Buffer potential checksum bytes. */
743 memcpy(sha1_buf + sha1_buf_len, buf, r);
747 * Mix in previously buffered bytes which
748 * are not part of the checksum after all.
750 SHA1Update(&sha1_ctx, sha1_buf, r);
752 /* Update potential checksum buffer. */
753 memmove(sha1_buf, sha1_buf + r,
755 memcpy(sha1_buf + sha1_buf_len - r, buf, r);
758 /* Mix in any previously buffered bytes. */
759 SHA1Update(&sha1_ctx, sha1_buf, sha1_buf_len);
761 /* Mix in bytes read minus potential checksum bytes. */
762 SHA1Update(&sha1_ctx, buf, r - SHA1_DIGEST_LENGTH);
764 /* Buffer potential checksum bytes. */
765 memcpy(sha1_buf, buf + r - SHA1_DIGEST_LENGTH,
767 sha1_buf_len = SHA1_DIGEST_LENGTH;
770 /* Write packfile data to temporary pack file. */
771 w = write(packfd, buf, r);
773 err = got_error_from_errno("write");
777 err = got_error(GOT_ERR_IO);
782 /* Don't send too many progress privsep messages. */
783 if (packsz > last_reported_packsz + 1024) {
784 err = send_fetch_download_progress(ibuf, packsz, &rl);
787 last_reported_packsz = packsz;
790 err = send_fetch_download_progress(ibuf, packsz, NULL);
794 SHA1Final(pack_sha1, &sha1_ctx);
795 if (sha1_buf_len != SHA1_DIGEST_LENGTH ||
796 memcmp(pack_sha1, sha1_buf, sha1_buf_len) != 0) {
797 err = got_error_msg(GOT_ERR_BAD_PACKFILE,
798 "pack file checksum mismatch");
801 got_pathlist_free(&symrefs, GOT_PATHLIST_FREE_ALL);
806 free(server_capabilities);
812 main(int argc, char **argv)
814 const struct got_error *err = NULL;
815 int fetchfd = -1, packfd = -1;
816 uint8_t pack_sha1[SHA1_DIGEST_LENGTH];
819 struct got_pathlist_head have_refs;
820 struct got_pathlist_head wanted_branches;
821 struct got_pathlist_head wanted_refs;
822 struct got_imsg_fetch_request fetch_req;
823 struct got_imsg_fetch_have_ref href;
824 struct got_imsg_fetch_wanted_branch wbranch;
825 struct got_imsg_fetch_wanted_ref wref;
827 char *worktree_branch = NULL;
834 TAILQ_INIT(&have_refs);
835 TAILQ_INIT(&wanted_branches);
836 TAILQ_INIT(&wanted_refs);
838 imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
840 /* revoke access to most system calls */
841 if (pledge("stdio recvfd", NULL) == -1) {
842 err = got_error_from_errno("pledge");
843 got_privsep_send_error(&ibuf, err);
847 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
849 if (err->code == GOT_ERR_PRIVSEP_PIPE)
853 if (imsg.hdr.type == GOT_IMSG_STOP)
855 if (imsg.hdr.type != GOT_IMSG_FETCH_REQUEST) {
856 err = got_error(GOT_ERR_PRIVSEP_MSG);
859 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
860 if (datalen < sizeof(fetch_req)) {
861 err = got_error(GOT_ERR_PRIVSEP_LEN);
864 memcpy(&fetch_req, imsg.data, sizeof(fetch_req));
867 if (datalen != sizeof(fetch_req) +
868 fetch_req.worktree_branch_len) {
869 err = got_error(GOT_ERR_PRIVSEP_LEN);
873 if (fetch_req.worktree_branch_len != 0) {
874 worktree_branch = strndup(imsg.data +
875 sizeof(fetch_req), fetch_req.worktree_branch_len);
876 if (worktree_branch == NULL) {
877 err = got_error_from_errno("strndup");
884 if (fetch_req.verbosity > 0)
885 chattygot += fetch_req.verbosity;
887 for (i = 0; i < fetch_req.n_have_refs; i++) {
888 struct got_object_id *id;
891 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
893 if (err->code == GOT_ERR_PRIVSEP_PIPE)
897 if (imsg.hdr.type == GOT_IMSG_STOP)
899 if (imsg.hdr.type != GOT_IMSG_FETCH_HAVE_REF) {
900 err = got_error(GOT_ERR_PRIVSEP_MSG);
903 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
904 if (datalen < sizeof(href)) {
905 err = got_error(GOT_ERR_PRIVSEP_LEN);
908 memcpy(&href, imsg.data, sizeof(href));
909 if (datalen - sizeof(href) < href.name_len) {
910 err = got_error(GOT_ERR_PRIVSEP_LEN);
913 refname = strndup(imsg.data + sizeof(href), href.name_len);
914 if (refname == NULL) {
915 err = got_error_from_errno("strndup");
919 id = malloc(sizeof(*id));
922 err = got_error_from_errno("malloc");
925 memcpy(id, &href.id, sizeof(*id));
926 err = got_pathlist_append(&have_refs, refname, id);
936 for (i = 0; i < fetch_req.n_wanted_branches; i++) {
939 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
941 if (err->code == GOT_ERR_PRIVSEP_PIPE)
945 if (imsg.hdr.type == GOT_IMSG_STOP)
947 if (imsg.hdr.type != GOT_IMSG_FETCH_WANTED_BRANCH) {
948 err = got_error(GOT_ERR_PRIVSEP_MSG);
951 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
952 if (datalen < sizeof(wbranch)) {
953 err = got_error(GOT_ERR_PRIVSEP_LEN);
956 memcpy(&wbranch, imsg.data, sizeof(wbranch));
957 if (datalen - sizeof(wbranch) < wbranch.name_len) {
958 err = got_error(GOT_ERR_PRIVSEP_LEN);
961 refname = strndup(imsg.data + sizeof(wbranch),
963 if (refname == NULL) {
964 err = got_error_from_errno("strndup");
968 err = got_pathlist_append(&wanted_branches, refname, NULL);
977 for (i = 0; i < fetch_req.n_wanted_refs; i++) {
980 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
982 if (err->code == GOT_ERR_PRIVSEP_PIPE)
986 if (imsg.hdr.type == GOT_IMSG_STOP)
988 if (imsg.hdr.type != GOT_IMSG_FETCH_WANTED_REF) {
989 err = got_error(GOT_ERR_PRIVSEP_MSG);
992 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
993 if (datalen < sizeof(wref)) {
994 err = got_error(GOT_ERR_PRIVSEP_LEN);
997 memcpy(&wref, imsg.data, sizeof(wref));
998 if (datalen - sizeof(wref) < wref.name_len) {
999 err = got_error(GOT_ERR_PRIVSEP_LEN);
1002 refname = strndup(imsg.data + sizeof(wref), wref.name_len);
1003 if (refname == NULL) {
1004 err = got_error_from_errno("strndup");
1008 err = got_pathlist_append(&wanted_refs, refname, NULL);
1017 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
1019 if (err->code == GOT_ERR_PRIVSEP_PIPE)
1023 if (imsg.hdr.type == GOT_IMSG_STOP)
1025 if (imsg.hdr.type != GOT_IMSG_FETCH_OUTFD) {
1026 err = got_error(GOT_ERR_PRIVSEP_MSG);
1029 if (imsg.hdr.len - IMSG_HEADER_SIZE != 0) {
1030 err = got_error(GOT_ERR_PRIVSEP_LEN);
1035 err = fetch_pack(fetchfd, packfd, pack_sha1, &have_refs,
1036 fetch_req.fetch_all_branches, &wanted_branches,
1037 &wanted_refs, fetch_req.list_refs_only,
1038 worktree_branch, fetch_req.no_head, &ibuf);
1040 free(worktree_branch);
1041 got_pathlist_free(&have_refs, GOT_PATHLIST_FREE_ALL);
1042 got_pathlist_free(&wanted_branches, GOT_PATHLIST_FREE_PATH);
1043 if (fetchfd != -1 && close(fetchfd) == -1 && err == NULL)
1044 err = got_error_from_errno("close");
1045 if (packfd != -1 && close(packfd) == -1 && err == NULL)
1046 err = got_error_from_errno("close");
1048 got_privsep_send_error(&ibuf, err);
1050 err = send_fetch_done(&ibuf, pack_sha1);
1052 fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
1053 got_privsep_send_error(&ibuf, err);