libexec/got-send-pack/got-send-pack.c

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