lib/serve.c

   1 /*
   2  * Copyright (c) 2022 Stefan Sperling <stsp@openbsd.org>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "got_compat.h"
  18
  19 #include <sys/types.h>
  20 #include <sys/queue.h>
  21 #include <sys/uio.h>
  22
  23 #include <errno.h>
  24 #include <event.h>
  25 #include <poll.h>
  26 #include <limits.h>
  27 #include <stdio.h>
  28 #include <stdint.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <imsg.h>
  32 #include <unistd.h>
  33
  34 #include "got_error.h"
  35 #include "got_serve.h"
  36 #include "got_path.h"
  37 #include "got_version.h"
  38 #include "got_reference.h"
  39 #include "got_object.h"
  40
  41 #include "got_lib_pkt.h"
  42 #include "got_lib_dial.h"
  43 #include "got_lib_gitproto.h"
  44 #include "got_lib_hash.h"
  45 #include "got_lib_poll.h"
  46
  47 #include "gotd.h"
  48
  49 #ifndef nitems
  50 #define nitems(_a)      (sizeof((_a)) / sizeof((_a)[0]))
  51 #endif
  52
  53 static const struct got_capability read_capabilities[] = {
  54         { GOT_CAPA_AGENT, "got/" GOT_VERSION_STR },
  55         { GOT_CAPA_OFS_DELTA, NULL },
  56         { GOT_CAPA_SIDE_BAND_64K, NULL },
  57 };
  58
  59 static const struct got_capability write_capabilities[] = {
  60         { GOT_CAPA_AGENT, "got/" GOT_VERSION_STR },
  61         { GOT_CAPA_OFS_DELTA, NULL },
  62         { GOT_CAPA_REPORT_STATUS, NULL },
  63         { GOT_CAPA_NO_THIN, NULL },
  64         { GOT_CAPA_DELETE_REFS, NULL },
  65 };
  66
  67 static const struct got_error *
  68 append_read_capabilities(size_t *capalen, size_t len, const char *symrefstr,
  69     uint8_t *buf, size_t bufsize)
  70 {
  71         struct got_capability capa[nitems(read_capabilities) + 1];
  72         size_t ncapa;
  73
  74         memcpy(&capa, read_capabilities, sizeof(read_capabilities));
  75         if (symrefstr) {
  76                 capa[nitems(read_capabilities)].key = "symref";
  77                 capa[nitems(read_capabilities)].value = symrefstr;
  78                 ncapa = nitems(capa);
  79         } else
  80                 ncapa = nitems(read_capabilities);
  81
  82         return got_gitproto_append_capabilities(capalen, buf, len,
  83             bufsize, capa, ncapa);
  84 }
  85
  86 static const struct got_error *
  87 send_ref(int outfd, uint8_t *id, const char *refname, int send_capabilities,
  88     int client_is_reading, const char *symrefstr, int chattygot)
  89 {
  90         const struct got_error *err = NULL;
  91         char hex[SHA1_DIGEST_STRING_LENGTH];
  92         char buf[GOT_PKT_MAX];
  93         size_t len, capalen = 0;
  94
  95         if (got_sha1_digest_to_str(id, hex, sizeof(hex)) == NULL)
  96                 return got_error(GOT_ERR_BAD_OBJ_ID);
  97
  98         len = snprintf(buf, sizeof(buf), "%s %s", hex, refname);
  99         if (len >= sizeof(buf))
 100                 return got_error(GOT_ERR_NO_SPACE);
 101
 102         if (send_capabilities) {
 103                 if (client_is_reading) {
 104                         err = append_read_capabilities(&capalen, len,
 105                             symrefstr, buf, sizeof(buf));
 106                 } else {
 107                         err = got_gitproto_append_capabilities(&capalen,
 108                             buf, len, sizeof(buf), write_capabilities,
 109                             nitems(write_capabilities));
 110                 }
 111                 if (err)
 112                         return err;
 113                 len += capalen;
 114         }
 115
 116         if (len + 1 >= sizeof(buf))
 117                 return got_error(GOT_ERR_NO_SPACE);
 118         buf[len] = '\n';
 119         len++;
 120         buf[len] = '\0';
 121
 122         return got_pkt_writepkt(outfd, buf, len, chattygot);
 123 }
 124
 125 static const struct got_error *
 126 send_zero_refs(int outfd, int client_is_reading, int chattygot)
 127 {
 128         const struct got_error *err = NULL;
 129         const char *line = GOT_SHA1_STRING_ZERO " capabilities^{}";
 130         char buf[GOT_PKT_MAX];
 131         size_t len, capalen = 0;
 132
 133         len = strlcpy(buf, line, sizeof(buf));
 134         if (len >= sizeof(buf))
 135                 return got_error(GOT_ERR_NO_SPACE);
 136
 137         if (client_is_reading) {
 138                 err = got_gitproto_append_capabilities(&capalen, buf, len,
 139                     sizeof(buf), read_capabilities, nitems(read_capabilities));
 140                 if (err)
 141                         return err;
 142         } else {
 143                 err = got_gitproto_append_capabilities(&capalen, buf, len,
 144                     sizeof(buf), write_capabilities,
 145                     nitems(write_capabilities));
 146                 if (err)
 147                         return err;
 148         }
 149
 150         return got_pkt_writepkt(outfd, buf, len + capalen, chattygot);
 151 }
 152
 153 static void
 154 echo_error(const struct got_error *err, int outfd, int chattygot)
 155 {
 156         char buf[4 + GOT_ERR_MAX_MSG_SIZE];
 157         size_t len;
 158
 159         /*
 160          * Echo the error to the client on a pkt-line.
 161          * The client should then terminate its session.
 162          */
 163         buf[0] = 'E'; buf[1] = 'R'; buf[2] = 'R'; buf[3] = ' '; buf[4] = '\0';
 164         len = strlcat(buf, err->msg, sizeof(buf));
 165         got_pkt_writepkt(outfd, buf, len, chattygot);
 166 }
 167
 168 static const struct got_error *
 169 announce_refs(int outfd, struct imsgbuf *ibuf, int client_is_reading,
 170     const char *repo_path, int chattygot)
 171 {
 172         const struct got_error *err = NULL;
 173         struct imsg imsg;
 174         size_t datalen;
 175         struct gotd_imsg_list_refs lsref;
 176         struct gotd_imsg_reflist ireflist;
 177         struct gotd_imsg_ref iref;
 178         struct gotd_imsg_symref isymref;
 179         size_t nrefs = 0;
 180         int have_nrefs = 0, sent_capabilities = 0;
 181         char *symrefname = NULL, *symreftarget = NULL, *symrefstr = NULL;
 182         char *refname = NULL;
 183
 184         memset(&imsg, 0, sizeof(imsg));
 185         memset(&lsref, 0, sizeof(lsref));
 186
 187         if (strlcpy(lsref.repo_name, repo_path, sizeof(lsref.repo_name)) >=
 188             sizeof(lsref.repo_name))
 189                 return got_error(GOT_ERR_NO_SPACE);
 190         lsref.client_is_reading = client_is_reading;
 191
 192         if (imsg_compose(ibuf, GOTD_IMSG_LIST_REFS, 0, 0, -1,
 193             &lsref, sizeof(lsref)) == -1)
 194                 return got_error_from_errno("imsg_compose LIST_REFS");
 195
 196         err = gotd_imsg_flush(ibuf);
 197         if (err)
 198                 return err;
 199
 200         while (!have_nrefs || nrefs > 0) {
 201                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 202                 if (err)
 203                         goto done;
 204                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 205                 switch (imsg.hdr.type) {
 206                 case GOTD_IMSG_ERROR:
 207                         err = gotd_imsg_recv_error(NULL, &imsg);
 208                         goto done;
 209                 case GOTD_IMSG_REFLIST:
 210                         if (have_nrefs || nrefs > 0) {
 211                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 212                                 goto done;
 213                         }
 214                         if (datalen != sizeof(ireflist)) {
 215                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 216                                 goto done;
 217                         }
 218                         memcpy(&ireflist, imsg.data, sizeof(ireflist));
 219                         nrefs = ireflist.nrefs;
 220                         have_nrefs = 1;
 221                         if (nrefs == 0)
 222                                 err = send_zero_refs(outfd, client_is_reading,
 223                                     chattygot);
 224                         break;
 225                 case GOTD_IMSG_REF:
 226                         if (!have_nrefs || nrefs == 0) {
 227                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 228                                 goto done;
 229                         }
 230                         if (datalen < sizeof(iref)) {
 231                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 232                                 goto done;
 233                         }
 234                         memcpy(&iref, imsg.data, sizeof(iref));
 235                         if (datalen != sizeof(iref) + iref.name_len) {
 236                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 237                                 goto done;
 238                         }
 239                         refname = strndup(imsg.data + sizeof(iref),
 240                             iref.name_len);
 241                         if (refname == NULL) {
 242                                 err = got_error_from_errno("strndup");
 243                                 goto done;
 244                         }
 245                         err = send_ref(outfd, iref.id, refname,
 246                             !sent_capabilities, client_is_reading,
 247                             NULL, chattygot);
 248                         free(refname);
 249                         refname = NULL;
 250                         if (err)
 251                                 goto done;
 252                         sent_capabilities = 1;
 253                         if (nrefs > 0)
 254                                 nrefs--;
 255                         break;
 256                 case GOTD_IMSG_SYMREF:
 257                         if (!have_nrefs || nrefs == 0) {
 258                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 259                                 goto done;
 260                         }
 261                         if (datalen < sizeof(isymref)) {
 262                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 263                                 goto done;
 264                         }
 265                         memcpy(&isymref, imsg.data, sizeof(isymref));
 266                         if (datalen != sizeof(isymref) + isymref.name_len +
 267                             isymref.target_len) {
 268                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 269                                 goto done;
 270                         }
 271
 272                         /*
 273                          * For now, we only announce one symbolic ref,
 274                          * as part of our capability advertisement.
 275                          */
 276                         if (sent_capabilities || symrefstr != NULL ||
 277                             symrefname != NULL || symreftarget != NULL)
 278                                 break;
 279
 280                         symrefname = strndup(imsg.data + sizeof(isymref),
 281                             isymref.name_len);
 282                         if (symrefname == NULL) {
 283                                 err = got_error_from_errno("malloc");
 284                                 goto done;
 285                         }
 286
 287                         symreftarget = strndup(
 288                             imsg.data + sizeof(isymref) + isymref.name_len,
 289                             isymref.target_len);
 290                         if (symreftarget == NULL) {
 291                                 err = got_error_from_errno("strndup");
 292                                 goto done;
 293                         }
 294
 295                         if (asprintf(&symrefstr, "%s:%s", symrefname,
 296                             symreftarget) == -1) {
 297                                 err = got_error_from_errno("asprintf");
 298                                 goto done;
 299                         }
 300                         err = send_ref(outfd, isymref.target_id, symrefname,
 301                             !sent_capabilities, client_is_reading, symrefstr,
 302                             chattygot);
 303                         free(refname);
 304                         refname = NULL;
 305                         if (err)
 306                                 goto done;
 307                         sent_capabilities = 1;
 308                         if (nrefs > 0)
 309                                 nrefs--;
 310                         break;
 311                 default:
 312                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 313                         break;
 314                 }
 315
 316                 imsg_free(&imsg);
 317         }
 318
 319         err = got_pkt_flushpkt(outfd, chattygot);
 320         if (err)
 321                 goto done;
 322 done:
 323         free(symrefstr);
 324         free(symrefname);
 325         free(symreftarget);
 326         return err;
 327 }
 328
 329 static const struct got_error *
 330 parse_want_line(char **common_capabilities, uint8_t *id, char *buf, size_t len)
 331 {
 332         const struct got_error *err;
 333         char *id_str = NULL, *client_capabilities = NULL;
 334
 335         err = got_gitproto_parse_want_line(&id_str,
 336             &client_capabilities, buf, len);
 337         if (err)
 338                 return err;
 339
 340         if (!got_parse_hash_digest(id, id_str, GOT_HASH_SHA1)) {
 341                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 342                     "want-line with bad object ID");
 343                 goto done;
 344         }
 345
 346         if (client_capabilities) {
 347                 err = got_gitproto_match_capabilities(common_capabilities,
 348                     NULL, client_capabilities, read_capabilities,
 349                     nitems(read_capabilities));
 350                 if (err)
 351                         goto done;
 352         }
 353 done:
 354         free(id_str);
 355         free(client_capabilities);
 356         return err;
 357 }
 358
 359 static const struct got_error *
 360 parse_have_line(uint8_t *id, char *buf, size_t len)
 361 {
 362         const struct got_error *err;
 363         char *id_str = NULL;
 364
 365         err = got_gitproto_parse_have_line(&id_str, buf, len);
 366         if (err)
 367                 return err;
 368
 369         if (!got_parse_hash_digest(id, id_str, GOT_HASH_SHA1)) {
 370                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 371                     "have-line with bad object ID");
 372                 goto done;
 373         }
 374 done:
 375         free(id_str);
 376         return err;
 377 }
 378
 379 static const struct got_error *
 380 send_capability(struct got_capability *capa, struct imsgbuf *ibuf)
 381 {
 382         const struct got_error *err = NULL;
 383         struct gotd_imsg_capability icapa;
 384         size_t len;
 385         struct ibuf *wbuf;
 386
 387         memset(&icapa, 0, sizeof(icapa));
 388
 389         icapa.key_len = strlen(capa->key);
 390         len = sizeof(icapa) + icapa.key_len;
 391         if (capa->value) {
 392                 icapa.value_len = strlen(capa->value);
 393                 len += icapa.value_len;
 394         }
 395
 396         wbuf = imsg_create(ibuf, GOTD_IMSG_CAPABILITY, 0, 0, len);
 397         if (wbuf == NULL) {
 398                 err = got_error_from_errno("imsg_create CAPABILITY");
 399                 return err;
 400         }
 401
 402         if (imsg_add(wbuf, &icapa, sizeof(icapa)) == -1)
 403                 return got_error_from_errno("imsg_add CAPABILITY");
 404         if (imsg_add(wbuf, capa->key, icapa.key_len) == -1)
 405                 return got_error_from_errno("imsg_add CAPABILITY");
 406         if (capa->value) {
 407                 if (imsg_add(wbuf, capa->value, icapa.value_len) == -1)
 408                         return got_error_from_errno("imsg_add CAPABILITY");
 409         }
 410
 411         wbuf->fd = -1;
 412         imsg_close(ibuf, wbuf);
 413
 414         return NULL;
 415 }
 416
 417 static const struct got_error *
 418 send_capabilities(int *use_sidebands, int *report_status,
 419     char *capabilities_str, struct imsgbuf *ibuf)
 420 {
 421         const struct got_error *err = NULL;
 422         struct gotd_imsg_capabilities icapas;
 423         struct got_capability *capa = NULL;
 424         size_t ncapa, i;
 425
 426         err = got_gitproto_split_capabilities_str(&capa, &ncapa,
 427             capabilities_str);
 428         if (err)
 429                 return err;
 430
 431         icapas.ncapabilities = ncapa;
 432         if (imsg_compose(ibuf, GOTD_IMSG_CAPABILITIES, 0, 0, -1,
 433             &icapas, sizeof(icapas)) == -1) {
 434                 err = got_error_from_errno("imsg_compose IMSG_CAPABILITIES");
 435                 goto done;
 436         }
 437
 438         for (i = 0; i < ncapa; i++) {
 439                 err = send_capability(&capa[i], ibuf);
 440                 if (err)
 441                         goto done;
 442                 if (use_sidebands &&
 443                     strcmp(capa[i].key, GOT_CAPA_SIDE_BAND_64K) == 0)
 444                         *use_sidebands = 1;
 445                 if (report_status &&
 446                     strcmp(capa[i].key, GOT_CAPA_REPORT_STATUS) == 0)
 447                         *report_status = 1;
 448         }
 449 done:
 450         free(capa);
 451         return err;
 452 }
 453
 454 static const struct got_error *
 455 forward_flushpkt(struct imsgbuf *ibuf)
 456 {
 457         if (imsg_compose(ibuf, GOTD_IMSG_FLUSH, 0, 0, -1, NULL, 0) == -1)
 458                 return got_error_from_errno("imsg_compose FLUSH");
 459
 460         return gotd_imsg_flush(ibuf);
 461 }
 462
 463 static const struct got_error *
 464 recv_ack(struct imsg *imsg, uint8_t *expected_id)
 465 {
 466         struct gotd_imsg_ack iack;
 467         size_t datalen;
 468
 469         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 470         if (datalen != sizeof(iack))
 471                 return got_error(GOT_ERR_PRIVSEP_LEN);
 472
 473         memcpy(&iack, imsg->data, sizeof(iack));
 474         if (memcmp(iack.object_id, expected_id, SHA1_DIGEST_LENGTH) != 0)
 475                 return got_error(GOT_ERR_BAD_OBJ_ID);
 476
 477         return NULL;
 478 }
 479
 480 static const struct got_error *
 481 recv_nak(struct imsg *imsg, uint8_t *expected_id)
 482 {
 483         struct gotd_imsg_ack inak;
 484         size_t datalen;
 485
 486         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 487         if (datalen != sizeof(inak))
 488                 return got_error(GOT_ERR_PRIVSEP_LEN);
 489
 490         memcpy(&inak, imsg->data, sizeof(inak));
 491         if (memcmp(inak.object_id, expected_id, SHA1_DIGEST_LENGTH) != 0)
 492                 return got_error(GOT_ERR_BAD_OBJ_ID);
 493
 494         return NULL;
 495 }
 496
 497
 498 static const struct got_error *
 499 recv_want(int *use_sidebands, int outfd, struct imsgbuf *ibuf,
 500     char *buf, size_t len, int expect_capabilities, int chattygot)
 501 {
 502         const struct got_error *err;
 503         struct gotd_imsg_want iwant;
 504         char *capabilities_str;
 505         int done = 0;
 506         struct imsg imsg;
 507
 508         memset(&iwant, 0, sizeof(iwant));
 509         memset(&imsg, 0, sizeof(imsg));
 510
 511         err = parse_want_line(&capabilities_str, iwant.object_id, buf, len);
 512         if (err)
 513                 return err;
 514
 515         if (capabilities_str) {
 516                 if (!expect_capabilities) {
 517                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 518                             "unexpected capability announcement received");
 519                         goto done;
 520                 }
 521                 err = send_capabilities(use_sidebands, NULL, capabilities_str,
 522                     ibuf);
 523                 if (err)
 524                         goto done;
 525
 526         }
 527
 528         if (imsg_compose(ibuf, GOTD_IMSG_WANT, 0, 0, -1,
 529             &iwant, sizeof(iwant)) == -1) {
 530                 err = got_error_from_errno("imsg_compose WANT");
 531                 goto done;
 532         }
 533
 534         err = gotd_imsg_flush(ibuf);
 535         if (err)
 536                 goto done;
 537
 538         /*
 539          * Wait for an ACK, or an error in case the desired object
 540          * does not exist.
 541          */
 542         while (!done && err == NULL) {
 543                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 544                 if (err)
 545                         break;
 546                 switch (imsg.hdr.type) {
 547                 case GOTD_IMSG_ERROR:
 548                         err = gotd_imsg_recv_error(NULL, &imsg);
 549                         break;
 550                 case GOTD_IMSG_ACK:
 551                         err = recv_ack(&imsg, iwant.object_id);
 552                         if (err)
 553                                 break;
 554                         done = 1;
 555                         break;
 556                 default:
 557                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 558                         break;
 559                 }
 560
 561                 imsg_free(&imsg);
 562         }
 563 done:
 564         free(capabilities_str);
 565         return err;
 566 }
 567
 568 static const struct got_error *
 569 send_ack(int outfd, uint8_t *id, int chattygot)
 570 {
 571         char hex[SHA1_DIGEST_STRING_LENGTH];
 572         char buf[GOT_PKT_MAX];
 573         int len;
 574
 575         if (got_sha1_digest_to_str(id, hex, sizeof(hex)) == NULL)
 576                 return got_error(GOT_ERR_BAD_OBJ_ID);
 577
 578         len = snprintf(buf, sizeof(buf), "ACK %s\n", hex);
 579         if (len >= sizeof(buf))
 580                 return got_error(GOT_ERR_NO_SPACE);
 581
 582         return got_pkt_writepkt(outfd, buf, len, chattygot);
 583 }
 584
 585 static const struct got_error *
 586 send_nak(int outfd, int chattygot)
 587 {
 588         char buf[5];
 589         int len;
 590
 591         len = snprintf(buf, sizeof(buf), "NAK\n");
 592         if (len >= sizeof(buf))
 593                 return got_error(GOT_ERR_NO_SPACE);
 594
 595         return got_pkt_writepkt(outfd, buf, len, chattygot);
 596 }
 597
 598 static const struct got_error *
 599 recv_have(int *have_ack, int outfd, struct imsgbuf *ibuf, char *buf,
 600     size_t len, int chattygot)
 601 {
 602         const struct got_error *err;
 603         struct gotd_imsg_have ihave;
 604         int done = 0;
 605         struct imsg imsg;
 606
 607         memset(&ihave, 0, sizeof(ihave));
 608         memset(&imsg, 0, sizeof(imsg));
 609
 610         err = parse_have_line(ihave.object_id, buf, len);
 611         if (err)
 612                 return err;
 613
 614         if (imsg_compose(ibuf, GOTD_IMSG_HAVE, 0, 0, -1,
 615             &ihave, sizeof(ihave)) == -1)
 616                 return got_error_from_errno("imsg_compose HAVE");
 617
 618         err = gotd_imsg_flush(ibuf);
 619         if (err)
 620                 return err;
 621
 622         /*
 623          * Wait for an ACK or a NAK, indicating whether a common
 624          * commit object has been found.
 625          */
 626         while (!done && err == NULL) {
 627                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 628                 if (err)
 629                         return err;
 630                 switch (imsg.hdr.type) {
 631                 case GOTD_IMSG_ERROR:
 632                         err = gotd_imsg_recv_error(NULL, &imsg);
 633                         break;
 634                 case GOTD_IMSG_ACK:
 635                         err = recv_ack(&imsg, ihave.object_id);
 636                         if (err)
 637                                 break;
 638                         if (!*have_ack) {
 639                                 err = send_ack(outfd, ihave.object_id,
 640                                     chattygot);
 641                                 if (err)
 642                                         return err;
 643                                 *have_ack = 1;
 644                         }
 645                         done = 1;
 646                         break;
 647                 case GOTD_IMSG_NAK:
 648                         err = recv_nak(&imsg, ihave.object_id);
 649                         if (err)
 650                                 break;
 651                         done = 1;
 652                         break;
 653                 default:
 654                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 655                         break;
 656                 }
 657
 658                 imsg_free(&imsg);
 659         }
 660
 661         return err;
 662 }
 663
 664 static const struct got_error *
 665 recv_done(int *packfd, int outfd, struct imsgbuf *ibuf, int chattygot)
 666 {
 667         const struct got_error *err;
 668         struct imsg imsg;
 669
 670         *packfd = -1;
 671
 672         if (imsg_compose(ibuf, GOTD_IMSG_DONE, 0, 0, -1, NULL, 0) == -1)
 673                 return got_error_from_errno("imsg_compose DONE");
 674
 675         err = gotd_imsg_flush(ibuf);
 676         if (err)
 677                 return err;
 678
 679         while (*packfd == -1 && err == NULL) {
 680                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 681                 if (err)
 682                         break;
 683
 684                 switch (imsg.hdr.type) {
 685                 case GOTD_IMSG_ERROR:
 686                         err = gotd_imsg_recv_error(NULL, &imsg);
 687                         break;
 688                 case GOTD_IMSG_PACKFILE_PIPE:
 689                         if (imsg.fd != -1)
 690                                 *packfd = imsg.fd;
 691                         else
 692                                 err = got_error(GOT_ERR_PRIVSEP_NO_FD);
 693                         break;
 694                 default:
 695                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 696                         break;
 697                 }
 698
 699                 imsg_free(&imsg);
 700         }
 701
 702         return err;
 703 }
 704
 705 static const struct got_error *
 706 relay_progress_reports(struct imsgbuf *ibuf, int outfd, int chattygot)
 707 {
 708         const struct got_error *err = NULL;
 709         int pack_starting = 0;
 710         struct gotd_imsg_packfile_progress iprog;
 711         char buf[GOT_PKT_MAX];
 712         struct imsg imsg;
 713         size_t datalen;
 714         int p_deltify = 0, n;
 715         const char *eol = "\r";
 716
 717         memset(&imsg, 0, sizeof(imsg));
 718
 719         while (!pack_starting && err == NULL) {
 720                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 721                 if (err)
 722                         break;
 723
 724                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 725                 switch (imsg.hdr.type) {
 726                 case GOTD_IMSG_ERROR:
 727                         err = gotd_imsg_recv_error(NULL, &imsg);
 728                         break;
 729                 case GOTD_IMSG_PACKFILE_READY:
 730                         eol = "\n";
 731                         pack_starting = 1;
 732                         /* fallthrough */
 733                 case GOTD_IMSG_PACKFILE_PROGRESS:
 734                         if (datalen != sizeof(iprog)) {
 735                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 736                                 break;
 737                         }
 738                         memcpy(&iprog, imsg.data, sizeof(iprog));
 739                         if (iprog.nobj_total > 0) {
 740                                 p_deltify = (iprog.nobj_deltify * 100) /
 741                                     iprog.nobj_total;
 742                         }
 743                         buf[0] = GOT_SIDEBAND_PROGRESS_INFO;
 744                         n = snprintf(&buf[1], sizeof(buf) - 1,
 745                             "%d commits colored, "
 746                             "%d objects found, "
 747                             "deltify %d%%%s",
 748                             iprog.ncolored,
 749                             iprog.nfound,
 750                             p_deltify, eol);
 751                         if (n >= sizeof(buf) - 1)
 752                                 break;
 753                         err = got_pkt_writepkt(outfd, buf, 1 + n, chattygot);
 754                         break;
 755                 default:
 756                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 757                         break;
 758                 }
 759
 760                 imsg_free(&imsg);
 761         }
 762
 763         return err;
 764 }
 765
 766 static const struct got_error *
 767 serve_read(int infd, int outfd, int gotd_sock, const char *repo_path,
 768     int chattygot)
 769 {
 770         const struct got_error *err = NULL;
 771         char buf[GOT_PKT_MAX];
 772         struct imsgbuf ibuf;
 773         enum protostate {
 774                 STATE_EXPECT_WANT,
 775                 STATE_EXPECT_MORE_WANT,
 776                 STATE_EXPECT_HAVE,
 777                 STATE_EXPECT_DONE,
 778                 STATE_DONE,
 779         };
 780         enum protostate curstate = STATE_EXPECT_WANT;
 781         int have_ack = 0, use_sidebands = 0, seen_have = 0;
 782         int packfd = -1;
 783         size_t pack_chunksize;
 784
 785         imsg_init(&ibuf, gotd_sock);
 786
 787         err = announce_refs(outfd, &ibuf, 1, repo_path, chattygot);
 788         if (err)
 789                 goto done;
 790
 791         while (curstate != STATE_DONE) {
 792                 int n;
 793                 buf[0] = '\0';
 794                 err = got_pkt_readpkt(&n, infd, buf, sizeof(buf), chattygot);
 795                 if (err)
 796                         goto done;
 797                 if (n == 0) {
 798                         if (curstate != STATE_EXPECT_WANT &&
 799                             curstate != STATE_EXPECT_MORE_WANT &&
 800                             curstate != STATE_EXPECT_HAVE &&
 801                             curstate != STATE_EXPECT_DONE) {
 802                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 803                                     "unexpected flush packet received");
 804                                 goto done;
 805                         }
 806
 807                         if (curstate == STATE_EXPECT_WANT) {
 808                                 ssize_t r;
 809                                 /*
 810                                  * If the client does not want to fetch
 811                                  * anything we should receive a flush
 812                                  * packet followed by EOF.
 813                                  */
 814                                 r = read(infd, buf, sizeof(buf));
 815                                 if (r == -1) {
 816                                         err = got_error_from_errno("read");
 817                                         goto done;
 818                                 }
 819                                 if (r == 0) /* EOF */
 820                                         goto done;
 821
 822                                 /* Zero-length field followed by payload. */
 823                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 824                                     "unexpected flush packet received");
 825                                 goto done;
 826                         }
 827
 828                         if (curstate == STATE_EXPECT_WANT ||
 829                             curstate == STATE_EXPECT_MORE_WANT ||
 830                             curstate == STATE_EXPECT_HAVE) {
 831                                 err = forward_flushpkt(&ibuf);
 832                                 if (err)
 833                                         goto done;
 834                         }
 835                         if (curstate == STATE_EXPECT_HAVE && !have_ack) {
 836                                 err = send_nak(outfd, chattygot);
 837                                 if (err)
 838                                         goto done;
 839                         }
 840                         if (curstate == STATE_EXPECT_MORE_WANT)
 841                                 curstate = STATE_EXPECT_HAVE;
 842                         else
 843                                 curstate = STATE_EXPECT_DONE;
 844                 } else if (n >= 5 && strncmp(buf, "want ", 5) == 0) {
 845                         if (curstate != STATE_EXPECT_WANT &&
 846                             curstate != STATE_EXPECT_MORE_WANT) {
 847                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 848                                     "unexpected 'want' packet");
 849                                 goto done;
 850                         }
 851                         err = recv_want(&use_sidebands, outfd, &ibuf, buf, n,
 852                             curstate == STATE_EXPECT_WANT ? 1 : 0, chattygot);
 853                         if (err)
 854                                 goto done;
 855                         if (curstate == STATE_EXPECT_WANT)
 856                                 curstate = STATE_EXPECT_MORE_WANT;
 857                 } else if (n >= 5 && strncmp(buf, "have ", 5) == 0) {
 858                         if (curstate != STATE_EXPECT_HAVE &&
 859                             curstate != STATE_EXPECT_DONE) {
 860                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 861                                     "unexpected 'have' packet");
 862                                 goto done;
 863                         }
 864                         if (curstate == STATE_EXPECT_HAVE) {
 865                                 err = recv_have(&have_ack, outfd, &ibuf,
 866                                     buf, n, chattygot);
 867                                 if (err)
 868                                         goto done;
 869                                 seen_have = 1;
 870                         }
 871                 } else if (n == 5 && strncmp(buf, "done\n", 5) == 0) {
 872                         if (curstate != STATE_EXPECT_HAVE &&
 873                             curstate != STATE_EXPECT_DONE) {
 874                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 875                                     "unexpected 'done' packet");
 876                                 goto done;
 877                         }
 878                         err = recv_done(&packfd, outfd, &ibuf, chattygot);
 879                         if (err)
 880                                 goto done;
 881                         curstate = STATE_DONE;
 882                         break;
 883                 } else {
 884                         err = got_error(GOT_ERR_BAD_PACKET);
 885                         goto done;
 886                 }
 887         }
 888
 889         if (!seen_have) {
 890                 err = send_nak(outfd, chattygot);
 891                 if (err)
 892                         goto done;
 893         }
 894
 895         if (use_sidebands) {
 896                 err = relay_progress_reports(&ibuf, outfd, chattygot);
 897                 if (err)
 898                         goto done;
 899                 pack_chunksize = GOT_SIDEBAND_64K_PACKFILE_DATA_MAX;
 900         } else
 901                 pack_chunksize = sizeof(buf);
 902
 903         for (;;) {
 904                 ssize_t r;
 905
 906                 r = read(packfd, use_sidebands ? &buf[1] : buf,
 907                     pack_chunksize);
 908                 if (r == -1) {
 909                         err = got_error_from_errno("read");
 910                         break;
 911                 } else if (r == 0) {
 912                         err = got_pkt_flushpkt(outfd, chattygot);
 913                         break;
 914                 }
 915
 916                 if (use_sidebands) {
 917                         buf[0] = GOT_SIDEBAND_PACKFILE_DATA;
 918                         err = got_pkt_writepkt(outfd, buf, 1 + r, chattygot);
 919                         if (err)
 920                                 break;
 921                 } else {
 922                         err = got_poll_write_full(outfd, buf, r);
 923                         if (err) {
 924                                 if (err->code == GOT_ERR_EOF)
 925                                         err = NULL;
 926                                 break;
 927                         }
 928                 }
 929         }
 930 done:
 931         imsg_clear(&ibuf);
 932         if (packfd != -1 && close(packfd) == -1 && err == NULL)
 933                 err = got_error_from_errno("close");
 934         if (err)
 935                 echo_error(err, outfd, chattygot);
 936         return err;
 937 }
 938
 939 static const struct got_error *
 940 parse_ref_update_line(char **common_capabilities, char **refname,
 941     uint8_t *old_id, uint8_t *new_id, char *buf, size_t len)
 942 {
 943         const struct got_error *err;
 944         char *old_id_str = NULL, *new_id_str = NULL;
 945         char *client_capabilities = NULL;
 946
 947         *refname = NULL;
 948
 949         err = got_gitproto_parse_ref_update_line(&old_id_str, &new_id_str,
 950             refname, &client_capabilities, buf, len);
 951         if (err)
 952                 return err;
 953
 954         if (!got_parse_hash_digest(old_id, old_id_str, GOT_HASH_SHA1) ||
 955             !got_parse_hash_digest(new_id, new_id_str, GOT_HASH_SHA1)) {
 956                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 957                     "ref-update with bad object ID");
 958                 goto done;
 959         }
 960         if (!got_ref_name_is_valid(*refname)) {
 961                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 962                     "ref-update with bad reference name");
 963                 goto done;
 964         }
 965
 966         if (client_capabilities) {
 967                 err = got_gitproto_match_capabilities(common_capabilities,
 968                     NULL, client_capabilities, write_capabilities,
 969                     nitems(write_capabilities));
 970                 if (err)
 971                         goto done;
 972         }
 973 done:
 974         free(old_id_str);
 975         free(new_id_str);
 976         free(client_capabilities);
 977         if (err) {
 978                 free(*refname);
 979                 *refname = NULL;
 980         }
 981         return err;
 982 }
 983
 984 static const struct got_error *
 985 recv_ref_update(int *report_status, int outfd, struct imsgbuf *ibuf,
 986     char *buf, size_t len, int expect_capabilities, int chattygot)
 987 {
 988         const struct got_error *err;
 989         struct gotd_imsg_ref_update iref;
 990         struct ibuf *wbuf;
 991         char *capabilities_str = NULL, *refname = NULL;
 992         int done = 0;
 993         struct imsg imsg;
 994
 995         memset(&iref, 0, sizeof(iref));
 996         memset(&imsg, 0, sizeof(imsg));
 997
 998         err = parse_ref_update_line(&capabilities_str, &refname,
 999             iref.old_id, iref.new_id, buf, len);
1000         if (err)
1001                 return err;
1002
1003         if (capabilities_str) {
1004                 if (!expect_capabilities) {
1005                         err = got_error_msg(GOT_ERR_BAD_PACKET,
1006                             "unexpected capability announcement received");
1007                         goto done;
1008                 }
1009                 err = send_capabilities(NULL, report_status, capabilities_str,
1010                     ibuf);
1011                 if (err)
1012                         goto done;
1013         }
1014
1015         iref.name_len = strlen(refname);
1016         len = sizeof(iref) + iref.name_len;
1017         wbuf = imsg_create(ibuf, GOTD_IMSG_REF_UPDATE, 0, 0, len);
1018         if (wbuf == NULL) {
1019                 err = got_error_from_errno("imsg_create REF_UPDATE");
1020                 goto done;
1021         }
1022
1023         if (imsg_add(wbuf, &iref, sizeof(iref)) == -1)
1024                 return got_error_from_errno("imsg_add REF_UPDATE");
1025         if (imsg_add(wbuf, refname, iref.name_len) == -1)
1026                 return got_error_from_errno("imsg_add REF_UPDATE");
1027         wbuf->fd = -1;
1028         imsg_close(ibuf, wbuf);
1029
1030         err = gotd_imsg_flush(ibuf);
1031         if (err)
1032                 goto done;
1033
1034         /* Wait for ACK or an error. */
1035         while (!done && err == NULL) {
1036                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
1037                 if (err)
1038                         break;
1039                 switch (imsg.hdr.type) {
1040                 case GOTD_IMSG_ERROR:
1041                         err = gotd_imsg_recv_error(NULL, &imsg);
1042                         break;
1043                 case GOTD_IMSG_ACK:
1044                         err = recv_ack(&imsg, iref.new_id);
1045                         if (err)
1046                                 break;
1047                         done = 1;
1048                         break;
1049                 default:
1050                         err = got_error(GOT_ERR_PRIVSEP_MSG);
1051                         break;
1052                 }
1053
1054                 imsg_free(&imsg);
1055         }
1056 done:
1057         free(capabilities_str);
1058         free(refname);
1059         return err;
1060 }
1061
1062 static const struct got_error *
1063 recv_packfile(struct imsg *imsg, int infd)
1064 {
1065         const struct got_error *err = NULL;
1066         size_t datalen;
1067         int packfd;
1068         char buf[GOT_PKT_MAX];
1069         int pack_done = 0;
1070
1071         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1072         if (datalen != 0)
1073                 return got_error(GOT_ERR_PRIVSEP_MSG);
1074
1075         if (imsg->fd == -1)
1076                 return got_error(GOT_ERR_PRIVSEP_NO_FD);
1077
1078         packfd = imsg->fd;
1079         while (!pack_done) {
1080                 ssize_t r = 0;
1081
1082                 err = got_poll_fd(infd, POLLIN, 1);
1083                 if (err) {
1084                         if (err->code != GOT_ERR_TIMEOUT)
1085                                 break;
1086                         err = NULL;
1087                 } else {
1088                         r = read(infd, buf, sizeof(buf));
1089                         if (r == -1) {
1090                                 err = got_error_from_errno("read");
1091                                 break;
1092                         }
1093                         if (r == 0) {
1094                                 /*
1095                                  * Git clients hang up their side of the
1096                                  * connection after sending the pack file.
1097                                  */
1098                                 err = NULL;
1099                                 pack_done = 1;
1100                                 break;
1101                         }
1102                 }
1103
1104                 if (r == 0) {
1105                         /* Detect gotd(8) closing the pack pipe when done. */
1106                         err = got_poll_fd(packfd, 0, 1);
1107                         if (err) {
1108                                 if (err->code != GOT_ERR_TIMEOUT &&
1109                                     err->code != GOT_ERR_EOF)
1110                                         break;
1111                                 if (err->code == GOT_ERR_EOF)
1112                                         pack_done = 1;
1113                                 err = NULL;
1114                         }
1115                 } else {
1116                         /* Write pack data and/or detect pipe being closed. */
1117                         err = got_poll_write_full(packfd, buf, r);
1118                         if (err) {
1119                                 if (err->code == GOT_ERR_EOF)
1120                                         err = NULL;
1121                                 break;
1122                         }
1123                 }
1124         }
1125
1126         close(packfd);
1127         return err;
1128 }
1129
1130 static const struct got_error *
1131 report_unpack_status(struct imsg *imsg, int outfd, int chattygot)
1132 {
1133         const struct got_error *err = NULL;
1134         struct gotd_imsg_packfile_status istatus;
1135         char buf[GOT_PKT_MAX];
1136         size_t datalen, len;
1137         char *reason = NULL;
1138
1139         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1140         if (datalen < sizeof(istatus))
1141                 return got_error(GOT_ERR_PRIVSEP_LEN);
1142         memcpy(&istatus, imsg->data, sizeof(istatus));
1143         if (datalen != sizeof(istatus) + istatus.reason_len)
1144                 return got_error(GOT_ERR_PRIVSEP_LEN);
1145
1146         reason = strndup(imsg->data + sizeof(istatus), istatus.reason_len);
1147         if (reason == NULL) {
1148                 err = got_error_from_errno("strndup");
1149                 goto done;
1150         }
1151
1152         if (err == NULL)
1153                 len = snprintf(buf, sizeof(buf), "unpack ok\n");
1154         else
1155                 len = snprintf(buf, sizeof(buf), "unpack %s\n", reason);
1156         if (len >= sizeof(buf)) {
1157                 err = got_error(GOT_ERR_NO_SPACE);
1158                 goto done;
1159         }
1160
1161         err = got_pkt_writepkt(outfd, buf, len, chattygot);
1162 done:
1163         free(reason);
1164         return err;
1165 }
1166
1167 static const struct got_error *
1168 recv_ref_update_ok(struct imsg *imsg, int outfd, int chattygot)
1169 {
1170         const struct got_error *err = NULL;
1171         struct gotd_imsg_ref_update_ok iok;
1172         size_t datalen, len;
1173         char buf[GOT_PKT_MAX];
1174         char *refname = NULL;
1175
1176         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1177         if (datalen < sizeof(iok))
1178                 return got_error(GOT_ERR_PRIVSEP_LEN);
1179         memcpy(&iok, imsg->data, sizeof(iok));
1180         if (datalen != sizeof(iok) + iok.name_len)
1181                 return got_error(GOT_ERR_PRIVSEP_LEN);
1182
1183         memcpy(&iok, imsg->data, sizeof(iok));
1184
1185         refname = strndup(imsg->data + sizeof(iok), iok.name_len);
1186         if (refname == NULL)
1187                 return got_error_from_errno("strndup");
1188
1189         len = snprintf(buf, sizeof(buf), "ok %s\n", refname);
1190         if (len >= sizeof(buf)) {
1191                 err = got_error(GOT_ERR_NO_SPACE);
1192                 goto done;
1193         }
1194
1195         err = got_pkt_writepkt(outfd, buf, len, chattygot);
1196 done:
1197         free(refname);
1198         return err;
1199 }
1200
1201 static const struct got_error *
1202 recv_ref_update_ng(struct imsg *imsg, int outfd, int chattygot)
1203 {
1204         const struct got_error *err = NULL;
1205         struct gotd_imsg_ref_update_ng ing;
1206         size_t datalen, len;
1207         char buf[GOT_PKT_MAX];
1208         char *refname = NULL, *reason = NULL;
1209
1210         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
1211         if (datalen < sizeof(ing))
1212                 return got_error(GOT_ERR_PRIVSEP_LEN);
1213         memcpy(&ing, imsg->data, sizeof(ing));
1214         if (datalen != sizeof(ing) + ing.name_len + ing.reason_len)
1215                 return got_error(GOT_ERR_PRIVSEP_LEN);
1216
1217         memcpy(&ing, imsg->data, sizeof(ing));
1218
1219         refname = strndup(imsg->data + sizeof(ing), ing.name_len);
1220         if (refname == NULL)
1221                 return got_error_from_errno("strndup");
1222
1223         reason = strndup(imsg->data + sizeof(ing) + ing.name_len,
1224             ing.reason_len);
1225         if (reason == NULL) {
1226                 err = got_error_from_errno("strndup");
1227                 goto done;
1228         }
1229
1230         len = snprintf(buf, sizeof(buf), "ng %s %s\n", refname, reason);
1231         if (len >= sizeof(buf)) {
1232                 err = got_error(GOT_ERR_NO_SPACE);
1233                 goto done;
1234         }
1235
1236         err = got_pkt_writepkt(outfd, buf, len, chattygot);
1237 done:
1238         free(refname);
1239         free(reason);
1240         return err;
1241 }
1242
1243 static const struct got_error *
1244 serve_write(int infd, int outfd, int gotd_sock, const char *repo_path,
1245     int chattygot)
1246 {
1247         const struct got_error *err = NULL;
1248         char buf[GOT_PKT_MAX];
1249         struct imsgbuf ibuf;
1250         enum protostate {
1251                 STATE_EXPECT_REF_UPDATE,
1252                 STATE_EXPECT_MORE_REF_UPDATES,
1253                 STATE_EXPECT_PACKFILE,
1254                 STATE_PACKFILE_RECEIVED,
1255                 STATE_REFS_UPDATED,
1256         };
1257         enum protostate curstate = STATE_EXPECT_REF_UPDATE;
1258         struct imsg imsg;
1259         int report_status = 0;
1260
1261         imsg_init(&ibuf, gotd_sock);
1262         memset(&imsg, 0, sizeof(imsg));
1263
1264         err = announce_refs(outfd, &ibuf, 0, repo_path, chattygot);
1265         if (err)
1266                 goto done;
1267
1268         while (curstate != STATE_EXPECT_PACKFILE) {
1269                 int n;
1270                 buf[0] = '\0';
1271                 err = got_pkt_readpkt(&n, infd, buf, sizeof(buf), chattygot);
1272                 if (err)
1273                         goto done;
1274                 if (n == 0) {
1275                         if (curstate == STATE_EXPECT_REF_UPDATE) {
1276                                 /* The client will not send us anything. */
1277                                 goto done;
1278                         } else if (curstate != STATE_EXPECT_MORE_REF_UPDATES) {
1279                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
1280                                     "unexpected flush packet received");
1281                                 goto done;
1282                         }
1283                         err = forward_flushpkt(&ibuf);
1284                         if (err)
1285                                 goto done;
1286                         curstate = STATE_EXPECT_PACKFILE;
1287                 } else if (n >= (SHA1_DIGEST_STRING_LENGTH * 2) + 2) {
1288                         if (curstate != STATE_EXPECT_REF_UPDATE &&
1289                             curstate != STATE_EXPECT_MORE_REF_UPDATES) {
1290                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
1291                                     "unexpected ref-update packet");
1292                                 goto done;
1293                         }
1294                         if (curstate == STATE_EXPECT_REF_UPDATE) {
1295                                 err = recv_ref_update(&report_status,
1296                                     outfd, &ibuf, buf, n, 1, chattygot);
1297                         } else {
1298                                 err = recv_ref_update(NULL, outfd, &ibuf,
1299                                     buf, n, 0, chattygot);
1300                         }
1301                         if (err)
1302                                 goto done;
1303                         curstate = STATE_EXPECT_MORE_REF_UPDATES;
1304                 } else {
1305                         err = got_error(GOT_ERR_BAD_PACKET);
1306                         goto done;
1307                 }
1308         }
1309
1310         while (curstate != STATE_PACKFILE_RECEIVED) {
1311                 err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
1312                 if (err)
1313                         goto done;
1314                 switch (imsg.hdr.type) {
1315                 case GOTD_IMSG_ERROR:
1316                         err = gotd_imsg_recv_error(NULL, &imsg);
1317                         goto done;
1318                 case GOTD_IMSG_PACKFILE_PIPE:
1319                         err = recv_packfile(&imsg, infd);
1320                         if (err) {
1321                                 if (err->code != GOT_ERR_EOF)
1322                                         goto done;
1323                                 /*
1324                                  * EOF is reported when the client hangs up,
1325                                  * which can happen with Git clients.
1326                                  * The socket should stay half-open so we
1327                                  * can still send our reports if requested.
1328                                  */
1329                                 err = NULL;
1330                         }
1331                         curstate = STATE_PACKFILE_RECEIVED;
1332                         break;
1333                 default:
1334                         err = got_error(GOT_ERR_PRIVSEP_MSG);
1335                         break;
1336                 }
1337
1338                 imsg_free(&imsg);
1339                 if (err)
1340                         goto done;
1341         }
1342
1343         while (curstate != STATE_REFS_UPDATED && err == NULL) {
1344                 err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
1345                 if (err)
1346                         break;
1347                 switch (imsg.hdr.type) {
1348                 case GOTD_IMSG_ERROR:
1349                         err = gotd_imsg_recv_error(NULL, &imsg);
1350                         break;
1351                 case GOTD_IMSG_PACKFILE_STATUS:
1352                         if (!report_status)
1353                                 break;
1354                         err = report_unpack_status(&imsg, outfd, chattygot);
1355                         break;
1356                 case GOTD_IMSG_REF_UPDATE_OK:
1357                         if (!report_status)
1358                                 break;
1359                         err = recv_ref_update_ok(&imsg, outfd, chattygot);
1360                         break;
1361                 case GOTD_IMSG_REF_UPDATE_NG:
1362                         if (!report_status)
1363                                 break;
1364                         err = recv_ref_update_ng(&imsg, outfd, chattygot);
1365                         break;
1366                 case GOTD_IMSG_REFS_UPDATED:
1367                         curstate = STATE_REFS_UPDATED;
1368                         err = got_pkt_flushpkt(outfd, chattygot);
1369                         break;
1370                 default:
1371                         err = got_error(GOT_ERR_PRIVSEP_MSG);
1372                         break;
1373                 }
1374
1375                 imsg_free(&imsg);
1376         }
1377 done:
1378         imsg_clear(&ibuf);
1379         if (err)
1380                 echo_error(err, outfd, chattygot);
1381         return err;
1382 }
1383
1384 const struct got_error *
1385 got_serve(int infd, int outfd, const char *command, const char *repo_path,
1386     int gotd_sock, int chattygot)
1387 {
1388         const struct got_error *err = NULL;
1389
1390         if (strcmp(command, GOT_DIAL_CMD_FETCH) == 0)
1391                 err = serve_read(infd, outfd, gotd_sock, repo_path, chattygot);
1392         else if (strcmp(command, GOT_DIAL_CMD_SEND) == 0)
1393                 err = serve_write(infd, outfd, gotd_sock, repo_path,
1394                     chattygot);
1395         else
1396                 err = got_error(GOT_ERR_BAD_PACKET);
1397
1398         return err;
1399 }