libexec/got-fetch-pack/got-fetch-pack.c

   1 /*
   2  * Copyright (c) 2019 Ori Bernstein <ori@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/uio.h>
  22 #include <sys/time.h>
  23 #include <sys/stat.h>
  24
  25 #include <stdint.h>
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <signal.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35 #include <zlib.h>
  36 #include <err.h>
  37
  38 #include "got_error.h"
  39 #include "got_object.h"
  40 #include "got_path.h"
  41 #include "got_version.h"
  42 #include "got_fetch.h"
  43 #include "got_reference.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_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"
  54
  55 #ifndef MIN
  56 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
  57 #endif
  58
  59 #ifndef nitems
  60 #define nitems(_a)      (sizeof((_a)) / sizeof((_a)[0]))
  61 #endif
  62
  63 struct got_object *indexed;
  64 static int chattygot;
  65
  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 },
  70 };
  71
  72 static void
  73 match_remote_ref(struct got_pathlist_head *have_refs,
  74     struct got_object_id *my_id, const char *refname)
  75 {
  76         struct got_pathlist_entry *pe;
  77
  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));
  81
  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));
  86                         break;
  87                 }
  88         }
  89 }
  90
  91 static int
  92 match_branch(const char *branch, const char *wanted_branch)
  93 {
  94         if (strncmp(branch, "refs/heads/", 11) != 0)
  95                 return 0;
  96
  97         if (strncmp(wanted_branch, "refs/heads/", 11) == 0)
  98                 wanted_branch += 11;
  99
 100         return (strcmp(branch + 11, wanted_branch) == 0);
 101 }
 102
 103 static int
 104 match_wanted_ref(const char *refname, const char *wanted_ref)
 105 {
 106         if (strncmp(refname, "refs/", 5) != 0)
 107                 return 0;
 108         refname += 5;
 109
 110         /*
 111          * Prevent fetching of references that won't make any
 112          * sense outside of the remote repository's context.
 113          */
 114         if (strncmp(refname, "got/", 4) == 0)
 115                 return 0;
 116         if (strncmp(refname, "remotes/", 8) == 0)
 117                 return 0;
 118
 119         if (strncmp(wanted_ref, "refs/", 5) == 0)
 120                 wanted_ref += 5;
 121
 122         /* Allow prefix match. */
 123         if (got_path_is_child(refname, wanted_ref, strlen(wanted_ref)))
 124                 return 1;
 125
 126         /* Allow exact match. */
 127         return (strcmp(refname, wanted_ref) == 0);
 128 }
 129
 130 static const struct got_error *
 131 send_fetch_server_progress(struct imsgbuf *ibuf, const char *msg, size_t msglen)
 132 {
 133         if (msglen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
 134                 return got_error(GOT_ERR_NO_SPACE);
 135
 136         if (msglen == 0)
 137                 return NULL;
 138
 139         if (imsg_compose(ibuf, GOT_IMSG_FETCH_SERVER_PROGRESS, 0, 0, -1,
 140             msg, msglen) == -1)
 141                 return got_error_from_errno(
 142                     "imsg_compose FETCH_SERVER_PROGRESS");
 143
 144         return got_privsep_flush_imsg(ibuf);
 145 }
 146
 147 static const struct got_error *
 148 send_fetch_download_progress(struct imsgbuf *ibuf, off_t bytes,
 149     struct got_ratelimit *rl)
 150 {
 151         const struct got_error *err;
 152         int elapsed = 0;
 153
 154         if (rl) {
 155                 err = got_ratelimit_check(&elapsed, rl);
 156                 if (err || !elapsed)
 157                         return err;
 158         }
 159
 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");
 164
 165         return got_privsep_flush_imsg(ibuf);
 166 }
 167
 168 static const struct got_error *
 169 send_fetch_done(struct imsgbuf *ibuf, uint8_t *pack_sha1)
 170 {
 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);
 175 }
 176
 177 static const struct got_error *
 178 fetch_progress(struct imsgbuf *ibuf, const char *buf, size_t len)
 179 {
 180         size_t i;
 181
 182         if (len == 0)
 183                 return NULL;
 184
 185         /*
 186          * Truncate messages which exceed the maximum imsg payload size.
 187          * Server may send up to 64k.
 188          */
 189         if (len > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
 190                 len = MAX_IMSGSIZE - IMSG_HEADER_SIZE;
 191
 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]))
 196                         continue;
 197                 return got_error_msg(GOT_ERR_BAD_PACKET,
 198                     "non-printable progress message received from server");
 199         }
 200
 201         return send_fetch_server_progress(ibuf, buf, len);
 202 }
 203
 204 static const struct got_error *
 205 fetch_error(const char *buf, size_t len)
 206 {
 207         static char msg[1024];
 208         size_t i;
 209
 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");
 214                 msg[i] = buf[i];
 215         }
 216         msg[i] = '\0';
 217         return got_error_msg(GOT_ERR_FETCH_FAILED, msg);
 218 }
 219
 220 static const struct got_error *
 221 send_fetch_symrefs(struct imsgbuf *ibuf, struct got_pathlist_head *symrefs)
 222 {
 223         struct ibuf *wbuf;
 224         size_t len, nsymrefs = 0;
 225         struct got_pathlist_entry *pe;
 226
 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);
 232                 nsymrefs++;
 233         }
 234
 235         if (len >= MAX_IMSGSIZE - IMSG_HEADER_SIZE)
 236                 return got_error(GOT_ERR_NO_SPACE);
 237
 238         wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_SYMREFS, 0, 0, len);
 239         if (wbuf == NULL)
 240                 return got_error_from_errno("imsg_create FETCH_SYMREFS");
 241
 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");
 245
 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);
 251
 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");
 261         }
 262
 263         wbuf->fd = -1;
 264         imsg_close(ibuf, wbuf);
 265         return got_privsep_flush_imsg(ibuf);
 266 }
 267
 268 static const struct got_error *
 269 send_fetch_ref(struct imsgbuf *ibuf, struct got_object_id *refid,
 270     const char *refname)
 271 {
 272         struct ibuf *wbuf;
 273         size_t len, reflen = strlen(refname);
 274
 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);
 278
 279         wbuf = imsg_create(ibuf, GOT_IMSG_FETCH_REF, 0, 0, len);
 280         if (wbuf == NULL)
 281                 return got_error_from_errno("imsg_create FETCH_REF");
 282
 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");
 288
 289         wbuf->fd = -1;
 290         imsg_close(ibuf, wbuf);
 291         return got_privsep_flush_imsg(ibuf);
 292 }
 293
 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)
 298 {
 299         const struct got_error *err;
 300         char *theirs = NULL, *mine = NULL;
 301
 302         if (!got_parse_object_id(want, id_str, GOT_HASH_SHA1)) {
 303                 err = got_error(GOT_ERR_BAD_OBJ_ID_STR);
 304                 goto done;
 305         }
 306
 307         match_remote_ref(have_refs, have, refname);
 308         err = send_fetch_ref(ibuf, want, refname);
 309         if (err)
 310                 goto done;
 311
 312         if (chattygot)
 313                 fprintf(stderr, "%s: %s will be fetched\n",
 314                     getprogname(), refname);
 315         if (chattygot > 1) {
 316                 err = got_object_id_str(&theirs, want);
 317                 if (err)
 318                         goto done;
 319                 err = got_object_id_str(&mine, have);
 320                 if (err)
 321                         goto done;
 322                 fprintf(stderr, "%s: remote: %s\n%s: local:  %s\n",
 323                     getprogname(), theirs, getprogname(), mine);
 324         }
 325 done:
 326         free(theirs);
 327         free(mine);
 328         return err;
 329 }
 330
 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, const char *remote_head,
 337     int no_head, struct imsgbuf *ibuf)
 338 {
 339         const struct got_error *err = NULL;
 340         char buf[GOT_PKT_MAX];
 341         char hashstr[SHA1_DIGEST_STRING_LENGTH];
 342         struct got_object_id *have, *want;
 343         int is_firstpkt = 1, nref = 0, refsz = 16;
 344         int i, n, nwant = 0, nhave = 0, acked = 0;
 345         off_t packsz = 0, last_reported_packsz = 0;
 346         char *id_str = NULL, *default_id_str = NULL, *refname = NULL;
 347         char *server_capabilities = NULL, *my_capabilities = NULL;
 348         const char *default_branch = NULL;
 349         struct got_pathlist_head symrefs;
 350         struct got_pathlist_entry *pe;
 351         int sent_my_capabilites = 0, have_sidebands = 0;
 352         int found_branch = 0;
 353         struct got_hash ctx;
 354         uint8_t sha1_buf[SHA1_DIGEST_LENGTH];
 355         size_t sha1_buf_len = 0;
 356         ssize_t w;
 357         struct got_ratelimit rl;
 358
 359         TAILQ_INIT(&symrefs);
 360         got_hash_init(&ctx, GOT_HASH_SHA1);
 361         got_ratelimit_init(&rl, 0, 500);
 362
 363         have = malloc(refsz * sizeof(have[0]));
 364         if (have == NULL)
 365                 return got_error_from_errno("malloc");
 366         want = malloc(refsz * sizeof(want[0]));
 367         if (want == NULL) {
 368                 err = got_error_from_errno("malloc");
 369                 goto done;
 370         }
 371         while (1) {
 372                 err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
 373                 if (err)
 374                         goto done;
 375                 if (n == 0)
 376                         break;
 377                 if (n >= 4 && strncmp(buf, "ERR ", 4) == 0) {
 378                         err = fetch_error(&buf[4], n - 4);
 379                         goto done;
 380                 }
 381                 free(id_str);
 382                 free(refname);
 383                 err = got_gitproto_parse_refline(&id_str, &refname,
 384                     &server_capabilities, buf, n);
 385                 if (err)
 386                         goto done;
 387
 388                 if (refsz == nref + 1) {
 389                         struct got_object_id *h, *w;
 390
 391                         refsz *= 2;
 392                         h = reallocarray(have, refsz, sizeof(have[0]));
 393                         if (h == NULL) {
 394                                 err = got_error_from_errno("reallocarray");
 395                                 goto done;
 396                         }
 397                         have = h;
 398                         w = reallocarray(want, refsz, sizeof(want[0]));
 399                         if (w == NULL) {
 400                                 err = got_error_from_errno("reallocarray");
 401                                 goto done;
 402                         }
 403                         want = w;
 404                 }
 405
 406                 if (is_firstpkt) {
 407                         if (chattygot && server_capabilities[0] != '\0')
 408                                 fprintf(stderr, "%s: server capabilities: %s\n",
 409                                     getprogname(), server_capabilities);
 410                         err = got_gitproto_match_capabilities(&my_capabilities,
 411                             &symrefs, server_capabilities,
 412                             got_capabilities, nitems(got_capabilities));
 413                         if (err)
 414                                 goto done;
 415                         if (chattygot)
 416                                 fprintf(stderr, "%s: my capabilities:%s\n",
 417                                     getprogname(), my_capabilities != NULL ?
 418                                     my_capabilities : "");
 419                         err = send_fetch_symrefs(ibuf, &symrefs);
 420                         if (err)
 421                                 goto done;
 422                         is_firstpkt = 0;
 423                         if (!fetch_all_branches) {
 424                                 TAILQ_FOREACH(pe, &symrefs, entry) {
 425                                         const char *name = pe->path;
 426                                         const char *symref_target = pe->data;
 427                                         if (strcmp(name, GOT_REF_HEAD) != 0)
 428                                                 continue;
 429                                         default_branch = symref_target;
 430                                         break;
 431                                 }
 432                         }
 433                         if (default_branch)
 434                                 continue;
 435                 }
 436                 if (strstr(refname, "^{}")) {
 437                         if (chattygot) {
 438                                 fprintf(stderr, "%s: ignoring %s\n",
 439                                     getprogname(), refname);
 440                         }
 441                         continue;
 442                 }
 443                 if (default_branch && default_id_str == NULL &&
 444                     strcmp(refname, default_branch) == 0) {
 445                         default_id_str = strdup(id_str);
 446                         if (default_id_str == NULL) {
 447                                 err = got_error_from_errno("strdup");
 448                                 goto done;
 449                         }
 450                 }
 451
 452                 if (list_refs_only || strncmp(refname, "refs/tags/", 10) == 0) {
 453                         err = fetch_ref(ibuf, have_refs, &have[nref],
 454                             &want[nref], refname, id_str);
 455                         if (err)
 456                                 goto done;
 457                         nref++;
 458                 } else if (strncmp(refname, "refs/heads/", 11) == 0) {
 459                         if (fetch_all_branches) {
 460                                 err = fetch_ref(ibuf, have_refs, &have[nref],
 461                                     &want[nref], refname, id_str);
 462                                 if (err)
 463                                         goto done;
 464                                 nref++;
 465                                 found_branch = 1;
 466                                 continue;
 467                         }
 468                         TAILQ_FOREACH(pe, wanted_branches, entry) {
 469                                 if (match_branch(refname, pe->path))
 470                                         break;
 471                         }
 472                         if (pe != NULL || (worktree_branch != NULL &&
 473                             match_branch(refname, worktree_branch))) {
 474                                 err = fetch_ref(ibuf, have_refs, &have[nref],
 475                                     &want[nref], refname, id_str);
 476                                 if (err)
 477                                         goto done;
 478                                 nref++;
 479                                 found_branch = 1;
 480                         } else if (chattygot) {
 481                                 fprintf(stderr, "%s: ignoring %s\n",
 482                                     getprogname(), refname);
 483                         }
 484                 } else {
 485                         TAILQ_FOREACH(pe, wanted_refs, entry) {
 486                                 if (match_wanted_ref(refname, pe->path))
 487                                         break;
 488                         }
 489                         if (pe != NULL) {
 490                                 err = fetch_ref(ibuf, have_refs, &have[nref],
 491                                     &want[nref], refname, id_str);
 492                                 if (err)
 493                                         goto done;
 494                                 nref++;
 495                         } else if (chattygot) {
 496                                 fprintf(stderr, "%s: ignoring %s\n",
 497                                     getprogname(), refname);
 498                         }
 499                 }
 500         }
 501
 502         if (list_refs_only)
 503                 goto done;
 504
 505         /*
 506          * If -b was not used and either none of the requested branches
 507          * (got.conf, worktree) were found or the client already has the
 508          * remote HEAD symref but its target changed, fetch remote's HEAD.
 509          */
 510         if (!no_head && default_branch && default_id_str &&
 511             strncmp(default_branch, "refs/heads/", 11) == 0) {
 512                 int remote_head_changed = 0;
 513
 514                 if (remote_head) {
 515                         if (strcmp(remote_head, default_branch + 11) != 0)
 516                                 remote_head_changed = 1;
 517                 }
 518
 519                 if (!found_branch || remote_head_changed) {
 520                         err = fetch_ref(ibuf, have_refs, &have[nref],
 521                             &want[nref], default_branch, default_id_str);
 522                         if (err)
 523                                 goto done;
 524                         nref++;
 525                 }
 526         }
 527
 528         /* Abort if we haven't found anything to fetch. */
 529         if (nref == 0) {
 530                 struct got_pathlist_entry *pe;
 531                 static char msg[PATH_MAX + 33];
 532
 533                 pe = TAILQ_FIRST(wanted_branches);
 534                 if (pe) {
 535                         snprintf(msg, sizeof(msg),
 536                             "branch \"%s\" not found on server", pe->path);
 537                         err = got_error_msg(GOT_ERR_FETCH_NO_BRANCH, msg);
 538                         goto done;
 539                 }
 540
 541                 pe = TAILQ_FIRST(wanted_refs);
 542                 if (pe) {
 543                         snprintf(msg, sizeof(msg),
 544                             "reference \"%s\" not found on server", pe->path);
 545                         err = got_error_msg(GOT_ERR_FETCH_NO_BRANCH, msg);
 546                         goto done;
 547                 }
 548
 549                 err = got_error(GOT_ERR_FETCH_NO_BRANCH);
 550                 goto done;
 551         }
 552
 553         for (i = 0; i < nref; i++) {
 554                 if (got_object_id_cmp(&have[i], &want[i]) == 0)
 555                         continue;
 556                 got_sha1_digest_to_str(want[i].sha1, hashstr, sizeof(hashstr));
 557                 n = snprintf(buf, sizeof(buf), "want %s%s\n", hashstr,
 558                     sent_my_capabilites || my_capabilities == NULL ?
 559                     "" : my_capabilities);
 560                 if (n < 0 || (size_t)n >= sizeof(buf)) {
 561                         err = got_error(GOT_ERR_NO_SPACE);
 562                         goto done;
 563                 }
 564                 err = got_pkt_writepkt(fd, buf, n, chattygot);
 565                 if (err)
 566                         goto done;
 567                 sent_my_capabilites = 1;
 568                 nwant++;
 569         }
 570         err = got_pkt_flushpkt(fd, chattygot);
 571         if (err)
 572                 goto done;
 573
 574         if (nwant == 0)
 575                 goto done;
 576
 577         TAILQ_FOREACH(pe, have_refs, entry) {
 578                 struct got_object_id *id = pe->data;
 579                 got_sha1_digest_to_str(id->sha1, hashstr, sizeof(hashstr));
 580                 n = snprintf(buf, sizeof(buf), "have %s\n", hashstr);
 581                 if (n < 0 || (size_t)n >= sizeof(buf)) {
 582                         err = got_error(GOT_ERR_NO_SPACE);
 583                         goto done;
 584                 }
 585                 err = got_pkt_writepkt(fd, buf, n, chattygot);
 586                 if (err)
 587                         goto done;
 588                 nhave++;
 589         }
 590
 591         n = strlcpy(buf, "done\n", sizeof(buf));
 592         err = got_pkt_writepkt(fd, buf, n, chattygot);
 593         if (err)
 594                 goto done;
 595
 596         while (nhave > 0 && !acked) {
 597                 struct got_object_id common_id;
 598
 599                 /* The server should ACK the object IDs we need. */
 600                 err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
 601                 if (err)
 602                         goto done;
 603                 if (n >= 4 && strncmp(buf, "ERR ", 4) == 0) {
 604                         err = fetch_error(&buf[4], n - 4);
 605                         goto done;
 606                 }
 607                 if (n >= 4 && strncmp(buf, "NAK\n", 4) == 0) {
 608                         /*
 609                          * Server could not find a common ancestor.
 610                          * Perhaps it is an out-of-date mirror, or there
 611                          * is a repository with unrelated history.
 612                          */
 613                         break;
 614                 }
 615                 if (n < 4 + SHA1_DIGEST_STRING_LENGTH ||
 616                     strncmp(buf, "ACK ", 4) != 0) {
 617                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 618                             "unexpected message from server");
 619                         goto done;
 620                 }
 621                 if (!got_parse_object_id(&common_id, buf + 4,
 622                     GOT_HASH_SHA1)) {
 623                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 624                             "bad object ID in ACK packet from server");
 625                         goto done;
 626                 }
 627                 acked++;
 628         }
 629
 630         if (nhave == 0) {
 631                 err = got_pkt_readpkt(&n, fd, buf, sizeof(buf), chattygot);
 632                 if (err)
 633                         goto done;
 634                 if (n != 4 || strncmp(buf, "NAK\n", n) != 0) {
 635                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 636                             "unexpected message from server");
 637                         goto done;
 638                 }
 639         }
 640
 641         if (chattygot)
 642                 fprintf(stderr, "%s: fetching...\n", getprogname());
 643
 644         if (my_capabilities != NULL &&
 645             strstr(my_capabilities, GOT_CAPA_SIDE_BAND_64K) != NULL)
 646                 have_sidebands = 1;
 647
 648         while (1) {
 649                 ssize_t r = 0;
 650                 int datalen = -1;
 651
 652                 if (have_sidebands) {
 653                         err = got_pkt_readhdr(&datalen, fd, chattygot);
 654                         if (err)
 655                                 goto done;
 656                         if (datalen <= 0)
 657                                 break;
 658
 659                         /* Read sideband channel ID (one byte). */
 660                         r = read(fd, buf, 1);
 661                         if (r == -1) {
 662                                 err = got_error_from_errno("read");
 663                                 goto done;
 664                         }
 665                         if (r != 1) {
 666                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 667                                     "short packet");
 668                                 goto done;
 669                         }
 670                         if (datalen > sizeof(buf) - 5) {
 671                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 672                                     "bad packet length");
 673                                 goto done;
 674                         }
 675                         datalen--; /* sideband ID has been read */
 676                         if (buf[0] == GOT_SIDEBAND_PACKFILE_DATA) {
 677                                 /* Read packfile data. */
 678                                 err = got_pkt_readn(&r, fd, buf, datalen);
 679                                 if (err)
 680                                         goto done;
 681                                 if (r != datalen) {
 682                                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 683                                             "packet too short");
 684                                         goto done;
 685                                 }
 686                         } else if (buf[0] == GOT_SIDEBAND_PROGRESS_INFO) {
 687                                 err = got_pkt_readn(&r, fd, buf, datalen);
 688                                 if (err)
 689                                         goto done;
 690                                 if (r != datalen) {
 691                                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 692                                             "packet too short");
 693                                         goto done;
 694                                 }
 695                                 err = fetch_progress(ibuf, buf, r);
 696                                 if (err)
 697                                         goto done;
 698                                 continue;
 699                         } else if (buf[0] == GOT_SIDEBAND_ERROR_INFO) {
 700                                 err = got_pkt_readn(&r, fd, buf, datalen);
 701                                 if (err)
 702                                         goto done;
 703                                 if (r != datalen) {
 704                                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 705                                             "packet too short");
 706                                         goto done;
 707                                 }
 708                                 err = fetch_error(buf, r);
 709                                 goto done;
 710                         } else if (buf[0] == 'A') {
 711                                 err = got_pkt_readn(&r, fd, buf, datalen);
 712                                 if (err)
 713                                         goto done;
 714                                 if (r != datalen) {
 715                                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 716                                             "packet too short");
 717                                         goto done;
 718                                 }
 719                                 /*
 720                                  * Git server responds with ACK after 'done'
 721                                  * even though multi_ack is disabled?!?
 722                                  */
 723                                 buf[r] = '\0';
 724                                 if (strncmp(buf, "CK ", 3) == 0)
 725                                         continue; /* ignore */
 726                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 727                                     "unexpected message from server");
 728                                 goto done;
 729                         } else {
 730                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 731                                     "unknown side-band received from server");
 732                                 goto done;
 733                         }
 734                 } else {
 735                         /* No sideband channel. Every byte is packfile data. */
 736                         err = got_pkt_readn(&r, fd, buf, sizeof buf);
 737                         if (err)
 738                                 goto done;
 739                         if (r <= 0)
 740                                 break;
 741                 }
 742
 743                 /*
 744                  * An expected SHA1 checksum sits at the end of the pack file.
 745                  * Since we don't know the file size ahead of time we have to
 746                  * keep SHA1_DIGEST_LENGTH bytes buffered and avoid mixing
 747                  * those bytes into our SHA1 checksum computation until we
 748                  * know for sure that additional pack file data bytes follow.
 749                  *
 750                  * We can assume r > 0 since otherwise the loop would exit.
 751                  */
 752                 if (r < SHA1_DIGEST_LENGTH) {
 753                         if (sha1_buf_len < SHA1_DIGEST_LENGTH) {
 754                                 /*
 755                                  * If there's enough buffered + read data to
 756                                  * fill up the buffer then shift a sufficient
 757                                  * amount of bytes out at the front to make
 758                                  * room, mixing those bytes into the checksum.
 759                                  */
 760                                 if (sha1_buf_len > 0 &&
 761                                     sha1_buf_len + r > SHA1_DIGEST_LENGTH) {
 762                                         size_t nshift = MIN(sha1_buf_len + r -
 763                                             SHA1_DIGEST_LENGTH, sha1_buf_len);
 764                                         got_hash_update(&ctx, sha1_buf,
 765                                             nshift);
 766                                         memmove(sha1_buf, sha1_buf + nshift,
 767                                             sha1_buf_len - nshift);
 768                                         sha1_buf_len -= nshift;
 769                                 }
 770
 771                                 /* Buffer potential checksum bytes. */
 772                                 memcpy(sha1_buf + sha1_buf_len, buf, r);
 773                                 sha1_buf_len += r;
 774                         } else {
 775                                 /*
 776                                  * Mix in previously buffered bytes which
 777                                  * are not part of the checksum after all.
 778                                  */
 779                                 got_hash_update(&ctx, sha1_buf, r);
 780
 781                                 /* Update potential checksum buffer. */
 782                                 memmove(sha1_buf, sha1_buf + r,
 783                                     sha1_buf_len - r);
 784                                 memcpy(sha1_buf + sha1_buf_len - r, buf, r);
 785                         }
 786                 } else {
 787                         /* Mix in any previously buffered bytes. */
 788                         got_hash_update(&ctx, sha1_buf, sha1_buf_len);
 789
 790                         /* Mix in bytes read minus potential checksum bytes. */
 791                         got_hash_update(&ctx, buf, r - SHA1_DIGEST_LENGTH);
 792
 793                         /* Buffer potential checksum bytes. */
 794                         memcpy(sha1_buf, buf + r - SHA1_DIGEST_LENGTH,
 795                             SHA1_DIGEST_LENGTH);
 796                         sha1_buf_len = SHA1_DIGEST_LENGTH;
 797                 }
 798
 799                 /* Write packfile data to temporary pack file. */
 800                 w = write(packfd, buf, r);
 801                 if (w == -1) {
 802                         err = got_error_from_errno("write");
 803                         goto done;
 804                 }
 805                 if (w != r) {
 806                         err = got_error(GOT_ERR_IO);
 807                         goto done;
 808                 }
 809                 packsz += w;
 810
 811                 /* Don't send too many progress privsep messages. */
 812                 if (packsz > last_reported_packsz + 1024) {
 813                         err = send_fetch_download_progress(ibuf, packsz, &rl);
 814                         if (err)
 815                                 goto done;
 816                         last_reported_packsz = packsz;
 817                 }
 818         }
 819         err = send_fetch_download_progress(ibuf, packsz, NULL);
 820         if (err)
 821                 goto done;
 822
 823         got_hash_final(&ctx, pack_sha1);
 824         if (sha1_buf_len != SHA1_DIGEST_LENGTH ||
 825             memcmp(pack_sha1, sha1_buf, sha1_buf_len) != 0) {
 826                 err = got_error_msg(GOT_ERR_BAD_PACKFILE,
 827                     "pack file checksum mismatch");
 828         }
 829 done:
 830         got_pathlist_free(&symrefs, GOT_PATHLIST_FREE_ALL);
 831         free(have);
 832         free(want);
 833         free(id_str);
 834         free(default_id_str);
 835         free(refname);
 836         free(server_capabilities);
 837         return err;
 838 }
 839
 840
 841 int
 842 main(int argc, char **argv)
 843 {
 844         const struct got_error *err = NULL;
 845         int fetchfd = -1, packfd = -1;
 846         uint8_t pack_sha1[SHA1_DIGEST_LENGTH];
 847         struct imsgbuf ibuf;
 848         struct imsg imsg;
 849         struct got_pathlist_head have_refs;
 850         struct got_pathlist_head wanted_branches;
 851         struct got_pathlist_head wanted_refs;
 852         struct got_imsg_fetch_request fetch_req;
 853         struct got_imsg_fetch_have_ref href;
 854         struct got_imsg_fetch_wanted_branch wbranch;
 855         struct got_imsg_fetch_wanted_ref wref;
 856         size_t datalen, i;
 857         char *remote_head = NULL, *worktree_branch = NULL;
 858 #if 0
 859         static int attached;
 860         while (!attached)
 861                 sleep (1);
 862 #endif
 863
 864         TAILQ_INIT(&have_refs);
 865         TAILQ_INIT(&wanted_branches);
 866         TAILQ_INIT(&wanted_refs);
 867
 868         imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
 869 #ifndef PROFILE
 870         /* revoke access to most system calls */
 871         if (pledge("stdio recvfd", NULL) == -1) {
 872                 err = got_error_from_errno("pledge");
 873                 got_privsep_send_error(&ibuf, err);
 874                 return 1;
 875         }
 876
 877         /* revoke fs access */
 878         if (landlock_no_fs() == -1) {
 879                 err = got_error_from_errno("landlock_no_fs");
 880                 got_privsep_send_error(&ibuf, err);
 881                 return 1;
 882         }
 883         if (cap_enter() == -1) {
 884                 err = got_error_from_errno("cap_enter");
 885                 got_privsep_send_error(&ibuf, err);
 886                 return 1;
 887         }
 888 #endif
 889         err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
 890         if (err) {
 891                 if (err->code == GOT_ERR_PRIVSEP_PIPE)
 892                         err = NULL;
 893                 goto done;
 894         }
 895         if (imsg.hdr.type == GOT_IMSG_STOP)
 896                 goto done;
 897         if (imsg.hdr.type != GOT_IMSG_FETCH_REQUEST) {
 898                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 899                 goto done;
 900         }
 901         datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 902         if (datalen < sizeof(fetch_req)) {
 903                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 904                 goto done;
 905         }
 906         memcpy(&fetch_req, imsg.data, sizeof(fetch_req));
 907         fetchfd = imsg.fd;
 908
 909         if (datalen != sizeof(fetch_req) +
 910             fetch_req.worktree_branch_len + fetch_req.remote_head_len) {
 911                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 912                 goto done;
 913         }
 914
 915         if (fetch_req.worktree_branch_len != 0) {
 916                 worktree_branch = strndup(imsg.data +
 917                     sizeof(fetch_req), fetch_req.worktree_branch_len);
 918                 if (worktree_branch == NULL) {
 919                         err = got_error_from_errno("strndup");
 920                         goto done;
 921                 }
 922         }
 923
 924         if (fetch_req.remote_head_len != 0) {
 925                 remote_head = strndup(imsg.data + sizeof(fetch_req) +
 926                     fetch_req.worktree_branch_len, fetch_req.remote_head_len);
 927                 if (remote_head == NULL) {
 928                         err = got_error_from_errno("strndup");
 929                         goto done;
 930                 }
 931         }
 932
 933         imsg_free(&imsg);
 934
 935         if (fetch_req.verbosity > 0)
 936                 chattygot += fetch_req.verbosity;
 937
 938         for (i = 0; i < fetch_req.n_have_refs; i++) {
 939                 struct got_object_id *id;
 940                 char *refname;
 941
 942                 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
 943                 if (err) {
 944                         if (err->code == GOT_ERR_PRIVSEP_PIPE)
 945                                 err = NULL;
 946                         goto done;
 947                 }
 948                 if (imsg.hdr.type == GOT_IMSG_STOP)
 949                         goto done;
 950                 if (imsg.hdr.type != GOT_IMSG_FETCH_HAVE_REF) {
 951                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 952                         goto done;
 953                 }
 954                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 955                 if (datalen < sizeof(href)) {
 956                         err = got_error(GOT_ERR_PRIVSEP_LEN);
 957                         goto done;
 958                 }
 959                 memcpy(&href, imsg.data, sizeof(href));
 960                 if (datalen - sizeof(href) < href.name_len) {
 961                         err = got_error(GOT_ERR_PRIVSEP_LEN);
 962                         goto done;
 963                 }
 964                 refname = strndup(imsg.data + sizeof(href), href.name_len);
 965                 if (refname == NULL) {
 966                         err = got_error_from_errno("strndup");
 967                         goto done;
 968                 }
 969
 970                 id = malloc(sizeof(*id));
 971                 if (id == NULL) {
 972                         free(refname);
 973                         err = got_error_from_errno("malloc");
 974                         goto done;
 975                 }
 976                 memcpy(id, &href.id, sizeof(*id));
 977                 err = got_pathlist_append(&have_refs, refname, id);
 978                 if (err) {
 979                         free(refname);
 980                         free(id);
 981                         goto done;
 982                 }
 983
 984                 imsg_free(&imsg);
 985         }
 986
 987         for (i = 0; i < fetch_req.n_wanted_branches; i++) {
 988                 char *refname;
 989
 990                 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
 991                 if (err) {
 992                         if (err->code == GOT_ERR_PRIVSEP_PIPE)
 993                                 err = NULL;
 994                         goto done;
 995                 }
 996                 if (imsg.hdr.type == GOT_IMSG_STOP)
 997                         goto done;
 998                 if (imsg.hdr.type != GOT_IMSG_FETCH_WANTED_BRANCH) {
 999                         err = got_error(GOT_ERR_PRIVSEP_MSG);
1000                         goto done;
1001                 }
1002                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1003                 if (datalen < sizeof(wbranch)) {
1004                         err = got_error(GOT_ERR_PRIVSEP_LEN);
1005                         goto done;
1006                 }
1007                 memcpy(&wbranch, imsg.data, sizeof(wbranch));
1008                 if (datalen - sizeof(wbranch) < wbranch.name_len) {
1009                         err = got_error(GOT_ERR_PRIVSEP_LEN);
1010                         goto done;
1011                 }
1012                 refname = strndup(imsg.data + sizeof(wbranch),
1013                     wbranch.name_len);
1014                 if (refname == NULL) {
1015                         err = got_error_from_errno("strndup");
1016                         goto done;
1017                 }
1018
1019                 err = got_pathlist_append(&wanted_branches, refname, NULL);
1020                 if (err) {
1021                         free(refname);
1022                         goto done;
1023                 }
1024
1025                 imsg_free(&imsg);
1026         }
1027
1028         for (i = 0; i < fetch_req.n_wanted_refs; i++) {
1029                 char *refname;
1030
1031                 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
1032                 if (err) {
1033                         if (err->code == GOT_ERR_PRIVSEP_PIPE)
1034                                 err = NULL;
1035                         goto done;
1036                 }
1037                 if (imsg.hdr.type == GOT_IMSG_STOP)
1038                         goto done;
1039                 if (imsg.hdr.type != GOT_IMSG_FETCH_WANTED_REF) {
1040                         err = got_error(GOT_ERR_PRIVSEP_MSG);
1041                         goto done;
1042                 }
1043                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1044                 if (datalen < sizeof(wref)) {
1045                         err = got_error(GOT_ERR_PRIVSEP_LEN);
1046                         goto done;
1047                 }
1048                 memcpy(&wref, imsg.data, sizeof(wref));
1049                 if (datalen - sizeof(wref) < wref.name_len) {
1050                         err = got_error(GOT_ERR_PRIVSEP_LEN);
1051                         goto done;
1052                 }
1053                 refname = strndup(imsg.data + sizeof(wref), wref.name_len);
1054                 if (refname == NULL) {
1055                         err = got_error_from_errno("strndup");
1056                         goto done;
1057                 }
1058
1059                 err = got_pathlist_append(&wanted_refs, refname, NULL);
1060                 if (err) {
1061                         free(refname);
1062                         goto done;
1063                 }
1064
1065                 imsg_free(&imsg);
1066         }
1067
1068         err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
1069         if (err) {
1070                 if (err->code == GOT_ERR_PRIVSEP_PIPE)
1071                         err = NULL;
1072                 goto done;
1073         }
1074         if (imsg.hdr.type == GOT_IMSG_STOP)
1075                 goto done;
1076         if (imsg.hdr.type != GOT_IMSG_FETCH_OUTFD) {
1077                 err = got_error(GOT_ERR_PRIVSEP_MSG);
1078                 goto done;
1079         }
1080         if (imsg.hdr.len - IMSG_HEADER_SIZE != 0) {
1081                 err = got_error(GOT_ERR_PRIVSEP_LEN);
1082                 goto done;
1083         }
1084         packfd = imsg.fd;
1085
1086         err = fetch_pack(fetchfd, packfd, pack_sha1, &have_refs,
1087             fetch_req.fetch_all_branches, &wanted_branches,
1088             &wanted_refs, fetch_req.list_refs_only,
1089             worktree_branch, remote_head, fetch_req.no_head, &ibuf);
1090 done:
1091         free(worktree_branch);
1092         free(remote_head);
1093         got_pathlist_free(&have_refs, GOT_PATHLIST_FREE_ALL);
1094         got_pathlist_free(&wanted_branches, GOT_PATHLIST_FREE_PATH);
1095         if (fetchfd != -1 && close(fetchfd) == -1 && err == NULL)
1096                 err = got_error_from_errno("close");
1097         if (packfd != -1 && close(packfd) == -1 && err == NULL)
1098                 err = got_error_from_errno("close");
1099         if (err != NULL)
1100                 got_privsep_send_error(&ibuf, err);
1101         else
1102                 err = send_fetch_done(&ibuf, pack_sha1);
1103         if (err != NULL) {
1104                 fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
1105                 got_privsep_send_error(&ibuf, err);
1106         }
1107
1108         exit(0);
1109 }