lib/object_open_privsep.c

   1 /*
   2  * Copyright (c) 2018, 2019, 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/mman.h>
  20 #include <sys/queue.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <sys/socket.h>
  24 #include <sys/uio.h>
  25
  26 #include <errno.h>
  27 #include <imsg.h>
  28 #include <stddef.h>
  29 #include <stdio.h>
  30 #include <stdint.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <limits.h>
  34 #include <unistd.h>
  35
  36 #include "got_error.h"
  37 #include "got_object.h"
  38 #include "got_repository.h"
  39 #include "got_opentemp.h"
  40 #include "got_path.h"
  41
  42 #include "got_lib_delta.h"
  43 #include "got_lib_object.h"
  44 #include "got_lib_hash.h"
  45 #include "got_lib_privsep.h"
  46 #include "got_lib_object_cache.h"
  47 #include "got_lib_pack.h"
  48 #include "got_lib_repository.h"
  49
  50 static const struct got_error *
  51 request_packed_object(struct got_object **obj, struct got_pack *pack, int idx,
  52     struct got_object_id *id)
  53 {
  54         const struct got_error *err = NULL;
  55         struct imsgbuf *ibuf = pack->privsep_child->ibuf;
  56
  57         err = got_privsep_send_packed_obj_req(ibuf, idx, id);
  58         if (err)
  59                 return err;
  60
  61         err = got_privsep_recv_obj(obj, ibuf);
  62         if (err)
  63                 return err;
  64
  65         memcpy(&(*obj)->id, id, sizeof((*obj)->id));
  66
  67         return NULL;
  68 }
  69
  70 /* Create temporary files used during delta application. */
  71 static const struct got_error *
  72 pack_child_send_tempfiles(struct imsgbuf *ibuf, struct got_pack *pack)
  73 {
  74         const struct got_error *err;
  75         int basefd = -1, accumfd = -1;
  76
  77         /*
  78          * For performance reasons, the child will keep reusing the
  79          * same temporary files during every object request.
  80          * Opening and closing new files for every object request is
  81          * too expensive during operations such as 'gotadmin pack'.
  82          */
  83         if (pack->child_has_tempfiles)
  84                 return NULL;
  85
  86         basefd = dup(pack->basefd);
  87         if (basefd == -1)
  88                 return got_error_from_errno("dup");
  89
  90         accumfd = dup(pack->accumfd);
  91         if (accumfd == -1) {
  92                 err = got_error_from_errno("dup");
  93                 goto done;
  94         }
  95
  96         err = got_privsep_send_tmpfd(ibuf, basefd);
  97         if (err)
  98                 goto done;
  99
 100         err = got_privsep_send_tmpfd(ibuf, accumfd);
 101 done:
 102         if (err) {
 103                 if (basefd != -1)
 104                         close(basefd);
 105                 if (accumfd != -1)
 106                         close(accumfd);
 107         } else
 108                 pack->child_has_tempfiles = 1;
 109         return err;
 110 }
 111
 112 static const struct got_error *
 113 request_packed_object_raw(uint8_t **outbuf, off_t *size, size_t *hdrlen,
 114     int outfd, struct got_pack *pack, int idx, struct got_object_id *id)
 115 {
 116         const struct got_error *err = NULL;
 117         struct imsgbuf *ibuf = pack->privsep_child->ibuf;
 118         int outfd_child;
 119
 120         err = pack_child_send_tempfiles(ibuf, pack);
 121         if (err)
 122                 return err;
 123
 124         outfd_child = dup(outfd);
 125         if (outfd_child == -1)
 126                 return got_error_from_errno("dup");
 127
 128         err = got_privsep_send_packed_raw_obj_req(ibuf, idx, id);
 129         if (err) {
 130                 close(outfd_child);
 131                 return err;
 132         }
 133
 134         err = got_privsep_send_raw_obj_outfd(ibuf, outfd_child);
 135         if (err)
 136                 return err;
 137
 138         err = got_privsep_recv_raw_obj(outbuf, size, hdrlen, ibuf);
 139         if (err)
 140                 return err;
 141
 142         return NULL;
 143 }
 144
 145 static const struct got_error *
 146 read_packed_object_privsep(struct got_object **obj,
 147     struct got_repository *repo, struct got_pack *pack,
 148     struct got_packidx *packidx, int idx, struct got_object_id *id)
 149 {
 150         const struct got_error *err = NULL;
 151
 152         if (pack->privsep_child == NULL) {
 153                 err = got_pack_start_privsep_child(pack, packidx);
 154                 if (err)
 155                         return err;
 156         }
 157
 158         return request_packed_object(obj, pack, idx, id);
 159 }
 160
 161 static const struct got_error *
 162 read_packed_object_raw_privsep(uint8_t **outbuf, off_t *size, size_t *hdrlen,
 163     int outfd, struct got_pack *pack, struct got_packidx *packidx, int idx,
 164     struct got_object_id *id)
 165 {
 166         const struct got_error *err = NULL;
 167
 168         if (pack->privsep_child == NULL) {
 169                 err = got_pack_start_privsep_child(pack, packidx);
 170                 if (err)
 171                         return err;
 172         }
 173
 174         return request_packed_object_raw(outbuf, size, hdrlen, outfd, pack,
 175             idx, id);
 176 }
 177
 178 const struct got_error *
 179 got_object_open_packed(struct got_object **obj, struct got_object_id *id,
 180     struct got_repository *repo)
 181 {
 182         const struct got_error *err = NULL;
 183         struct got_pack *pack = NULL;
 184         struct got_packidx *packidx = NULL;
 185         int idx;
 186         char *path_packfile;
 187
 188         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 189         if (err)
 190                 return err;
 191
 192         err = got_packidx_get_packfile_path(&path_packfile,
 193             packidx->path_packidx);
 194         if (err)
 195                 return err;
 196
 197         pack = got_repo_get_cached_pack(repo, path_packfile);
 198         if (pack == NULL) {
 199                 err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
 200                 if (err)
 201                         goto done;
 202         }
 203
 204         err = read_packed_object_privsep(obj, repo, pack, packidx, idx, id);
 205         if (err)
 206                 goto done;
 207 done:
 208         free(path_packfile);
 209         return err;
 210 }
 211
 212 const struct got_error *
 213 got_object_open_from_packfile(struct got_object **obj, struct got_object_id *id,
 214     struct got_pack *pack, struct got_packidx *packidx, int obj_idx,
 215     struct got_repository *repo)
 216 {
 217         return read_packed_object_privsep(obj, repo, pack, packidx,
 218             obj_idx, id);
 219 }
 220
 221 const struct got_error *
 222 got_object_read_raw_delta(uint64_t *base_size, uint64_t *result_size,
 223     off_t *delta_size, off_t *delta_compressed_size, off_t *delta_offset,
 224     off_t *delta_out_offset, struct got_object_id **base_id, int delta_cache_fd,
 225     struct got_packidx *packidx, int obj_idx, struct got_object_id *id,
 226     struct got_repository *repo)
 227 {
 228         const struct got_error *err = NULL;
 229         struct got_pack *pack = NULL;
 230         char *path_packfile;
 231
 232         *base_size = 0;
 233         *result_size = 0;
 234         *delta_size = 0;
 235         *delta_compressed_size = 0;
 236         *delta_offset = 0;
 237         *delta_out_offset = 0;
 238
 239         err = got_packidx_get_packfile_path(&path_packfile,
 240             packidx->path_packidx);
 241         if (err)
 242                 return err;
 243
 244         pack = got_repo_get_cached_pack(repo, path_packfile);
 245         if (pack == NULL) {
 246                 err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
 247                 if (err)
 248                         return err;
 249         }
 250
 251         if (pack->privsep_child == NULL) {
 252                 err = got_pack_start_privsep_child(pack, packidx);
 253                 if (err)
 254                         return err;
 255         }
 256
 257         if (!pack->child_has_delta_outfd) {
 258                 int outfd_child;
 259                 outfd_child = dup(delta_cache_fd);
 260                 if (outfd_child == -1)
 261                         return got_error_from_errno("dup");
 262                 err = got_privsep_send_raw_delta_outfd(
 263                     pack->privsep_child->ibuf, outfd_child);
 264                 if (err)
 265                         return err;
 266                 pack->child_has_delta_outfd = 1;
 267         }
 268
 269         err = got_privsep_send_raw_delta_req(pack->privsep_child->ibuf,
 270             obj_idx, id);
 271         if (err)
 272                 return err;
 273
 274         return got_privsep_recv_raw_delta(base_size, result_size, delta_size,
 275             delta_compressed_size, delta_offset, delta_out_offset, base_id,
 276             pack->privsep_child->ibuf);
 277 }
 278
 279 static const struct got_error *
 280 request_object(struct got_object **obj, struct got_object_id *id,
 281     struct got_repository *repo, int fd)
 282 {
 283         const struct got_error *err = NULL;
 284         struct imsgbuf *ibuf;
 285
 286         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
 287
 288         err = got_privsep_send_obj_req(ibuf, fd, id);
 289         if (err)
 290                 return err;
 291
 292         return got_privsep_recv_obj(obj, ibuf);
 293 }
 294
 295 static const struct got_error *
 296 request_raw_object(uint8_t **outbuf, off_t *size, size_t *hdrlen, int outfd,
 297     struct got_object_id *id, struct got_repository *repo, int infd)
 298 {
 299         const struct got_error *err = NULL;
 300         struct imsgbuf *ibuf;
 301         int outfd_child;
 302
 303         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
 304
 305         outfd_child = dup(outfd);
 306         if (outfd_child == -1)
 307                 return got_error_from_errno("dup");
 308
 309         err = got_privsep_send_raw_obj_req(ibuf, infd, id);
 310         if (err)
 311                 return err;
 312
 313         err = got_privsep_send_raw_obj_outfd(ibuf, outfd_child);
 314         if (err)
 315                 return err;
 316
 317         return got_privsep_recv_raw_obj(outbuf, size, hdrlen, ibuf);
 318 }
 319
 320 static const struct got_error *
 321 start_child(struct got_repository *repo, int type)
 322 {
 323         const struct got_error *err = NULL;
 324         int imsg_fds[2];
 325         pid_t pid;
 326         struct imsgbuf *ibuf;
 327         const char *prog_path;
 328
 329         switch (type) {
 330         case GOT_REPO_PRIVSEP_CHILD_OBJECT:
 331                 prog_path = GOT_PATH_PROG_READ_OBJECT;
 332                 break;
 333         case GOT_REPO_PRIVSEP_CHILD_TREE:
 334                 prog_path = GOT_PATH_PROG_READ_TREE;
 335                 break;
 336         case GOT_REPO_PRIVSEP_CHILD_COMMIT:
 337                 prog_path = GOT_PATH_PROG_READ_COMMIT;
 338                 break;
 339         case GOT_REPO_PRIVSEP_CHILD_BLOB:
 340                 prog_path = GOT_PATH_PROG_READ_BLOB;
 341                 break;
 342         case GOT_REPO_PRIVSEP_CHILD_TAG:
 343                 prog_path = GOT_PATH_PROG_READ_TAG;
 344                 break;
 345         default:
 346                 return got_error(GOT_ERR_OBJ_TYPE);
 347         }
 348
 349         ibuf = calloc(1, sizeof(*ibuf));
 350         if (ibuf == NULL)
 351                 return got_error_from_errno("calloc");
 352
 353         if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
 354                 err = got_error_from_errno("socketpair");
 355                 free(ibuf);
 356                 return err;
 357         }
 358
 359         pid = fork();
 360         if (pid == -1) {
 361                 err = got_error_from_errno("fork");
 362                 close(imsg_fds[0]);
 363                 close(imsg_fds[1]);
 364                 free(ibuf);
 365                 return err;
 366         }
 367         else if (pid == 0) {
 368                 got_privsep_exec_child(imsg_fds, prog_path, repo->path);
 369                 /* not reached */
 370         }
 371
 372         if (close(imsg_fds[1]) == -1) {
 373                 err = got_error_from_errno("close");
 374                 close(imsg_fds[0]);
 375                 free(ibuf);
 376                 return err;
 377         }
 378
 379         repo->privsep_children[type].imsg_fd = imsg_fds[0];
 380         repo->privsep_children[type].pid = pid;
 381         imsg_init(ibuf, imsg_fds[0]);
 382         repo->privsep_children[type].ibuf = ibuf;
 383
 384         return NULL;
 385 }
 386
 387 const struct got_error *
 388 got_object_read_header_privsep(struct got_object **obj,
 389     struct got_object_id *id, struct got_repository *repo, int obj_fd)
 390 {
 391         const struct got_error *err;
 392
 393         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
 394                 return request_object(obj, id, repo, obj_fd);
 395
 396         err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_OBJECT);
 397         if (err)
 398                 return err;
 399
 400         return request_object(obj, id, repo, obj_fd);
 401 }
 402
 403 static const struct got_error *
 404 read_object_raw_privsep(uint8_t **outbuf, off_t *size, size_t *hdrlen,
 405     int outfd, struct got_object_id *id, struct got_repository *repo,
 406     int obj_fd)
 407 {
 408         const struct got_error *err;
 409
 410         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
 411                 return request_raw_object(outbuf, size, hdrlen, outfd, id,
 412                     repo, obj_fd);
 413
 414         err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_OBJECT);
 415         if (err)
 416                 return err;
 417
 418         return request_raw_object(outbuf, size, hdrlen, outfd, id, repo,
 419             obj_fd);
 420 }
 421
 422 const struct got_error *
 423 got_object_open(struct got_object **obj, struct got_repository *repo,
 424     struct got_object_id *id)
 425 {
 426         const struct got_error *err = NULL;
 427         int fd;
 428
 429         *obj = got_repo_get_cached_object(repo, id);
 430         if (*obj != NULL) {
 431                 (*obj)->refcnt++;
 432                 return NULL;
 433         }
 434
 435         err = got_object_open_packed(obj, id, repo);
 436         if (err && err->code != GOT_ERR_NO_OBJ)
 437                 return err;
 438         if (*obj) {
 439                 (*obj)->refcnt++;
 440                 return got_repo_cache_object(repo, id, *obj);
 441         }
 442
 443         err = got_object_open_loose_fd(&fd, id, repo);
 444         if (err)
 445                 return err;
 446
 447         err = got_object_read_header_privsep(obj, id, repo, fd);
 448         if (err)
 449                 return err;
 450
 451         memcpy(&(*obj)->id, id, sizeof(*id));
 452
 453         (*obj)->refcnt++;
 454         return got_repo_cache_object(repo, id, *obj);
 455 }
 456
 457 /* *outfd must be initialized to -1 by caller */
 458 const struct got_error *
 459 got_object_raw_open(struct got_raw_object **obj, int *outfd,
 460     struct got_repository *repo, struct got_object_id *id)
 461 {
 462         const struct got_error *err = NULL;
 463         struct got_packidx *packidx = NULL;
 464         int idx;
 465         uint8_t *outbuf = NULL;
 466         off_t size = 0;
 467         size_t hdrlen = 0;
 468         char *path_packfile = NULL;
 469
 470         *obj = got_repo_get_cached_raw_object(repo, id);
 471         if (*obj != NULL) {
 472                 (*obj)->refcnt++;
 473                 return NULL;
 474         }
 475
 476         if (*outfd == -1) {
 477                 *outfd = got_opentempfd();
 478                 if (*outfd == -1)
 479                         return got_error_from_errno("got_opentempfd");
 480         }
 481
 482         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 483         if (err == NULL) {
 484                 struct got_pack *pack = NULL;
 485
 486                 err = got_packidx_get_packfile_path(&path_packfile,
 487                     packidx->path_packidx);
 488                 if (err)
 489                         goto done;
 490
 491                 pack = got_repo_get_cached_pack(repo, path_packfile);
 492                 if (pack == NULL) {
 493                         err = got_repo_cache_pack(&pack, repo, path_packfile,
 494                             packidx);
 495                         if (err)
 496                                 goto done;
 497                 }
 498                 err = read_packed_object_raw_privsep(&outbuf, &size, &hdrlen,
 499                     *outfd, pack, packidx, idx, id);
 500                 if (err)
 501                         goto done;
 502         } else if (err->code == GOT_ERR_NO_OBJ) {
 503                 int fd;
 504
 505                 err = got_object_open_loose_fd(&fd, id, repo);
 506                 if (err)
 507                         goto done;
 508                 err = read_object_raw_privsep(&outbuf, &size, &hdrlen, *outfd,
 509                     id, repo, fd);
 510                 if (err)
 511                         goto done;
 512         }
 513
 514         err = got_object_raw_alloc(obj, outbuf, outfd,
 515             GOT_DELTA_RESULT_SIZE_CACHED_MAX, hdrlen, size);
 516         if (err)
 517                 goto done;
 518
 519         err = got_repo_cache_raw_object(repo, id, *obj);
 520 done:
 521         free(path_packfile);
 522         if (err) {
 523                 if (*obj) {
 524                         got_object_raw_close(*obj);
 525                         *obj = NULL;
 526                 }
 527                 free(outbuf);
 528         }
 529         return err;
 530 }
 531
 532 static const struct got_error *
 533 request_packed_commit(struct got_commit_object **commit, struct got_pack *pack,
 534     int pack_idx, struct got_object_id *id)
 535 {
 536         const struct got_error *err = NULL;
 537
 538         err = got_privsep_send_commit_req(pack->privsep_child->ibuf, -1, id,
 539             pack_idx);
 540         if (err)
 541                 return err;
 542
 543         err = got_privsep_recv_commit(commit, pack->privsep_child->ibuf);
 544         if (err)
 545                 return err;
 546
 547         (*commit)->flags |= GOT_COMMIT_FLAG_PACKED;
 548         return NULL;
 549 }
 550
 551 static const struct got_error *
 552 read_packed_commit_privsep(struct got_commit_object **commit,
 553     struct got_pack *pack, struct got_packidx *packidx, int idx,
 554     struct got_object_id *id)
 555 {
 556         const struct got_error *err = NULL;
 557
 558         if (pack->privsep_child)
 559                 return request_packed_commit(commit, pack, idx, id);
 560
 561         err = got_pack_start_privsep_child(pack, packidx);
 562         if (err)
 563                 return err;
 564
 565         return request_packed_commit(commit, pack, idx, id);
 566 }
 567
 568 static const struct got_error *
 569 request_commit(struct got_commit_object **commit, struct got_repository *repo,
 570     int fd, struct got_object_id *id)
 571 {
 572         const struct got_error *err = NULL;
 573         struct imsgbuf *ibuf;
 574
 575         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf;
 576
 577         err = got_privsep_send_commit_req(ibuf, fd, id, -1);
 578         if (err)
 579                 return err;
 580
 581         return got_privsep_recv_commit(commit, ibuf);
 582 }
 583
 584 static const struct got_error *
 585 read_commit_privsep(struct got_commit_object **commit, int obj_fd,
 586     struct got_object_id *id, struct got_repository *repo)
 587 {
 588         const struct got_error *err;
 589
 590         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd != -1)
 591                 return request_commit(commit, repo, obj_fd, id);
 592
 593         err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_COMMIT);
 594         if (err)
 595                 return err;
 596
 597         return request_commit(commit, repo, obj_fd, id);
 598 }
 599
 600 static const struct got_error *
 601 open_commit(struct got_commit_object **commit,
 602     struct got_repository *repo, struct got_object_id *id, int check_cache)
 603 {
 604         const struct got_error *err = NULL;
 605         struct got_packidx *packidx = NULL;
 606         int idx;
 607         char *path_packfile = NULL;
 608
 609         if (check_cache) {
 610                 *commit = got_repo_get_cached_commit(repo, id);
 611                 if (*commit != NULL) {
 612                         (*commit)->refcnt++;
 613                         return NULL;
 614                 }
 615         } else
 616                 *commit = NULL;
 617
 618         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 619         if (err == NULL) {
 620                 struct got_pack *pack = NULL;
 621
 622                 err = got_packidx_get_packfile_path(&path_packfile,
 623                     packidx->path_packidx);
 624                 if (err)
 625                         return err;
 626
 627                 pack = got_repo_get_cached_pack(repo, path_packfile);
 628                 if (pack == NULL) {
 629                         err = got_repo_cache_pack(&pack, repo, path_packfile,
 630                             packidx);
 631                         if (err)
 632                                 goto done;
 633                 }
 634                 err = read_packed_commit_privsep(commit, pack,
 635                     packidx, idx, id);
 636         } else if (err->code == GOT_ERR_NO_OBJ) {
 637                 int fd;
 638
 639                 err = got_object_open_loose_fd(&fd, id, repo);
 640                 if (err)
 641                         return err;
 642                 err = read_commit_privsep(commit, fd, id, repo);
 643         }
 644
 645         if (err == NULL) {
 646                 (*commit)->refcnt++;
 647                 err = got_repo_cache_commit(repo, id, *commit);
 648         }
 649 done:
 650         free(path_packfile);
 651         return err;
 652 }
 653
 654 const struct got_error *
 655 got_object_open_as_commit(struct got_commit_object **commit,
 656     struct got_repository *repo, struct got_object_id *id)
 657 {
 658         *commit = got_repo_get_cached_commit(repo, id);
 659         if (*commit != NULL) {
 660                 (*commit)->refcnt++;
 661                 return NULL;
 662         }
 663
 664         return open_commit(commit, repo, id, 0);
 665 }
 666
 667 const struct got_error *
 668 got_object_commit_open(struct got_commit_object **commit,
 669     struct got_repository *repo, struct got_object *obj)
 670 {
 671         return open_commit(commit, repo, got_object_get_id(obj), 1);
 672 }
 673
 674 static const struct got_error *
 675 request_packed_tree(struct got_tree_object **tree, struct got_pack *pack,
 676     int pack_idx, struct got_object_id *id)
 677 {
 678         const struct got_error *err = NULL;
 679
 680         err = got_privsep_send_tree_req(pack->privsep_child->ibuf, -1, id,
 681             pack_idx);
 682         if (err)
 683                 return err;
 684
 685         return got_privsep_recv_tree(tree, pack->privsep_child->ibuf);
 686 }
 687
 688 static const struct got_error *
 689 read_packed_tree_privsep(struct got_tree_object **tree,
 690     struct got_pack *pack, struct got_packidx *packidx, int idx,
 691     struct got_object_id *id)
 692 {
 693         const struct got_error *err = NULL;
 694
 695         if (pack->privsep_child)
 696                 return request_packed_tree(tree, pack, idx, id);
 697
 698         err = got_pack_start_privsep_child(pack, packidx);
 699         if (err)
 700                 return err;
 701
 702         return request_packed_tree(tree, pack, idx, id);
 703 }
 704
 705 static const struct got_error *
 706 request_tree(struct got_tree_object **tree, struct got_repository *repo,
 707     int fd, struct got_object_id *id)
 708 {
 709         const struct got_error *err = NULL;
 710         struct imsgbuf *ibuf;
 711
 712         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf;
 713
 714         err = got_privsep_send_tree_req(ibuf, fd, id, -1);
 715         if (err)
 716                 return err;
 717
 718         return got_privsep_recv_tree(tree, ibuf);
 719 }
 720
 721 static const struct got_error *
 722 read_tree_privsep(struct got_tree_object **tree, int obj_fd,
 723     struct got_object_id *id, struct got_repository *repo)
 724 {
 725         const struct got_error *err;
 726
 727         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd != -1)
 728                 return request_tree(tree, repo, obj_fd, id);
 729
 730         err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_TREE);
 731         if (err)
 732                 return err;
 733
 734         return request_tree(tree, repo, obj_fd, id);
 735 }
 736
 737 static const struct got_error *
 738 open_tree(struct got_tree_object **tree, struct got_repository *repo,
 739     struct got_object_id *id, int check_cache)
 740 {
 741         const struct got_error *err = NULL;
 742         struct got_packidx *packidx = NULL;
 743         int idx;
 744         char *path_packfile = NULL;
 745
 746         if (check_cache) {
 747                 *tree = got_repo_get_cached_tree(repo, id);
 748                 if (*tree != NULL) {
 749                         (*tree)->refcnt++;
 750                         return NULL;
 751                 }
 752         } else
 753                 *tree = NULL;
 754
 755         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 756         if (err == NULL) {
 757                 struct got_pack *pack = NULL;
 758
 759                 err = got_packidx_get_packfile_path(&path_packfile,
 760                     packidx->path_packidx);
 761                 if (err)
 762                         return err;
 763
 764                 pack = got_repo_get_cached_pack(repo, path_packfile);
 765                 if (pack == NULL) {
 766                         err = got_repo_cache_pack(&pack, repo, path_packfile,
 767                             packidx);
 768                         if (err)
 769                                 goto done;
 770                 }
 771                 err = read_packed_tree_privsep(tree, pack,
 772                     packidx, idx, id);
 773         } else if (err->code == GOT_ERR_NO_OBJ) {
 774                 int fd;
 775
 776                 err = got_object_open_loose_fd(&fd, id, repo);
 777                 if (err)
 778                         return err;
 779                 err = read_tree_privsep(tree, fd, id, repo);
 780         }
 781
 782         if (err == NULL) {
 783                 (*tree)->refcnt++;
 784                 err = got_repo_cache_tree(repo, id, *tree);
 785         }
 786 done:
 787         free(path_packfile);
 788         return err;
 789 }
 790
 791 const struct got_error *
 792 got_object_open_as_tree(struct got_tree_object **tree,
 793     struct got_repository *repo, struct got_object_id *id)
 794 {
 795         *tree = got_repo_get_cached_tree(repo, id);
 796         if (*tree != NULL) {
 797                 (*tree)->refcnt++;
 798                 return NULL;
 799         }
 800
 801         return open_tree(tree, repo, id, 0);
 802 }
 803
 804 const struct got_error *
 805 got_object_tree_open(struct got_tree_object **tree,
 806     struct got_repository *repo, struct got_object *obj)
 807 {
 808         return open_tree(tree, repo, got_object_get_id(obj), 1);
 809 }
 810
 811 static const struct got_error *
 812 request_packed_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen, int outfd,
 813     struct got_pack *pack, struct got_packidx *packidx, int idx,
 814     struct got_object_id *id)
 815 {
 816         const struct got_error *err = NULL;
 817         struct imsgbuf *ibuf = pack->privsep_child->ibuf;
 818         int outfd_child;
 819
 820         err = pack_child_send_tempfiles(ibuf, pack);
 821         if (err)
 822                 return err;
 823
 824         outfd_child = dup(outfd);
 825         if (outfd_child == -1)
 826                 return got_error_from_errno("dup");
 827
 828         err = got_privsep_send_blob_req(pack->privsep_child->ibuf, -1, id, idx);
 829         if (err)
 830                 return err;
 831
 832         err = got_privsep_send_blob_outfd(pack->privsep_child->ibuf,
 833             outfd_child);
 834         if (err) {
 835                 return err;
 836         }
 837
 838         err = got_privsep_recv_blob(outbuf, size, hdrlen,
 839             pack->privsep_child->ibuf);
 840         if (err)
 841                 return err;
 842
 843         if (lseek(outfd, SEEK_SET, 0) == -1)
 844                 err = got_error_from_errno("lseek");
 845
 846         return err;
 847 }
 848
 849 static const struct got_error *
 850 read_packed_blob_privsep(uint8_t **outbuf, size_t *size, size_t *hdrlen,
 851     int outfd, struct got_pack *pack, struct got_packidx *packidx, int idx,
 852     struct got_object_id *id)
 853 {
 854         const struct got_error *err = NULL;
 855
 856         if (pack->privsep_child == NULL) {
 857                 err = got_pack_start_privsep_child(pack, packidx);
 858                 if (err)
 859                         return err;
 860         }
 861
 862         return request_packed_blob(outbuf, size, hdrlen, outfd, pack, packidx,
 863             idx, id);
 864 }
 865
 866 static const struct got_error *
 867 request_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen, int outfd,
 868     int infd, struct got_object_id *id, struct imsgbuf *ibuf)
 869 {
 870         const struct got_error *err = NULL;
 871         int outfd_child;
 872
 873         outfd_child = dup(outfd);
 874         if (outfd_child == -1)
 875                 return got_error_from_errno("dup");
 876
 877         err = got_privsep_send_blob_req(ibuf, infd, id, -1);
 878         if (err)
 879                 return err;
 880
 881         err = got_privsep_send_blob_outfd(ibuf, outfd_child);
 882         if (err)
 883                 return err;
 884
 885         err = got_privsep_recv_blob(outbuf, size, hdrlen, ibuf);
 886         if (err)
 887                 return err;
 888
 889         if (lseek(outfd, SEEK_SET, 0) == -1)
 890                 return got_error_from_errno("lseek");
 891
 892         return err;
 893 }
 894
 895 static const struct got_error *
 896 read_blob_privsep(uint8_t **outbuf, size_t *size, size_t *hdrlen,
 897     int outfd, int infd, struct got_object_id *id, struct got_repository *repo)
 898 {
 899         const struct got_error *err;
 900         struct imsgbuf *ibuf;
 901
 902         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd != -1) {
 903                 ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
 904                 return request_blob(outbuf, size, hdrlen, outfd, infd, id,
 905                     ibuf);
 906         }
 907
 908         err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_BLOB);
 909         if (err)
 910                 return err;
 911
 912         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
 913         return request_blob(outbuf, size, hdrlen, outfd, infd, id, ibuf);
 914 }
 915
 916 static const struct got_error *
 917 open_blob(struct got_blob_object **blob, struct got_repository *repo,
 918     struct got_object_id *id, size_t blocksize, int outfd)
 919 {
 920         const struct got_error *err = NULL;
 921         struct got_packidx *packidx = NULL;
 922         int idx, dfd = -1;
 923         char *path_packfile = NULL;
 924         uint8_t *outbuf;
 925         size_t size, hdrlen;
 926         struct stat sb;
 927
 928         *blob = calloc(1, sizeof(**blob));
 929         if (*blob == NULL)
 930                 return got_error_from_errno("calloc");
 931
 932         (*blob)->read_buf = malloc(blocksize);
 933         if ((*blob)->read_buf == NULL) {
 934                 err = got_error_from_errno("malloc");
 935                 goto done;
 936         }
 937
 938         if (ftruncate(outfd, 0L) == -1) {
 939                 err = got_error_from_errno("ftruncate");
 940                 goto done;
 941         }
 942         if (lseek(outfd, SEEK_SET, 0) == -1) {
 943                 err = got_error_from_errno("lseek");
 944                 goto done;
 945         }
 946
 947         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 948         if (err == NULL) {
 949                 struct got_pack *pack = NULL;
 950
 951                 err = got_packidx_get_packfile_path(&path_packfile,
 952                     packidx->path_packidx);
 953                 if (err)
 954                         goto done;
 955
 956                 pack = got_repo_get_cached_pack(repo, path_packfile);
 957                 if (pack == NULL) {
 958                         err = got_repo_cache_pack(&pack, repo, path_packfile,
 959                             packidx);
 960                         if (err)
 961                                 goto done;
 962                 }
 963                 err = read_packed_blob_privsep(&outbuf, &size, &hdrlen, outfd,
 964                     pack, packidx, idx, id);
 965         } else if (err->code == GOT_ERR_NO_OBJ) {
 966                 int infd;
 967
 968                 err = got_object_open_loose_fd(&infd, id, repo);
 969                 if (err)
 970                         goto done;
 971                 err = read_blob_privsep(&outbuf, &size, &hdrlen, outfd, infd,
 972                     id, repo);
 973         }
 974         if (err)
 975                 goto done;
 976
 977         if (hdrlen > size) {
 978                 err = got_error(GOT_ERR_BAD_OBJ_HDR);
 979                 goto done;
 980         }
 981
 982         if (outbuf && size > 0) {
 983                 (*blob)->f = fmemopen(outbuf, size, "rb");
 984                 if ((*blob)->f == NULL) {
 985                         err = got_error_from_errno("fmemopen");
 986                         free(outbuf);
 987                         goto done;
 988                 }
 989                 (*blob)->data = outbuf;
 990         } else {
 991                 if (fstat(outfd, &sb) == -1) {
 992                         err = got_error_from_errno("fstat");
 993                         goto done;
 994                 }
 995
 996                 if (sb.st_size != size) {
 997                         err = got_error(GOT_ERR_PRIVSEP_LEN);
 998                         goto done;
 999                 }
1000
1001                 dfd = dup(outfd);
1002                 if (dfd == -1) {
1003                         err = got_error_from_errno("dup");
1004                         goto done;
1005                 }
1006
1007                 (*blob)->f = fdopen(dfd, "rb");
1008                 if ((*blob)->f == NULL) {
1009                         err = got_error_from_errno("fdopen");
1010                         close(dfd);
1011                         dfd = -1;
1012                         goto done;
1013                 }
1014         }
1015
1016         (*blob)->hdrlen = hdrlen;
1017         (*blob)->blocksize = blocksize;
1018         memcpy(&(*blob)->id, id, sizeof(*id));
1019
1020 done:
1021         free(path_packfile);
1022         if (err) {
1023                 if (*blob) {
1024                         got_object_blob_close(*blob);
1025                         *blob = NULL;
1026                 }
1027         }
1028         return err;
1029 }
1030
1031 const struct got_error *
1032 got_object_open_as_blob(struct got_blob_object **blob,
1033     struct got_repository *repo, struct got_object_id *id, size_t blocksize,
1034     int outfd)
1035 {
1036         return open_blob(blob, repo, id, blocksize, outfd);
1037 }
1038
1039 const struct got_error *
1040 got_object_blob_open(struct got_blob_object **blob,
1041     struct got_repository *repo, struct got_object *obj, size_t blocksize,
1042     int outfd)
1043 {
1044         return open_blob(blob, repo, got_object_get_id(obj), blocksize, outfd);
1045 }
1046
1047 static const struct got_error *
1048 request_packed_tag(struct got_tag_object **tag, struct got_pack *pack,
1049     int pack_idx, struct got_object_id *id)
1050 {
1051         const struct got_error *err = NULL;
1052
1053         err = got_privsep_send_tag_req(pack->privsep_child->ibuf, -1, id,
1054             pack_idx);
1055         if (err)
1056                 return err;
1057
1058         return got_privsep_recv_tag(tag, pack->privsep_child->ibuf);
1059 }
1060
1061 static const struct got_error *
1062 read_packed_tag_privsep(struct got_tag_object **tag,
1063     struct got_pack *pack, struct got_packidx *packidx, int idx,
1064     struct got_object_id *id)
1065 {
1066         const struct got_error *err = NULL;
1067
1068         if (pack->privsep_child)
1069                 return request_packed_tag(tag, pack, idx, id);
1070
1071         err = got_pack_start_privsep_child(pack, packidx);
1072         if (err)
1073                 return err;
1074
1075         return request_packed_tag(tag, pack, idx, id);
1076 }
1077
1078 static const struct got_error *
1079 request_tag(struct got_tag_object **tag, struct got_repository *repo,
1080     int fd, struct got_object_id *id)
1081 {
1082         const struct got_error *err = NULL;
1083         struct imsgbuf *ibuf;
1084
1085         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].ibuf;
1086
1087         err = got_privsep_send_tag_req(ibuf, fd, id, -1);
1088         if (err)
1089                 return err;
1090
1091         return got_privsep_recv_tag(tag, ibuf);
1092 }
1093
1094 static const struct got_error *
1095 read_tag_privsep(struct got_tag_object **tag, int obj_fd,
1096     struct got_object_id *id, struct got_repository *repo)
1097 {
1098         const struct got_error *err;
1099
1100         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].imsg_fd != -1)
1101                 return request_tag(tag, repo, obj_fd, id);
1102
1103         err = start_child(repo, GOT_REPO_PRIVSEP_CHILD_TAG);
1104         if (err)
1105                 return err;
1106
1107         return request_tag(tag, repo, obj_fd, id);
1108 }
1109
1110 static const struct got_error *
1111 open_tag(struct got_tag_object **tag, struct got_repository *repo,
1112     struct got_object_id *id, int check_cache)
1113 {
1114         const struct got_error *err = NULL;
1115         struct got_packidx *packidx = NULL;
1116         int idx;
1117         char *path_packfile = NULL;
1118         struct got_object *obj = NULL;
1119         int obj_type = GOT_OBJ_TYPE_ANY;
1120
1121         if (check_cache) {
1122                 *tag = got_repo_get_cached_tag(repo, id);
1123                 if (*tag != NULL) {
1124                         (*tag)->refcnt++;
1125                         return NULL;
1126                 }
1127         } else
1128                 *tag = NULL;
1129
1130         err = got_repo_search_packidx(&packidx, &idx, repo, id);
1131         if (err == NULL) {
1132                 struct got_pack *pack = NULL;
1133
1134                 err = got_packidx_get_packfile_path(&path_packfile,
1135                     packidx->path_packidx);
1136                 if (err)
1137                         return err;
1138
1139                 pack = got_repo_get_cached_pack(repo, path_packfile);
1140                 if (pack == NULL) {
1141                         err = got_repo_cache_pack(&pack, repo, path_packfile,
1142                             packidx);
1143                         if (err)
1144                                 goto done;
1145                 }
1146
1147                 /* Beware of "lightweight" tags: Check object type first. */
1148                 err = read_packed_object_privsep(&obj, repo, pack, packidx,
1149                     idx, id);
1150                 if (err)
1151                         goto done;
1152                 obj_type = obj->type;
1153                 got_object_close(obj);
1154                 if (obj_type != GOT_OBJ_TYPE_TAG) {
1155                         err = got_error(GOT_ERR_OBJ_TYPE);
1156                         goto done;
1157                 }
1158                 err = read_packed_tag_privsep(tag, pack, packidx, idx, id);
1159         } else if (err->code == GOT_ERR_NO_OBJ) {
1160                 int fd;
1161
1162                 err = got_object_open_loose_fd(&fd, id, repo);
1163                 if (err)
1164                         return err;
1165                 err = got_object_read_header_privsep(&obj, id, repo, fd);
1166                 if (err)
1167                         return err;
1168                 obj_type = obj->type;
1169                 got_object_close(obj);
1170                 if (obj_type != GOT_OBJ_TYPE_TAG)
1171                         return got_error(GOT_ERR_OBJ_TYPE);
1172
1173                 err = got_object_open_loose_fd(&fd, id, repo);
1174                 if (err)
1175                         return err;
1176                 err = read_tag_privsep(tag, fd, id, repo);
1177         }
1178
1179         if (err == NULL) {
1180                 (*tag)->refcnt++;
1181                 err = got_repo_cache_tag(repo, id, *tag);
1182         }
1183 done:
1184         free(path_packfile);
1185         return err;
1186 }
1187
1188 const struct got_error *
1189 got_object_open_as_tag(struct got_tag_object **tag,
1190     struct got_repository *repo, struct got_object_id *id)
1191 {
1192         *tag = got_repo_get_cached_tag(repo, id);
1193         if (*tag != NULL) {
1194                 (*tag)->refcnt++;
1195                 return NULL;
1196         }
1197
1198         return open_tag(tag, repo, id, 0);
1199 }
1200
1201 const struct got_error *
1202 got_object_tag_open(struct got_tag_object **tag,
1203     struct got_repository *repo, struct got_object *obj)
1204 {
1205         return open_tag(tag, repo, got_object_get_id(obj), 1);
1206 }
1207
1208 const struct got_error *
1209 got_traverse_packed_commits(struct got_object_id_queue *traversed_commits,
1210     struct got_object_id *commit_id, const char *path,
1211     struct got_repository *repo)
1212 {
1213         const struct got_error *err = NULL;
1214         struct got_pack *pack = NULL;
1215         struct got_packidx *packidx = NULL;
1216         char *path_packfile = NULL;
1217         struct got_commit_object *changed_commit = NULL;
1218         struct got_object_qid *changed_commit_qid = NULL;
1219         int idx;
1220
1221         err = got_repo_search_packidx(&packidx, &idx, repo, commit_id);
1222         if (err) {
1223                 if (err->code != GOT_ERR_NO_OBJ)
1224                         return err;
1225                 return NULL;
1226         }
1227
1228         err = got_packidx_get_packfile_path(&path_packfile,
1229             packidx->path_packidx);
1230         if (err)
1231                 return err;
1232
1233         pack = got_repo_get_cached_pack(repo, path_packfile);
1234         if (pack == NULL) {
1235                 err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
1236                 if (err)
1237                         goto done;
1238         }
1239
1240         if (pack->privsep_child == NULL) {
1241                 err = got_pack_start_privsep_child(pack, packidx);
1242                 if (err)
1243                         goto done;
1244         }
1245
1246         err = got_privsep_send_commit_traversal_request(
1247             pack->privsep_child->ibuf, commit_id, idx, path);
1248         if (err)
1249                 goto done;
1250
1251         err = got_privsep_recv_traversed_commits(&changed_commit,
1252             traversed_commits, pack->privsep_child->ibuf);
1253         if (err)
1254                 goto done;
1255
1256         if (changed_commit) {
1257                 /*
1258                  * Cache the commit in which the path was changed.
1259                  * This commit might be opened again soon.
1260                  */
1261                 changed_commit->refcnt++;
1262                 changed_commit_qid = STAILQ_LAST(traversed_commits, got_object_qid, entry);
1263                 err = got_repo_cache_commit(repo, &changed_commit_qid->id,
1264                     changed_commit);
1265                 got_object_commit_close(changed_commit);
1266         }
1267 done:
1268         free(path_packfile);
1269         return err;
1270 }
1271
1272 const struct got_error *
1273 got_object_enumerate(int *found_all_objects,
1274     got_object_enumerate_commit_cb cb_commit,
1275     got_object_enumerate_tree_cb cb_tree, void *cb_arg,
1276     struct got_object_id **ours, int nours,
1277     struct got_object_id **theirs, int ntheirs,
1278     struct got_packidx *packidx, struct got_repository *repo)
1279 {
1280         const struct got_error *err = NULL;
1281         struct got_pack *pack;
1282         char *path_packfile = NULL;
1283
1284         err = got_packidx_get_packfile_path(&path_packfile,
1285             packidx->path_packidx);
1286         if (err)
1287                 return err;
1288
1289         pack = got_repo_get_cached_pack(repo, path_packfile);
1290         if (pack == NULL) {
1291                 err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
1292                 if (err)
1293                         goto done;
1294         }
1295
1296         if (pack->privsep_child == NULL) {
1297                 err = got_pack_start_privsep_child(pack, packidx);
1298                 if (err)
1299                         goto done;
1300         }
1301
1302         err = got_privsep_send_object_enumeration_request(
1303             pack->privsep_child->ibuf);
1304         if (err)
1305                 goto done;
1306
1307         err = got_privsep_send_object_idlist(pack->privsep_child->ibuf,
1308             ours, nours);
1309         if (err)
1310                 goto done;
1311         err = got_privsep_send_object_idlist_done(pack->privsep_child->ibuf);
1312         if (err)
1313                 goto done;
1314
1315         err = got_privsep_send_object_idlist(pack->privsep_child->ibuf,
1316             theirs, ntheirs);
1317         if (err)
1318                 goto done;
1319         err = got_privsep_send_object_idlist_done(pack->privsep_child->ibuf);
1320         if (err)
1321                 goto done;
1322
1323         err = got_privsep_recv_enumerated_objects(found_all_objects,
1324             pack->privsep_child->ibuf, cb_commit, cb_tree, cb_arg, repo);
1325 done:
1326         free(path_packfile);
1327         return err;
1328 }