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 /*
  54  * Number of seconds until we give up trying to read more
  55  * data from the client connection.
  56  */
  57 static const int timeout = 60;
  58
  59 static const struct got_capability read_capabilities[] = {
  60         { GOT_CAPA_AGENT, "got/" GOT_VERSION_STR },
  61         { GOT_CAPA_OFS_DELTA, NULL },
  62         { GOT_CAPA_SIDE_BAND_64K, NULL },
  63 };
  64
  65 static const struct got_capability write_capabilities[] = {
  66         { GOT_CAPA_AGENT, "got/" GOT_VERSION_STR },
  67         { GOT_CAPA_OFS_DELTA, NULL },
  68         { GOT_CAPA_REPORT_STATUS, NULL },
  69         { GOT_CAPA_NO_THIN, NULL },
  70         { GOT_CAPA_DELETE_REFS, NULL },
  71 };
  72
  73 static const struct got_error *
  74 append_read_capabilities(size_t *capalen, size_t len, const char *symrefstr,
  75     uint8_t *buf, size_t bufsize)
  76 {
  77         struct got_capability capa[nitems(read_capabilities) + 1];
  78         size_t ncapa;
  79
  80         memcpy(&capa, read_capabilities, sizeof(read_capabilities));
  81         if (symrefstr) {
  82                 capa[nitems(read_capabilities)].key = "symref";
  83                 capa[nitems(read_capabilities)].value = symrefstr;
  84                 ncapa = nitems(capa);
  85         } else
  86                 ncapa = nitems(read_capabilities);
  87
  88         return got_gitproto_append_capabilities(capalen, buf, len,
  89             bufsize, capa, ncapa);
  90 }
  91
  92 static const struct got_error *
  93 send_ref(int outfd, uint8_t *id, const char *refname, int send_capabilities,
  94     int client_is_reading, const char *symrefstr, int chattygot)
  95 {
  96         const struct got_error *err = NULL;
  97         char hex[SHA1_DIGEST_STRING_LENGTH];
  98         char buf[GOT_PKT_MAX];
  99         size_t len, capalen = 0;
 100
 101         if (got_sha1_digest_to_str(id, hex, sizeof(hex)) == NULL)
 102                 return got_error(GOT_ERR_BAD_OBJ_ID);
 103
 104         len = snprintf(buf, sizeof(buf), "%s %s", hex, refname);
 105         if (len >= sizeof(buf))
 106                 return got_error(GOT_ERR_NO_SPACE);
 107
 108         if (send_capabilities) {
 109                 if (client_is_reading) {
 110                         err = append_read_capabilities(&capalen, len,
 111                             symrefstr, buf, sizeof(buf));
 112                 } else {
 113                         err = got_gitproto_append_capabilities(&capalen,
 114                             buf, len, sizeof(buf), write_capabilities,
 115                             nitems(write_capabilities));
 116                 }
 117                 if (err)
 118                         return err;
 119                 len += capalen;
 120         }
 121
 122         if (len + 1 >= sizeof(buf))
 123                 return got_error(GOT_ERR_NO_SPACE);
 124         buf[len] = '\n';
 125         len++;
 126         buf[len] = '\0';
 127
 128         return got_pkt_writepkt(outfd, buf, len, chattygot);
 129 }
 130
 131 static const struct got_error *
 132 send_zero_refs(int outfd, int client_is_reading, int chattygot)
 133 {
 134         const struct got_error *err = NULL;
 135         const char *line = GOT_SHA1_STRING_ZERO " capabilities^{}";
 136         char buf[GOT_PKT_MAX];
 137         size_t len, capalen = 0;
 138
 139         len = strlcpy(buf, line, sizeof(buf));
 140         if (len >= sizeof(buf))
 141                 return got_error(GOT_ERR_NO_SPACE);
 142
 143         if (client_is_reading) {
 144                 err = got_gitproto_append_capabilities(&capalen, buf, len,
 145                     sizeof(buf), read_capabilities, nitems(read_capabilities));
 146                 if (err)
 147                         return err;
 148         } else {
 149                 err = got_gitproto_append_capabilities(&capalen, buf, len,
 150                     sizeof(buf), write_capabilities,
 151                     nitems(write_capabilities));
 152                 if (err)
 153                         return err;
 154         }
 155
 156         return got_pkt_writepkt(outfd, buf, len + capalen, chattygot);
 157 }
 158
 159 static void
 160 echo_error(const struct got_error *err, int outfd, int chattygot)
 161 {
 162         char buf[4 + GOT_ERR_MAX_MSG_SIZE];
 163         size_t len;
 164
 165         /*
 166          * Echo the error to the client on a pkt-line.
 167          * The client should then terminate its session.
 168          */
 169         buf[0] = 'E'; buf[1] = 'R'; buf[2] = 'R'; buf[3] = ' '; buf[4] = '\0';
 170         len = strlcat(buf, err->msg, sizeof(buf));
 171         got_pkt_writepkt(outfd, buf, len, chattygot);
 172 }
 173
 174 static const struct got_error *
 175 announce_refs(int outfd, struct imsgbuf *ibuf, int client_is_reading,
 176     const char *repo_path, int chattygot)
 177 {
 178         const struct got_error *err = NULL;
 179         struct imsg imsg;
 180         size_t datalen;
 181         struct gotd_imsg_list_refs lsref;
 182         struct gotd_imsg_reflist ireflist;
 183         struct gotd_imsg_ref iref;
 184         struct gotd_imsg_symref isymref;
 185         size_t nrefs = 0;
 186         int have_nrefs = 0, sent_capabilities = 0;
 187         char *symrefname = NULL, *symreftarget = NULL, *symrefstr = NULL;
 188         char *refname = NULL;
 189
 190         memset(&imsg, 0, sizeof(imsg));
 191         memset(&lsref, 0, sizeof(lsref));
 192
 193         if (strlcpy(lsref.repo_name, repo_path, sizeof(lsref.repo_name)) >=
 194             sizeof(lsref.repo_name))
 195                 return got_error(GOT_ERR_NO_SPACE);
 196         lsref.client_is_reading = client_is_reading;
 197
 198         if (imsg_compose(ibuf, GOTD_IMSG_LIST_REFS, 0, 0, -1,
 199             &lsref, sizeof(lsref)) == -1)
 200                 return got_error_from_errno("imsg_compose LIST_REFS");
 201
 202         err = gotd_imsg_flush(ibuf);
 203         if (err)
 204                 return err;
 205
 206         while (!have_nrefs || nrefs > 0) {
 207                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 208                 if (err)
 209                         goto done;
 210                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 211                 switch (imsg.hdr.type) {
 212                 case GOTD_IMSG_ERROR:
 213                         err = gotd_imsg_recv_error(NULL, &imsg);
 214                         goto done;
 215                 case GOTD_IMSG_REFLIST:
 216                         if (have_nrefs || nrefs > 0) {
 217                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 218                                 goto done;
 219                         }
 220                         if (datalen != sizeof(ireflist)) {
 221                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 222                                 goto done;
 223                         }
 224                         memcpy(&ireflist, imsg.data, sizeof(ireflist));
 225                         nrefs = ireflist.nrefs;
 226                         have_nrefs = 1;
 227                         if (nrefs == 0)
 228                                 err = send_zero_refs(outfd, client_is_reading,
 229                                     chattygot);
 230                         break;
 231                 case GOTD_IMSG_REF:
 232                         if (!have_nrefs || nrefs == 0) {
 233                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 234                                 goto done;
 235                         }
 236                         if (datalen < sizeof(iref)) {
 237                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 238                                 goto done;
 239                         }
 240                         memcpy(&iref, imsg.data, sizeof(iref));
 241                         if (datalen != sizeof(iref) + iref.name_len) {
 242                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 243                                 goto done;
 244                         }
 245                         refname = strndup(imsg.data + sizeof(iref),
 246                             iref.name_len);
 247                         if (refname == NULL) {
 248                                 err = got_error_from_errno("strndup");
 249                                 goto done;
 250                         }
 251                         err = send_ref(outfd, iref.id, refname,
 252                             !sent_capabilities, client_is_reading,
 253                             NULL, chattygot);
 254                         free(refname);
 255                         refname = NULL;
 256                         if (err)
 257                                 goto done;
 258                         sent_capabilities = 1;
 259                         if (nrefs > 0)
 260                                 nrefs--;
 261                         break;
 262                 case GOTD_IMSG_SYMREF:
 263                         if (!have_nrefs || nrefs == 0) {
 264                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 265                                 goto done;
 266                         }
 267                         if (datalen < sizeof(isymref)) {
 268                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 269                                 goto done;
 270                         }
 271                         memcpy(&isymref, imsg.data, sizeof(isymref));
 272                         if (datalen != sizeof(isymref) + isymref.name_len +
 273                             isymref.target_len) {
 274                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 275                                 goto done;
 276                         }
 277
 278                         /*
 279                          * For now, we only announce one symbolic ref,
 280                          * as part of our capability advertisement.
 281                          */
 282                         if (sent_capabilities || symrefstr != NULL ||
 283                             symrefname != NULL || symreftarget != NULL)
 284                                 break;
 285
 286                         symrefname = strndup(imsg.data + sizeof(isymref),
 287                             isymref.name_len);
 288                         if (symrefname == NULL) {
 289                                 err = got_error_from_errno("malloc");
 290                                 goto done;
 291                         }
 292
 293                         symreftarget = strndup(
 294                             imsg.data + sizeof(isymref) + isymref.name_len,
 295                             isymref.target_len);
 296                         if (symreftarget == NULL) {
 297                                 err = got_error_from_errno("strndup");
 298                                 goto done;
 299                         }
 300
 301                         if (asprintf(&symrefstr, "%s:%s", symrefname,
 302                             symreftarget) == -1) {
 303                                 err = got_error_from_errno("asprintf");
 304                                 goto done;
 305                         }
 306                         err = send_ref(outfd, isymref.target_id, symrefname,
 307                             !sent_capabilities, client_is_reading, symrefstr,
 308                             chattygot);
 309                         free(refname);
 310                         refname = NULL;
 311                         if (err)
 312                                 goto done;
 313                         sent_capabilities = 1;
 314                         if (nrefs > 0)
 315                                 nrefs--;
 316                         break;
 317                 default:
 318                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 319                         break;
 320                 }
 321
 322                 imsg_free(&imsg);
 323         }
 324
 325         err = got_pkt_flushpkt(outfd, chattygot);
 326         if (err)
 327                 goto done;
 328 done:
 329         free(symrefstr);
 330         free(symrefname);
 331         free(symreftarget);
 332         return err;
 333 }
 334
 335 static const struct got_error *
 336 parse_want_line(char **common_capabilities, uint8_t *id, char *buf, size_t len)
 337 {
 338         const struct got_error *err;
 339         char *id_str = NULL, *client_capabilities = NULL;
 340
 341         err = got_gitproto_parse_want_line(&id_str,
 342             &client_capabilities, buf, len);
 343         if (err)
 344                 return err;
 345
 346         if (!got_parse_hash_digest(id, id_str, GOT_HASH_SHA1)) {
 347                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 348                     "want-line with bad object ID");
 349                 goto done;
 350         }
 351
 352         if (client_capabilities) {
 353                 err = got_gitproto_match_capabilities(common_capabilities,
 354                     NULL, client_capabilities, read_capabilities,
 355                     nitems(read_capabilities));
 356                 if (err)
 357                         goto done;
 358         }
 359 done:
 360         free(id_str);
 361         free(client_capabilities);
 362         return err;
 363 }
 364
 365 static const struct got_error *
 366 parse_have_line(uint8_t *id, char *buf, size_t len)
 367 {
 368         const struct got_error *err;
 369         char *id_str = NULL;
 370
 371         err = got_gitproto_parse_have_line(&id_str, buf, len);
 372         if (err)
 373                 return err;
 374
 375         if (!got_parse_hash_digest(id, id_str, GOT_HASH_SHA1)) {
 376                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 377                     "have-line with bad object ID");
 378                 goto done;
 379         }
 380 done:
 381         free(id_str);
 382         return err;
 383 }
 384
 385 static const struct got_error *
 386 send_capability(struct got_capability *capa, struct imsgbuf *ibuf)
 387 {
 388         const struct got_error *err = NULL;
 389         struct gotd_imsg_capability icapa;
 390         size_t len;
 391         struct ibuf *wbuf;
 392
 393         memset(&icapa, 0, sizeof(icapa));
 394
 395         icapa.key_len = strlen(capa->key);
 396         len = sizeof(icapa) + icapa.key_len;
 397         if (capa->value) {
 398                 icapa.value_len = strlen(capa->value);
 399                 len += icapa.value_len;
 400         }
 401
 402         wbuf = imsg_create(ibuf, GOTD_IMSG_CAPABILITY, 0, 0, len);
 403         if (wbuf == NULL) {
 404                 err = got_error_from_errno("imsg_create CAPABILITY");
 405                 return err;
 406         }
 407
 408         if (imsg_add(wbuf, &icapa, sizeof(icapa)) == -1)
 409                 return got_error_from_errno("imsg_add CAPABILITY");
 410         if (imsg_add(wbuf, capa->key, icapa.key_len) == -1)
 411                 return got_error_from_errno("imsg_add CAPABILITY");
 412         if (capa->value) {
 413                 if (imsg_add(wbuf, capa->value, icapa.value_len) == -1)
 414                         return got_error_from_errno("imsg_add CAPABILITY");
 415         }
 416
 417         imsg_close(ibuf, wbuf);
 418
 419         return NULL;
 420 }
 421
 422 static const struct got_error *
 423 send_capabilities(int *use_sidebands, int *report_status,
 424     char *capabilities_str, struct imsgbuf *ibuf)
 425 {
 426         const struct got_error *err = NULL;
 427         struct gotd_imsg_capabilities icapas;
 428         struct got_capability *capa = NULL;
 429         size_t ncapa, i;
 430
 431         err = got_gitproto_split_capabilities_str(&capa, &ncapa,
 432             capabilities_str);
 433         if (err)
 434                 return err;
 435
 436         icapas.ncapabilities = ncapa;
 437         if (imsg_compose(ibuf, GOTD_IMSG_CAPABILITIES, 0, 0, -1,
 438             &icapas, sizeof(icapas)) == -1) {
 439                 err = got_error_from_errno("imsg_compose IMSG_CAPABILITIES");
 440                 goto done;
 441         }
 442
 443         for (i = 0; i < ncapa; i++) {
 444                 err = send_capability(&capa[i], ibuf);
 445                 if (err)
 446                         goto done;
 447                 if (use_sidebands &&
 448                     strcmp(capa[i].key, GOT_CAPA_SIDE_BAND_64K) == 0)
 449                         *use_sidebands = 1;
 450                 if (report_status &&
 451                     strcmp(capa[i].key, GOT_CAPA_REPORT_STATUS) == 0)
 452                         *report_status = 1;
 453         }
 454 done:
 455         free(capa);
 456         return err;
 457 }
 458
 459 static const struct got_error *
 460 forward_flushpkt(struct imsgbuf *ibuf)
 461 {
 462         if (imsg_compose(ibuf, GOTD_IMSG_FLUSH, 0, 0, -1, NULL, 0) == -1)
 463                 return got_error_from_errno("imsg_compose FLUSH");
 464
 465         return gotd_imsg_flush(ibuf);
 466 }
 467
 468 static const struct got_error *
 469 recv_ack(struct imsg *imsg, uint8_t *expected_id)
 470 {
 471         struct gotd_imsg_ack iack;
 472         size_t datalen;
 473
 474         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 475         if (datalen != sizeof(iack))
 476                 return got_error(GOT_ERR_PRIVSEP_LEN);
 477
 478         memcpy(&iack, imsg->data, sizeof(iack));
 479         if (memcmp(iack.object_id, expected_id, SHA1_DIGEST_LENGTH) != 0)
 480                 return got_error(GOT_ERR_BAD_OBJ_ID);
 481
 482         return NULL;
 483 }
 484
 485 static const struct got_error *
 486 recv_nak(struct imsg *imsg, uint8_t *expected_id)
 487 {
 488         struct gotd_imsg_ack inak;
 489         size_t datalen;
 490
 491         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 492         if (datalen != sizeof(inak))
 493                 return got_error(GOT_ERR_PRIVSEP_LEN);
 494
 495         memcpy(&inak, imsg->data, sizeof(inak));
 496         if (memcmp(inak.object_id, expected_id, SHA1_DIGEST_LENGTH) != 0)
 497                 return got_error(GOT_ERR_BAD_OBJ_ID);
 498
 499         return NULL;
 500 }
 501
 502
 503 static const struct got_error *
 504 recv_want(int *use_sidebands, int outfd, struct imsgbuf *ibuf,
 505     char *buf, size_t len, int expect_capabilities, int chattygot)
 506 {
 507         const struct got_error *err;
 508         struct gotd_imsg_want iwant;
 509         char *capabilities_str;
 510         int done = 0;
 511         struct imsg imsg;
 512
 513         memset(&iwant, 0, sizeof(iwant));
 514         memset(&imsg, 0, sizeof(imsg));
 515
 516         err = parse_want_line(&capabilities_str, iwant.object_id, buf, len);
 517         if (err)
 518                 return err;
 519
 520         if (capabilities_str) {
 521                 if (!expect_capabilities) {
 522                         err = got_error_msg(GOT_ERR_BAD_PACKET,
 523                             "unexpected capability announcement received");
 524                         goto done;
 525                 }
 526                 err = send_capabilities(use_sidebands, NULL, capabilities_str,
 527                     ibuf);
 528                 if (err)
 529                         goto done;
 530
 531         }
 532
 533         if (imsg_compose(ibuf, GOTD_IMSG_WANT, 0, 0, -1,
 534             &iwant, sizeof(iwant)) == -1) {
 535                 err = got_error_from_errno("imsg_compose WANT");
 536                 goto done;
 537         }
 538
 539         err = gotd_imsg_flush(ibuf);
 540         if (err)
 541                 goto done;
 542
 543         /*
 544          * Wait for an ACK, or an error in case the desired object
 545          * does not exist.
 546          */
 547         while (!done && err == NULL) {
 548                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 549                 if (err)
 550                         break;
 551                 switch (imsg.hdr.type) {
 552                 case GOTD_IMSG_ERROR:
 553                         err = gotd_imsg_recv_error(NULL, &imsg);
 554                         break;
 555                 case GOTD_IMSG_ACK:
 556                         err = recv_ack(&imsg, iwant.object_id);
 557                         if (err)
 558                                 break;
 559                         done = 1;
 560                         break;
 561                 default:
 562                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 563                         break;
 564                 }
 565
 566                 imsg_free(&imsg);
 567         }
 568 done:
 569         free(capabilities_str);
 570         return err;
 571 }
 572
 573 static const struct got_error *
 574 send_ack(int outfd, uint8_t *id, int chattygot)
 575 {
 576         char hex[SHA1_DIGEST_STRING_LENGTH];
 577         char buf[GOT_PKT_MAX];
 578         int len;
 579
 580         if (got_sha1_digest_to_str(id, hex, sizeof(hex)) == NULL)
 581                 return got_error(GOT_ERR_BAD_OBJ_ID);
 582
 583         len = snprintf(buf, sizeof(buf), "ACK %s\n", hex);
 584         if (len >= sizeof(buf))
 585                 return got_error(GOT_ERR_NO_SPACE);
 586
 587         return got_pkt_writepkt(outfd, buf, len, chattygot);
 588 }
 589
 590 static const struct got_error *
 591 send_nak(int outfd, int chattygot)
 592 {
 593         char buf[5];
 594         int len;
 595
 596         len = snprintf(buf, sizeof(buf), "NAK\n");
 597         if (len >= sizeof(buf))
 598                 return got_error(GOT_ERR_NO_SPACE);
 599
 600         return got_pkt_writepkt(outfd, buf, len, chattygot);
 601 }
 602
 603 static const struct got_error *
 604 recv_have(int *have_ack, int outfd, struct imsgbuf *ibuf, char *buf,
 605     size_t len, int chattygot)
 606 {
 607         const struct got_error *err;
 608         struct gotd_imsg_have ihave;
 609         int done = 0;
 610         struct imsg imsg;
 611
 612         memset(&ihave, 0, sizeof(ihave));
 613         memset(&imsg, 0, sizeof(imsg));
 614
 615         err = parse_have_line(ihave.object_id, buf, len);
 616         if (err)
 617                 return err;
 618
 619         if (imsg_compose(ibuf, GOTD_IMSG_HAVE, 0, 0, -1,
 620             &ihave, sizeof(ihave)) == -1)
 621                 return got_error_from_errno("imsg_compose HAVE");
 622
 623         err = gotd_imsg_flush(ibuf);
 624         if (err)
 625                 return err;
 626
 627         /*
 628          * Wait for an ACK or a NAK, indicating whether a common
 629          * commit object has been found.
 630          */
 631         while (!done && err == NULL) {
 632                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 633                 if (err)
 634                         return err;
 635                 switch (imsg.hdr.type) {
 636                 case GOTD_IMSG_ERROR:
 637                         err = gotd_imsg_recv_error(NULL, &imsg);
 638                         break;
 639                 case GOTD_IMSG_ACK:
 640                         err = recv_ack(&imsg, ihave.object_id);
 641                         if (err)
 642                                 break;
 643                         if (!*have_ack) {
 644                                 err = send_ack(outfd, ihave.object_id,
 645                                     chattygot);
 646                                 if (err)
 647                                         return err;
 648                                 *have_ack = 1;
 649                         }
 650                         done = 1;
 651                         break;
 652                 case GOTD_IMSG_NAK:
 653                         err = recv_nak(&imsg, ihave.object_id);
 654                         if (err)
 655                                 break;
 656                         done = 1;
 657                         break;
 658                 default:
 659                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 660                         break;
 661                 }
 662
 663                 imsg_free(&imsg);
 664         }
 665
 666         return err;
 667 }
 668
 669 static const struct got_error *
 670 recv_done(int *packfd, int outfd, struct imsgbuf *ibuf, int chattygot)
 671 {
 672         const struct got_error *err;
 673         struct imsg imsg;
 674         int fd;
 675
 676         *packfd = -1;
 677
 678         if (imsg_compose(ibuf, GOTD_IMSG_DONE, 0, 0, -1, NULL, 0) == -1)
 679                 return got_error_from_errno("imsg_compose DONE");
 680
 681         err = gotd_imsg_flush(ibuf);
 682         if (err)
 683                 return err;
 684
 685         while (*packfd == -1 && err == NULL) {
 686                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 687                 if (err)
 688                         break;
 689
 690                 switch (imsg.hdr.type) {
 691                 case GOTD_IMSG_ERROR:
 692                         err = gotd_imsg_recv_error(NULL, &imsg);
 693                         break;
 694                 case GOTD_IMSG_PACKFILE_PIPE:
 695                         fd = imsg_get_fd(&imsg);
 696                         if (fd != -1)
 697                                 *packfd = fd;
 698                         else
 699                                 err = got_error(GOT_ERR_PRIVSEP_NO_FD);
 700                         break;
 701                 default:
 702                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 703                         break;
 704                 }
 705
 706                 imsg_free(&imsg);
 707         }
 708
 709         return err;
 710 }
 711
 712 static const struct got_error *
 713 relay_progress_reports(struct imsgbuf *ibuf, int outfd, int chattygot)
 714 {
 715         const struct got_error *err = NULL;
 716         int pack_starting = 0;
 717         struct gotd_imsg_packfile_progress iprog;
 718         char buf[GOT_PKT_MAX];
 719         struct imsg imsg;
 720         size_t datalen;
 721         int p_deltify = 0, n;
 722         const char *eol = "\r";
 723
 724         memset(&imsg, 0, sizeof(imsg));
 725
 726         while (!pack_starting && err == NULL) {
 727                 err = gotd_imsg_poll_recv(&imsg, ibuf, 0);
 728                 if (err)
 729                         break;
 730
 731                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 732                 switch (imsg.hdr.type) {
 733                 case GOTD_IMSG_ERROR:
 734                         err = gotd_imsg_recv_error(NULL, &imsg);
 735                         break;
 736                 case GOTD_IMSG_PACKFILE_READY:
 737                         eol = "\n";
 738                         pack_starting = 1;
 739                         /* fallthrough */
 740                 case GOTD_IMSG_PACKFILE_PROGRESS:
 741                         if (datalen != sizeof(iprog)) {
 742                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 743                                 break;
 744                         }
 745                         memcpy(&iprog, imsg.data, sizeof(iprog));
 746                         if (iprog.nobj_total > 0) {
 747                                 p_deltify = (iprog.nobj_deltify * 100) /
 748                                     iprog.nobj_total;
 749                         }
 750                         buf[0] = GOT_SIDEBAND_PROGRESS_INFO;
 751                         n = snprintf(&buf[1], sizeof(buf) - 1,
 752                             "%d commits colored, "
 753                             "%d objects found, "
 754                             "deltify %d%%%s",
 755                             iprog.ncolored,
 756                             iprog.nfound,
 757                             p_deltify, eol);
 758                         if (n >= sizeof(buf) - 1)
 759                                 break;
 760                         err = got_pkt_writepkt(outfd, buf, 1 + n, chattygot);
 761                         break;
 762                 default:
 763                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 764                         break;
 765                 }
 766
 767                 imsg_free(&imsg);
 768         }
 769
 770         return err;
 771 }
 772
 773 static const struct got_error *
 774 serve_read(int infd, int outfd, int gotd_sock, const char *repo_path,
 775     int chattygot)
 776 {
 777         const struct got_error *err = NULL;
 778         char buf[GOT_PKT_MAX];
 779         struct imsgbuf ibuf;
 780         enum protostate {
 781                 STATE_EXPECT_WANT,
 782                 STATE_EXPECT_MORE_WANT,
 783                 STATE_EXPECT_HAVE_OR_DONE,
 784                 STATE_DONE,
 785         };
 786         enum protostate curstate = STATE_EXPECT_WANT;
 787         int have_ack = 0, use_sidebands = 0, seen_have = 0;
 788         int packfd = -1;
 789         size_t pack_chunksize;
 790
 791         imsg_init(&ibuf, gotd_sock);
 792
 793         err = announce_refs(outfd, &ibuf, 1, repo_path, chattygot);
 794         if (err)
 795                 goto done;
 796
 797         while (curstate != STATE_DONE) {
 798                 int n;
 799                 buf[0] = '\0';
 800                 err = got_pkt_readpkt(&n, infd, buf, sizeof(buf), chattygot,
 801                     timeout);
 802                 if (err)
 803                         goto done;
 804                 if (n == 0) {
 805                         if (curstate != STATE_EXPECT_WANT &&
 806                             curstate != STATE_EXPECT_MORE_WANT &&
 807                             curstate != STATE_EXPECT_HAVE_OR_DONE) {
 808                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 809                                     "unexpected flush packet received");
 810                                 goto done;
 811                         }
 812
 813                         if (curstate == STATE_EXPECT_WANT) {
 814                                 ssize_t r;
 815                                 /*
 816                                  * If the client does not want to fetch
 817                                  * anything we should receive a flush
 818                                  * packet followed by EOF.
 819                                  */
 820                                 r = read(infd, buf, sizeof(buf));
 821                                 if (r == -1) {
 822                                         err = got_error_from_errno("read");
 823                                         goto done;
 824                                 }
 825                                 if (r == 0) /* EOF */
 826                                         goto done;
 827
 828                                 /* Zero-length field followed by payload. */
 829                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 830                                     "unexpected flush packet received");
 831                                 goto done;
 832                         }
 833
 834                         if (curstate == STATE_EXPECT_WANT ||
 835                             curstate == STATE_EXPECT_MORE_WANT ||
 836                             curstate == STATE_EXPECT_HAVE_OR_DONE) {
 837                                 err = forward_flushpkt(&ibuf);
 838                                 if (err)
 839                                         goto done;
 840                         }
 841                         if (curstate == STATE_EXPECT_HAVE_OR_DONE &&
 842                             !have_ack) {
 843                                 err = send_nak(outfd, chattygot);
 844                                 if (err)
 845                                         goto done;
 846                         }
 847                         if (curstate == STATE_EXPECT_MORE_WANT)
 848                                 curstate = STATE_EXPECT_HAVE_OR_DONE;
 849                 } else if (n >= 5 && strncmp(buf, "want ", 5) == 0) {
 850                         if (curstate != STATE_EXPECT_WANT &&
 851                             curstate != STATE_EXPECT_MORE_WANT) {
 852                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 853                                     "unexpected 'want' packet");
 854                                 goto done;
 855                         }
 856                         err = recv_want(&use_sidebands, outfd, &ibuf, buf, n,
 857                             curstate == STATE_EXPECT_WANT ? 1 : 0, chattygot);
 858                         if (err)
 859                                 goto done;
 860                         if (curstate == STATE_EXPECT_WANT)
 861                                 curstate = STATE_EXPECT_MORE_WANT;
 862                 } else if (n >= 5 && strncmp(buf, "have ", 5) == 0) {
 863                         if (curstate != STATE_EXPECT_HAVE_OR_DONE) {
 864                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 865                                     "unexpected 'have' packet");
 866                                 goto done;
 867                         }
 868                         err = recv_have(&have_ack, outfd, &ibuf,
 869                             buf, n, chattygot);
 870                         if (err)
 871                                 goto done;
 872                         seen_have = 1;
 873                 } else if (n == 5 && strncmp(buf, "done\n", 5) == 0) {
 874                         if (curstate != STATE_EXPECT_HAVE_OR_DONE) {
 875                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 876                                     "unexpected 'done' packet");
 877                                 goto done;
 878                         }
 879                         err = recv_done(&packfd, outfd, &ibuf, chattygot);
 880                         if (err)
 881                                 goto done;
 882                         curstate = STATE_DONE;
 883                         break;
 884                 } else {
 885                         err = got_error(GOT_ERR_BAD_PACKET);
 886                         goto done;
 887                 }
 888         }
 889
 890         if (!seen_have) {
 891                 err = send_nak(outfd, chattygot);
 892                 if (err)
 893                         goto done;
 894         }
 895
 896         if (use_sidebands) {
 897                 err = relay_progress_reports(&ibuf, outfd, chattygot);
 898                 if (err)
 899                         goto done;
 900                 pack_chunksize = GOT_SIDEBAND_64K_PACKFILE_DATA_MAX;
 901         } else
 902                 pack_chunksize = sizeof(buf);
 903
 904         for (;;) {
 905                 ssize_t r;
 906
 907                 r = read(packfd, use_sidebands ? &buf[1] : buf,
 908                     pack_chunksize);
 909                 if (r == -1) {
 910                         err = got_error_from_errno("read");
 911                         break;
 912                 } else if (r == 0) {
 913                         err = got_pkt_flushpkt(outfd, chattygot);
 914                         break;
 915                 }
 916
 917                 if (use_sidebands) {
 918                         buf[0] = GOT_SIDEBAND_PACKFILE_DATA;
 919                         err = got_pkt_writepkt(outfd, buf, 1 + r, chattygot);
 920                         if (err)
 921                                 break;
 922                 } else {
 923                         err = got_poll_write_full(outfd, buf, r);
 924                         if (err) {
 925                                 if (err->code == GOT_ERR_EOF)
 926                                         err = NULL;
 927                                 break;
 928                         }
 929                 }
 930         }
 931 done:
 932         imsg_clear(&ibuf);
 933         if (packfd != -1 && close(packfd) == -1 && err == NULL)
 934                 err = got_error_from_errno("close");
 935         if (err)
 936                 echo_error(err, outfd, chattygot);
 937         return err;
 938 }
 939
 940 static const struct got_error *
 941 parse_ref_update_line(char **common_capabilities, char **refname,
 942     uint8_t *old_id, uint8_t *new_id, char *buf, size_t len)
 943 {
 944         const struct got_error *err;
 945         char *old_id_str = NULL, *new_id_str = NULL;
 946         char *client_capabilities = NULL;
 947
 948         *refname = NULL;
 949
 950         err = got_gitproto_parse_ref_update_line(&old_id_str, &new_id_str,
 951             refname, &client_capabilities, buf, len);
 952         if (err)
 953                 return err;
 954
 955         if (!got_parse_hash_digest(old_id, old_id_str, GOT_HASH_SHA1) ||
 956             !got_parse_hash_digest(new_id, new_id_str, GOT_HASH_SHA1)) {
 957                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 958                     "ref-update with bad object ID");
 959                 goto done;
 960         }
 961         if (!got_ref_name_is_valid(*refname)) {
 962                 err = got_error_msg(GOT_ERR_BAD_PACKET,
 963                     "ref-update with bad reference name");
 964                 goto done;
 965         }
 966
 967         if (client_capabilities) {
 968                 err = got_gitproto_match_capabilities(common_capabilities,
 969                     NULL, client_capabilities, write_capabilities,
 970                     nitems(write_capabilities));
 971                 if (err)
 972                         goto done;
 973         }
 974 done:
 975         free(old_id_str);
 976         free(new_id_str);
 977         free(client_capabilities);
 978         if (err) {
 979                 free(*refname);
 980                 *refname = NULL;
 981         }
 982         return err;
 983 }
 984
 985 static const struct got_error *
 986 recv_ref_update(int *report_status, int outfd, struct imsgbuf *ibuf,
 987     char *buf, size_t len, int expect_capabilities, int chattygot)
 988 {
 989         const struct got_error *err;
 990         struct gotd_imsg_ref_update iref;
 991         struct ibuf *wbuf;
 992         char *capabilities_str = NULL, *refname = NULL;
 993         int done = 0;
 994         struct imsg imsg;
 995
 996         memset(&iref, 0, sizeof(iref));
 997         memset(&imsg, 0, sizeof(imsg));
 998
 999         err = parse_ref_update_line(&capabilities_str, &refname,
1000             iref.old_id, iref.new_id, buf, len);
1001         if (err)
1002                 return err;
1003
1004         if (capabilities_str) {
1005                 if (!expect_capabilities) {
1006                         err = got_error_msg(GOT_ERR_BAD_PACKET,
1007                             "unexpected capability announcement received");
1008                         goto done;
1009                 }
1010                 err = send_capabilities(NULL, report_status, capabilities_str,
1011                     ibuf);
1012                 if (err)
1013                         goto done;
1014         }
1015
1016         iref.name_len = strlen(refname);
1017         len = sizeof(iref) + iref.name_len;
1018         wbuf = imsg_create(ibuf, GOTD_IMSG_REF_UPDATE, 0, 0, len);
1019         if (wbuf == NULL) {
1020                 err = got_error_from_errno("imsg_create REF_UPDATE");
1021                 goto done;
1022         }
1023
1024         if (imsg_add(wbuf, &iref, sizeof(iref)) == -1)
1025                 return got_error_from_errno("imsg_add REF_UPDATE");
1026         if (imsg_add(wbuf, refname, iref.name_len) == -1)
1027                 return got_error_from_errno("imsg_add REF_UPDATE");
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         packfd = imsg_get_fd(imsg);
1076         if (packfd == -1)
1077                 return got_error(GOT_ERR_PRIVSEP_NO_FD);
1078
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                     timeout);
1273                 if (err)
1274                         goto done;
1275                 if (n == 0) {
1276                         if (curstate == STATE_EXPECT_REF_UPDATE) {
1277                                 /* The client will not send us anything. */
1278                                 goto done;
1279                         } else if (curstate != STATE_EXPECT_MORE_REF_UPDATES) {
1280                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
1281                                     "unexpected flush packet received");
1282                                 goto done;
1283                         }
1284                         err = forward_flushpkt(&ibuf);
1285                         if (err)
1286                                 goto done;
1287                         curstate = STATE_EXPECT_PACKFILE;
1288                 } else if (n >= (SHA1_DIGEST_STRING_LENGTH * 2) + 2) {
1289                         if (curstate != STATE_EXPECT_REF_UPDATE &&
1290                             curstate != STATE_EXPECT_MORE_REF_UPDATES) {
1291                                 err = got_error_msg(GOT_ERR_BAD_PACKET,
1292                                     "unexpected ref-update packet");
1293                                 goto done;
1294                         }
1295                         if (curstate == STATE_EXPECT_REF_UPDATE) {
1296                                 err = recv_ref_update(&report_status,
1297                                     outfd, &ibuf, buf, n, 1, chattygot);
1298                         } else {
1299                                 err = recv_ref_update(NULL, outfd, &ibuf,
1300                                     buf, n, 0, chattygot);
1301                         }
1302                         if (err)
1303                                 goto done;
1304                         curstate = STATE_EXPECT_MORE_REF_UPDATES;
1305                 } else {
1306                         err = got_error(GOT_ERR_BAD_PACKET);
1307                         goto done;
1308                 }
1309         }
1310
1311         while (curstate != STATE_PACKFILE_RECEIVED) {
1312                 err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
1313                 if (err)
1314                         goto done;
1315                 switch (imsg.hdr.type) {
1316                 case GOTD_IMSG_ERROR:
1317                         err = gotd_imsg_recv_error(NULL, &imsg);
1318                         goto done;
1319                 case GOTD_IMSG_PACKFILE_PIPE:
1320                         err = recv_packfile(&imsg, infd);
1321                         if (err) {
1322                                 if (err->code != GOT_ERR_EOF)
1323                                         goto done;
1324                                 /*
1325                                  * EOF is reported when the client hangs up,
1326                                  * which can happen with Git clients.
1327                                  * The socket should stay half-open so we
1328                                  * can still send our reports if requested.
1329                                  */
1330                                 err = NULL;
1331                         }
1332                         curstate = STATE_PACKFILE_RECEIVED;
1333                         break;
1334                 default:
1335                         err = got_error(GOT_ERR_PRIVSEP_MSG);
1336                         break;
1337                 }
1338
1339                 imsg_free(&imsg);
1340                 if (err)
1341                         goto done;
1342         }
1343
1344         while (curstate != STATE_REFS_UPDATED && err == NULL) {
1345                 err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
1346                 if (err)
1347                         break;
1348                 switch (imsg.hdr.type) {
1349                 case GOTD_IMSG_ERROR:
1350                         err = gotd_imsg_recv_error(NULL, &imsg);
1351                         break;
1352                 case GOTD_IMSG_PACKFILE_STATUS:
1353                         if (!report_status)
1354                                 break;
1355                         err = report_unpack_status(&imsg, outfd, chattygot);
1356                         break;
1357                 case GOTD_IMSG_REF_UPDATE_OK:
1358                         if (!report_status)
1359                                 break;
1360                         err = recv_ref_update_ok(&imsg, outfd, chattygot);
1361                         break;
1362                 case GOTD_IMSG_REF_UPDATE_NG:
1363                         if (!report_status)
1364                                 break;
1365                         err = recv_ref_update_ng(&imsg, outfd, chattygot);
1366                         break;
1367                 case GOTD_IMSG_REFS_UPDATED:
1368                         curstate = STATE_REFS_UPDATED;
1369                         err = got_pkt_flushpkt(outfd, chattygot);
1370                         break;
1371                 default:
1372                         err = got_error(GOT_ERR_PRIVSEP_MSG);
1373                         break;
1374                 }
1375
1376                 imsg_free(&imsg);
1377         }
1378 done:
1379         imsg_clear(&ibuf);
1380         if (err)
1381                 echo_error(err, outfd, chattygot);
1382         return err;
1383 }
1384
1385 const struct got_error *
1386 got_serve(int infd, int outfd, const char *command, const char *repo_path,
1387     int gotd_sock, int chattygot)
1388 {
1389         const struct got_error *err = NULL;
1390
1391         if (strcmp(command, GOT_DIAL_CMD_FETCH) == 0)
1392                 err = serve_read(infd, outfd, gotd_sock, repo_path, chattygot);
1393         else if (strcmp(command, GOT_DIAL_CMD_SEND) == 0)
1394                 err = serve_write(infd, outfd, gotd_sock, repo_path,
1395                     chattygot);
1396         else
1397                 err = got_error(GOT_ERR_BAD_PACKET);
1398
1399         return err;
1400 }