lib/object.c

   1 /*
   2  * Copyright (c) 2018, 2019 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 <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <sys/uio.h>
  20 #include <sys/socket.h>
  21 #include <sys/wait.h>
  22 #include <sys/resource.h>
  23
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <stdint.h>
  30 #include <unistd.h>
  31 #include <zlib.h>
  32 #include <ctype.h>
  33 #include <libgen.h>
  34 #include <limits.h>
  35 #include <time.h>
  36
  37 #include "got_compat.h"
  38
  39 #include "got_error.h"
  40 #include "got_object.h"
  41 #include "got_repository.h"
  42 #include "got_opentemp.h"
  43 #include "got_path.h"
  44
  45 #include "got_lib_sha1.h"
  46 #include "got_lib_delta.h"
  47 #include "got_lib_inflate.h"
  48 #include "got_lib_object.h"
  49 #include "got_lib_privsep.h"
  50 #include "got_lib_object_idcache.h"
  51 #include "got_lib_object_cache.h"
  52 #include "got_lib_object_parse.h"
  53 #include "got_lib_pack.h"
  54 #include "got_lib_repository.h"
  55
  56 #ifndef MIN
  57 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
  58 #endif
  59
  60 struct got_object_id *
  61 got_object_get_id(struct got_object *obj)
  62 {
  63         return &obj->id;
  64 }
  65
  66 const struct got_error *
  67 got_object_get_id_str(char **outbuf, struct got_object *obj)
  68 {
  69         return got_object_id_str(outbuf, &obj->id);
  70 }
  71
  72 const struct got_error *
  73 got_object_get_type(int *type, struct got_repository *repo,
  74     struct got_object_id *id)
  75 {
  76         const struct got_error *err = NULL;
  77         struct got_object *obj;
  78
  79         err = got_object_open(&obj, repo, id);
  80         if (err)
  81                 return err;
  82
  83         switch (obj->type) {
  84         case GOT_OBJ_TYPE_COMMIT:
  85         case GOT_OBJ_TYPE_TREE:
  86         case GOT_OBJ_TYPE_BLOB:
  87         case GOT_OBJ_TYPE_TAG:
  88                 *type = obj->type;
  89                 break;
  90         default:
  91                 err = got_error(GOT_ERR_OBJ_TYPE);
  92                 break;
  93         }
  94
  95         got_object_close(obj);
  96         return err;
  97 }
  98
  99 const struct got_error *
 100 got_object_get_path(char **path, struct got_object_id *id,
 101     struct got_repository *repo)
 102 {
 103         const struct got_error *err = NULL;
 104         char *hex = NULL;
 105         char *path_objects;
 106
 107         *path = NULL;
 108
 109         path_objects = got_repo_get_path_objects(repo);
 110         if (path_objects == NULL)
 111                 return got_error_from_errno("got_repo_get_path_objects");
 112
 113         err = got_object_id_str(&hex, id);
 114         if (err)
 115                 goto done;
 116
 117         if (asprintf(path, "%s/%.2x/%s", path_objects,
 118             id->sha1[0], hex + 2) == -1)
 119                 err = got_error_from_errno("asprintf");
 120
 121 done:
 122         free(hex);
 123         free(path_objects);
 124         return err;
 125 }
 126
 127 const struct got_error *
 128 got_object_open_loose_fd(int *fd, struct got_object_id *id,
 129     struct got_repository *repo)
 130 {
 131         const struct got_error *err = NULL;
 132         char *path;
 133
 134         err = got_object_get_path(&path, id, repo);
 135         if (err)
 136                 return err;
 137         *fd = open(path, O_RDONLY | O_NOFOLLOW);
 138         if (*fd == -1) {
 139                 err = got_error_from_errno2("open", path);
 140                 goto done;
 141         }
 142 done:
 143         free(path);
 144         return err;
 145 }
 146
 147 static const struct got_error *
 148 request_packed_object(struct got_object **obj, struct got_pack *pack, int idx,
 149     struct got_object_id *id)
 150 {
 151         const struct got_error *err = NULL;
 152         struct imsgbuf *ibuf = pack->privsep_child->ibuf;
 153
 154         err = got_privsep_send_packed_obj_req(ibuf, idx, id);
 155         if (err)
 156                 return err;
 157
 158         err = got_privsep_recv_obj(obj, ibuf);
 159         if (err)
 160                 return err;
 161
 162         memcpy(&(*obj)->id, id, sizeof((*obj)->id));
 163
 164         return NULL;
 165 }
 166
 167 static const struct got_error *
 168 request_packed_object_raw(uint8_t **outbuf, off_t *size, size_t *hdrlen,
 169     int outfd, struct got_pack *pack, int idx, struct got_object_id *id)
 170 {
 171         const struct got_error *err = NULL;
 172         struct imsgbuf *ibuf = pack->privsep_child->ibuf;
 173         int outfd_child;
 174         int basefd, accumfd; /* temporary files for delta application */
 175
 176         basefd = got_opentempfd();
 177         if (basefd == -1)
 178                 return got_error_from_errno("got_opentempfd");
 179
 180         accumfd = got_opentempfd();
 181         if (accumfd == -1) {
 182                 close(basefd);
 183                 return got_error_from_errno("got_opentempfd");
 184         }
 185
 186         outfd_child = dup(outfd);
 187         if (outfd_child == -1) {
 188                 err = got_error_from_errno("dup");
 189                 close(basefd);
 190                 close(accumfd);
 191                 return err;
 192         }
 193
 194         err = got_privsep_send_packed_raw_obj_req(ibuf, idx, id);
 195         if (err) {
 196                 close(basefd);
 197                 close(accumfd);
 198                 close(outfd_child);
 199                 return err;
 200         }
 201
 202         err = got_privsep_send_raw_obj_outfd(ibuf, outfd_child);
 203         if (err) {
 204                 close(basefd);
 205                 close(accumfd);
 206                 return err;
 207         }
 208
 209
 210         err = got_privsep_send_tmpfd(pack->privsep_child->ibuf,
 211             basefd);
 212         if (err) {
 213                 close(accumfd);
 214                 return err;
 215         }
 216
 217         err = got_privsep_send_tmpfd(pack->privsep_child->ibuf,
 218             accumfd);
 219         if (err)
 220                 return err;
 221
 222         err = got_privsep_recv_raw_obj(outbuf, size, hdrlen, ibuf);
 223         if (err)
 224                 return err;
 225
 226         return NULL;
 227 }
 228
 229 static void
 230 set_max_datasize(void)
 231 {
 232         struct rlimit rl;
 233
 234         if (getrlimit(RLIMIT_DATA, &rl) != 0)
 235                 return;
 236
 237         rl.rlim_cur = rl.rlim_max;
 238         setrlimit(RLIMIT_DATA, &rl);
 239 }
 240
 241 static const struct got_error *
 242 start_pack_privsep_child(struct got_pack *pack, struct got_packidx *packidx)
 243 {
 244         const struct got_error *err = NULL;
 245         int imsg_fds[2];
 246         pid_t pid;
 247         struct imsgbuf *ibuf;
 248
 249         ibuf = calloc(1, sizeof(*ibuf));
 250         if (ibuf == NULL)
 251                 return got_error_from_errno("calloc");
 252
 253         pack->privsep_child = calloc(1, sizeof(*pack->privsep_child));
 254         if (pack->privsep_child == NULL) {
 255                 err = got_error_from_errno("calloc");
 256                 free(ibuf);
 257                 return err;
 258         }
 259
 260         if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
 261                 err = got_error_from_errno("socketpair");
 262                 goto done;
 263         }
 264
 265         pid = fork();
 266         if (pid == -1) {
 267                 err = got_error_from_errno("fork");
 268                 goto done;
 269         } else if (pid == 0) {
 270                 set_max_datasize();
 271                 got_privsep_exec_child(imsg_fds, GOT_PATH_PROG_READ_PACK,
 272                     pack->path_packfile);
 273                 /* not reached */
 274         }
 275
 276         if (close(imsg_fds[1]) == -1)
 277                 return got_error_from_errno("close");
 278         pack->privsep_child->imsg_fd = imsg_fds[0];
 279         pack->privsep_child->pid = pid;
 280         imsg_init(ibuf, imsg_fds[0]);
 281         pack->privsep_child->ibuf = ibuf;
 282
 283         err = got_privsep_init_pack_child(ibuf, pack, packidx);
 284         if (err) {
 285                 const struct got_error *child_err;
 286                 err = got_privsep_send_stop(pack->privsep_child->imsg_fd);
 287                 child_err = got_privsep_wait_for_child(
 288                     pack->privsep_child->pid);
 289                 if (child_err && err == NULL)
 290                         err = child_err;
 291         }
 292 done:
 293         if (err) {
 294                 free(ibuf);
 295                 free(pack->privsep_child);
 296                 pack->privsep_child = NULL;
 297         }
 298         return err;
 299 }
 300
 301 static const struct got_error *
 302 read_packed_object_privsep(struct got_object **obj,
 303     struct got_repository *repo, struct got_pack *pack,
 304     struct got_packidx *packidx, int idx, struct got_object_id *id)
 305 {
 306         const struct got_error *err = NULL;
 307
 308         if (pack->privsep_child == NULL) {
 309                 err = start_pack_privsep_child(pack, packidx);
 310                 if (err)
 311                         return err;
 312         }
 313
 314         return request_packed_object(obj, pack, idx, id);
 315 }
 316
 317 static const struct got_error *
 318 read_packed_object_raw_privsep(uint8_t **outbuf, off_t *size, size_t *hdrlen,
 319     int outfd, struct got_pack *pack, struct got_packidx *packidx, int idx,
 320     struct got_object_id *id)
 321 {
 322         const struct got_error *err = NULL;
 323
 324         if (pack->privsep_child == NULL) {
 325                 err = start_pack_privsep_child(pack, packidx);
 326                 if (err)
 327                         return err;
 328         }
 329
 330         return request_packed_object_raw(outbuf, size, hdrlen, outfd, pack,
 331             idx, id);
 332 }
 333
 334 const struct got_error *
 335 got_object_open_packed(struct got_object **obj, struct got_object_id *id,
 336     struct got_repository *repo)
 337 {
 338         const struct got_error *err = NULL;
 339         struct got_pack *pack = NULL;
 340         struct got_packidx *packidx = NULL;
 341         int idx;
 342         char *path_packfile;
 343
 344         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 345         if (err)
 346                 return err;
 347
 348         err = got_packidx_get_packfile_path(&path_packfile,
 349             packidx->path_packidx);
 350         if (err)
 351                 return err;
 352
 353         pack = got_repo_get_cached_pack(repo, path_packfile);
 354         if (pack == NULL) {
 355                 err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
 356                 if (err)
 357                         goto done;
 358         }
 359
 360         err = read_packed_object_privsep(obj, repo, pack, packidx, idx, id);
 361         if (err)
 362                 goto done;
 363 done:
 364         free(path_packfile);
 365         return err;
 366 }
 367
 368 static const struct got_error *
 369 request_object(struct got_object **obj, struct got_object_id *id,
 370     struct got_repository *repo, int fd)
 371 {
 372         const struct got_error *err = NULL;
 373         struct imsgbuf *ibuf;
 374
 375         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
 376
 377         err = got_privsep_send_obj_req(ibuf, fd, id);
 378         if (err)
 379                 return err;
 380
 381         return got_privsep_recv_obj(obj, ibuf);
 382 }
 383
 384 static const struct got_error *
 385 request_raw_object(uint8_t **outbuf, off_t *size, size_t *hdrlen, int outfd,
 386     struct got_object_id *id, struct got_repository *repo, int infd)
 387 {
 388         const struct got_error *err = NULL;
 389         struct imsgbuf *ibuf;
 390         int outfd_child;
 391
 392         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf;
 393
 394         outfd_child = dup(outfd);
 395         if (outfd_child == -1)
 396                 return got_error_from_errno("dup");
 397
 398         err = got_privsep_send_raw_obj_req(ibuf, infd, id);
 399         if (err)
 400                 return err;
 401
 402         err = got_privsep_send_raw_obj_outfd(ibuf, outfd_child);
 403         if (err)
 404                 return err;
 405
 406         return got_privsep_recv_raw_obj(outbuf, size, hdrlen, ibuf);
 407 }
 408
 409 static const struct got_error *
 410 start_read_object_child(struct got_repository *repo)
 411 {
 412         const struct got_error *err = NULL;
 413         int imsg_fds[2];
 414         pid_t pid;
 415         struct imsgbuf *ibuf;
 416
 417         ibuf = calloc(1, sizeof(*ibuf));
 418         if (ibuf == NULL)
 419                 return got_error_from_errno("calloc");
 420
 421         if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
 422                 err = got_error_from_errno("socketpair");
 423                 free(ibuf);
 424                 return err;
 425         }
 426
 427         pid = fork();
 428         if (pid == -1) {
 429                 err = got_error_from_errno("fork");
 430                 free(ibuf);
 431                 return err;
 432         }
 433         else if (pid == 0) {
 434                 got_privsep_exec_child(imsg_fds, GOT_PATH_PROG_READ_OBJECT,
 435                     repo->path);
 436                 /* not reached */
 437         }
 438
 439         if (close(imsg_fds[1]) == -1) {
 440                 err = got_error_from_errno("close");
 441                 free(ibuf);
 442                 return err;
 443         }
 444
 445         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd =
 446             imsg_fds[0];
 447         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].pid = pid;
 448         imsg_init(ibuf, imsg_fds[0]);
 449         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].ibuf = ibuf;
 450
 451         return NULL;
 452 }
 453
 454 const struct got_error *
 455 got_object_read_header_privsep(struct got_object **obj,
 456     struct got_object_id *id, struct got_repository *repo, int obj_fd)
 457 {
 458         const struct got_error *err;
 459
 460         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
 461                 return request_object(obj, id, repo, obj_fd);
 462
 463         err = start_read_object_child(repo);
 464         if (err) {
 465                 close(obj_fd);
 466                 return err;
 467         }
 468
 469         return request_object(obj, id, repo, obj_fd);
 470 }
 471
 472 static const struct got_error *
 473 read_object_raw_privsep(uint8_t **outbuf, off_t *size, size_t *hdrlen,
 474     int outfd, struct got_object_id *id, struct got_repository *repo,
 475     int obj_fd)
 476 {
 477         const struct got_error *err;
 478
 479         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_OBJECT].imsg_fd != -1)
 480                 return request_raw_object(outbuf, size, hdrlen, outfd, id,
 481                     repo, obj_fd);
 482
 483         err = start_read_object_child(repo);
 484         if (err)
 485                 return err;
 486
 487         return request_raw_object(outbuf, size, hdrlen, outfd, id, repo,
 488             obj_fd);
 489 }
 490
 491 const struct got_error *
 492 got_object_open(struct got_object **obj, struct got_repository *repo,
 493     struct got_object_id *id)
 494 {
 495         const struct got_error *err = NULL;
 496         int fd;
 497
 498         *obj = got_repo_get_cached_object(repo, id);
 499         if (*obj != NULL) {
 500                 (*obj)->refcnt++;
 501                 return NULL;
 502         }
 503
 504         err = got_object_open_packed(obj, id, repo);
 505         if (err && err->code != GOT_ERR_NO_OBJ)
 506                 return err;
 507         if (*obj) {
 508                 (*obj)->refcnt++;
 509                 return got_repo_cache_object(repo, id, *obj);
 510         }
 511
 512         err = got_object_open_loose_fd(&fd, id, repo);
 513         if (err) {
 514                 if (err->code == GOT_ERR_ERRNO && errno == ENOENT)
 515                         err = got_error_no_obj(id);
 516                 return err;
 517         }
 518
 519         err = got_object_read_header_privsep(obj, id, repo, fd);
 520         if (err)
 521                 return err;
 522
 523         memcpy((*obj)->id.sha1, id->sha1, SHA1_DIGEST_LENGTH);
 524
 525         (*obj)->refcnt++;
 526         return got_repo_cache_object(repo, id, *obj);
 527 }
 528
 529 const struct got_error *
 530 got_object_raw_open(struct got_raw_object **obj, struct got_repository *repo,
 531     struct got_object_id *id, size_t blocksize)
 532 {
 533         const struct got_error *err = NULL;
 534         struct got_packidx *packidx = NULL;
 535         int idx;
 536         uint8_t *outbuf = NULL;
 537         int outfd = -1;
 538         off_t size = 0;
 539         size_t hdrlen = 0;
 540         char *path_packfile = NULL;
 541
 542         *obj = NULL;
 543
 544         outfd = got_opentempfd();
 545         if (outfd == -1)
 546                 return got_error_from_errno("got_opentempfd");
 547
 548         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 549         if (err == NULL) {
 550                 struct got_pack *pack = NULL;
 551
 552                 err = got_packidx_get_packfile_path(&path_packfile,
 553                     packidx->path_packidx);
 554                 if (err)
 555                         goto done;
 556
 557                 pack = got_repo_get_cached_pack(repo, path_packfile);
 558                 if (pack == NULL) {
 559                         err = got_repo_cache_pack(&pack, repo, path_packfile,
 560                             packidx);
 561                         if (err)
 562                                 goto done;
 563                 }
 564                 err = read_packed_object_raw_privsep(&outbuf, &size, &hdrlen,
 565                     outfd, pack, packidx, idx, id);
 566         } else if (err->code == GOT_ERR_NO_OBJ) {
 567                 int fd;
 568
 569                 err = got_object_open_loose_fd(&fd, id, repo);
 570                 if (err)
 571                         goto done;
 572                 err = read_object_raw_privsep(&outbuf, &size, &hdrlen, outfd,
 573                     id, repo, fd);
 574         }
 575
 576         *obj = calloc(1, sizeof(**obj));
 577         if (*obj == NULL) {
 578                 err = got_error_from_errno("calloc");
 579                 goto done;
 580         }
 581
 582         (*obj)->read_buf = malloc(blocksize);
 583         if ((*obj)->read_buf == NULL) {
 584                 err = got_error_from_errno("malloc");
 585                 goto done;
 586         }
 587
 588         if (outbuf) {
 589                 if (close(outfd) == -1) {
 590                         err = got_error_from_errno("close");
 591                         goto done;
 592                 }
 593                 outfd = -1;
 594                 (*obj)->f = fmemopen(outbuf, hdrlen + size, "r");
 595                 if ((*obj)->f == NULL) {
 596                         err = got_error_from_errno("fdopen");
 597                         goto done;
 598                 }
 599                 (*obj)->data = outbuf;
 600         } else {
 601                 struct stat sb;
 602                 if (fstat(outfd, &sb) == -1) {
 603                         err = got_error_from_errno("fstat");
 604                         goto done;
 605                 }
 606
 607                 if (sb.st_size != hdrlen + size) {
 608                         err = got_error(GOT_ERR_PRIVSEP_LEN);
 609                         goto done;
 610                 }
 611
 612                 (*obj)->f = fdopen(outfd, "r");
 613                 if ((*obj)->f == NULL) {
 614                         err = got_error_from_errno("fdopen");
 615                         goto done;
 616                 }
 617                 outfd = -1;
 618                 (*obj)->data = NULL;
 619         }
 620         (*obj)->hdrlen = hdrlen;
 621         (*obj)->size = size;
 622         (*obj)->blocksize = blocksize;
 623 done:
 624         free(path_packfile);
 625         if (err) {
 626                 if (*obj) {
 627                         got_object_raw_close(*obj);
 628                         *obj = NULL;
 629                 }
 630                 if (outfd != -1)
 631                         close(outfd);
 632                 free(outbuf);
 633         }
 634         return err;
 635 }
 636
 637 void
 638 got_object_raw_rewind(struct got_raw_object *obj)
 639 {
 640         if (obj->f)
 641                 rewind(obj->f);
 642 }
 643
 644 size_t
 645 got_object_raw_get_hdrlen(struct got_raw_object *obj)
 646 {
 647         return obj->hdrlen;
 648 }
 649
 650 const uint8_t *
 651 got_object_raw_get_read_buf(struct got_raw_object *obj)
 652 {
 653         return obj->read_buf;
 654 }
 655
 656 const struct got_error *
 657 got_object_raw_read_block(size_t *outlenp, struct got_raw_object *obj)
 658 {
 659         size_t n;
 660
 661         n = fread(obj->read_buf, 1, obj->blocksize, obj->f);
 662         if (n == 0 && ferror(obj->f))
 663                 return got_ferror(obj->f, GOT_ERR_IO);
 664         *outlenp = n;
 665         return NULL;
 666 }
 667
 668 const struct got_error *
 669 got_object_raw_close(struct got_raw_object *obj)
 670 {
 671         const struct got_error *err = NULL;
 672
 673         free(obj->read_buf);
 674         if (obj->f != NULL && fclose(obj->f) == EOF && err == NULL)
 675                 err = got_error_from_errno("fclose");
 676         free(obj->data);
 677         free(obj);
 678         return err;
 679 }
 680
 681 const struct got_error *
 682 got_object_open_by_id_str(struct got_object **obj, struct got_repository *repo,
 683     const char *id_str)
 684 {
 685         struct got_object_id id;
 686
 687         if (!got_parse_sha1_digest(id.sha1, id_str))
 688                 return got_error_path(id_str, GOT_ERR_BAD_OBJ_ID_STR);
 689
 690         return got_object_open(obj, repo, &id);
 691 }
 692
 693 const struct got_error *
 694 got_object_resolve_id_str(struct got_object_id **id,
 695     struct got_repository *repo, const char *id_str)
 696 {
 697         const struct got_error *err = NULL;
 698         struct got_object *obj;
 699
 700         err = got_object_open_by_id_str(&obj, repo, id_str);
 701         if (err)
 702                 return err;
 703
 704         *id = got_object_id_dup(got_object_get_id(obj));
 705         got_object_close(obj);
 706         if (*id == NULL)
 707                 return got_error_from_errno("got_object_id_dup");
 708
 709         return NULL;
 710 }
 711
 712 static const struct got_error *
 713 request_packed_commit(struct got_commit_object **commit, struct got_pack *pack,
 714     int pack_idx, struct got_object_id *id)
 715 {
 716         const struct got_error *err = NULL;
 717
 718         err = got_privsep_send_commit_req(pack->privsep_child->ibuf, -1, id,
 719             pack_idx);
 720         if (err)
 721                 return err;
 722
 723         err = got_privsep_recv_commit(commit, pack->privsep_child->ibuf);
 724         if (err)
 725                 return err;
 726
 727         (*commit)->flags |= GOT_COMMIT_FLAG_PACKED;
 728         return NULL;
 729 }
 730
 731 static const struct got_error *
 732 read_packed_commit_privsep(struct got_commit_object **commit,
 733     struct got_pack *pack, struct got_packidx *packidx, int idx,
 734     struct got_object_id *id)
 735 {
 736         const struct got_error *err = NULL;
 737
 738         if (pack->privsep_child)
 739                 return request_packed_commit(commit, pack, idx, id);
 740
 741         err = start_pack_privsep_child(pack, packidx);
 742         if (err)
 743                 return err;
 744
 745         return request_packed_commit(commit, pack, idx, id);
 746 }
 747
 748 static const struct got_error *
 749 request_commit(struct got_commit_object **commit, struct got_repository *repo,
 750     int fd, struct got_object_id *id)
 751 {
 752         const struct got_error *err = NULL;
 753         struct imsgbuf *ibuf;
 754
 755         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf;
 756
 757         err = got_privsep_send_commit_req(ibuf, fd, id, -1);
 758         if (err)
 759                 return err;
 760
 761         return got_privsep_recv_commit(commit, ibuf);
 762 }
 763
 764 static const struct got_error *
 765 read_commit_privsep(struct got_commit_object **commit, int obj_fd,
 766     struct got_object_id *id, struct got_repository *repo)
 767 {
 768         const struct got_error *err;
 769         int imsg_fds[2];
 770         pid_t pid;
 771         struct imsgbuf *ibuf;
 772
 773         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd != -1)
 774                 return request_commit(commit, repo, obj_fd, id);
 775
 776         ibuf = calloc(1, sizeof(*ibuf));
 777         if (ibuf == NULL)
 778                 return got_error_from_errno("calloc");
 779
 780         if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
 781                 err = got_error_from_errno("socketpair");
 782                 free(ibuf);
 783                 return err;
 784         }
 785
 786         pid = fork();
 787         if (pid == -1) {
 788                 err = got_error_from_errno("fork");
 789                 free(ibuf);
 790                 return err;
 791         }
 792         else if (pid == 0) {
 793                 got_privsep_exec_child(imsg_fds, GOT_PATH_PROG_READ_COMMIT,
 794                     repo->path);
 795                 /* not reached */
 796         }
 797
 798         if (close(imsg_fds[1]) == -1) {
 799                 err = got_error_from_errno("close");
 800                 free(ibuf);
 801                 return err;
 802         }
 803         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].imsg_fd =
 804             imsg_fds[0];
 805         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].pid = pid;
 806         imsg_init(ibuf, imsg_fds[0]);
 807         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_COMMIT].ibuf = ibuf;
 808
 809         return request_commit(commit, repo, obj_fd, id);
 810 }
 811
 812
 813 static const struct got_error *
 814 open_commit(struct got_commit_object **commit,
 815     struct got_repository *repo, struct got_object_id *id, int check_cache)
 816 {
 817         const struct got_error *err = NULL;
 818         struct got_packidx *packidx = NULL;
 819         int idx;
 820         char *path_packfile = NULL;
 821
 822         if (check_cache) {
 823                 *commit = got_repo_get_cached_commit(repo, id);
 824                 if (*commit != NULL) {
 825                         (*commit)->refcnt++;
 826                         return NULL;
 827                 }
 828         } else
 829                 *commit = NULL;
 830
 831         err = got_repo_search_packidx(&packidx, &idx, repo, id);
 832         if (err == NULL) {
 833                 struct got_pack *pack = NULL;
 834
 835                 err = got_packidx_get_packfile_path(&path_packfile,
 836                     packidx->path_packidx);
 837                 if (err)
 838                         return err;
 839
 840                 pack = got_repo_get_cached_pack(repo, path_packfile);
 841                 if (pack == NULL) {
 842                         err = got_repo_cache_pack(&pack, repo, path_packfile,
 843                             packidx);
 844                         if (err)
 845                                 goto done;
 846                 }
 847                 err = read_packed_commit_privsep(commit, pack,
 848                     packidx, idx, id);
 849         } else if (err->code == GOT_ERR_NO_OBJ) {
 850                 int fd;
 851
 852                 err = got_object_open_loose_fd(&fd, id, repo);
 853                 if (err)
 854                         return err;
 855                 err = read_commit_privsep(commit, fd, id, repo);
 856         }
 857
 858         if (err == NULL) {
 859                 (*commit)->refcnt++;
 860                 err = got_repo_cache_commit(repo, id, *commit);
 861         }
 862 done:
 863         free(path_packfile);
 864         return err;
 865 }
 866
 867 const struct got_error *
 868 got_object_open_as_commit(struct got_commit_object **commit,
 869     struct got_repository *repo, struct got_object_id *id)
 870 {
 871         *commit = got_repo_get_cached_commit(repo, id);
 872         if (*commit != NULL) {
 873                 (*commit)->refcnt++;
 874                 return NULL;
 875         }
 876
 877         return open_commit(commit, repo, id, 0);
 878 }
 879
 880 const struct got_error *
 881 got_object_commit_open(struct got_commit_object **commit,
 882     struct got_repository *repo, struct got_object *obj)
 883 {
 884         return open_commit(commit, repo, got_object_get_id(obj), 1);
 885 }
 886
 887 const struct got_error *
 888 got_object_qid_alloc(struct got_object_qid **qid, struct got_object_id *id)
 889 {
 890         const struct got_error *err = NULL;
 891
 892         *qid = calloc(1, sizeof(**qid));
 893         if (*qid == NULL)
 894                 return got_error_from_errno("calloc");
 895
 896         (*qid)->id = got_object_id_dup(id);
 897         if ((*qid)->id == NULL) {
 898                 err = got_error_from_errno("got_object_id_dup");
 899                 got_object_qid_free(*qid);
 900                 *qid = NULL;
 901                 return err;
 902         }
 903
 904         return NULL;
 905 }
 906
 907 const struct got_error *
 908 got_object_id_queue_copy(const struct got_object_id_queue *src,
 909     struct got_object_id_queue *dest)
 910 {
 911         const struct got_error *err;
 912         struct got_object_qid *qid;
 913
 914         STAILQ_FOREACH(qid, src, entry) {
 915                 struct got_object_qid *new;
 916                 /*
 917                  * Deep-copy the object ID only. Let the caller deal
 918                  * with setting up the new->data pointer if needed.
 919                  */
 920                 err = got_object_qid_alloc(&new, qid->id);
 921                 if (err) {
 922                         got_object_id_queue_free(dest);
 923                         return err;
 924                 }
 925                 STAILQ_INSERT_TAIL(dest, new, entry);
 926         }
 927
 928         return NULL;
 929 }
 930
 931 static const struct got_error *
 932 request_packed_tree(struct got_tree_object **tree, struct got_pack *pack,
 933     int pack_idx, struct got_object_id *id)
 934 {
 935         const struct got_error *err = NULL;
 936
 937         err = got_privsep_send_tree_req(pack->privsep_child->ibuf, -1, id,
 938             pack_idx);
 939         if (err)
 940                 return err;
 941
 942         return got_privsep_recv_tree(tree, pack->privsep_child->ibuf);
 943 }
 944
 945 static const struct got_error *
 946 read_packed_tree_privsep(struct got_tree_object **tree,
 947     struct got_pack *pack, struct got_packidx *packidx, int idx,
 948     struct got_object_id *id)
 949 {
 950         const struct got_error *err = NULL;
 951
 952         if (pack->privsep_child)
 953                 return request_packed_tree(tree, pack, idx, id);
 954
 955         err = start_pack_privsep_child(pack, packidx);
 956         if (err)
 957                 return err;
 958
 959         return request_packed_tree(tree, pack, idx, id);
 960 }
 961
 962 static const struct got_error *
 963 request_tree(struct got_tree_object **tree, struct got_repository *repo,
 964     int fd, struct got_object_id *id)
 965 {
 966         const struct got_error *err = NULL;
 967         struct imsgbuf *ibuf;
 968
 969         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf;
 970
 971         err = got_privsep_send_tree_req(ibuf, fd, id, -1);
 972         if (err)
 973                 return err;
 974
 975         return got_privsep_recv_tree(tree, ibuf);
 976 }
 977
 978 const struct got_error *
 979 read_tree_privsep(struct got_tree_object **tree, int obj_fd,
 980     struct got_object_id *id, struct got_repository *repo)
 981 {
 982         const struct got_error *err;
 983         int imsg_fds[2];
 984         pid_t pid;
 985         struct imsgbuf *ibuf;
 986
 987         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd != -1)
 988                 return request_tree(tree, repo, obj_fd, id);
 989
 990         ibuf = calloc(1, sizeof(*ibuf));
 991         if (ibuf == NULL)
 992                 return got_error_from_errno("calloc");
 993
 994         if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
 995                 err = got_error_from_errno("socketpair");
 996                 free(ibuf);
 997                 return err;
 998         }
 999
1000         pid = fork();
1001         if (pid == -1) {
1002                 err = got_error_from_errno("fork");
1003                 free(ibuf);
1004                 return err;
1005         }
1006         else if (pid == 0) {
1007                 got_privsep_exec_child(imsg_fds, GOT_PATH_PROG_READ_TREE,
1008                     repo->path);
1009                 /* not reached */
1010         }
1011
1012         if (close(imsg_fds[1]) == -1) {
1013                 err = got_error_from_errno("close");
1014                 free(ibuf);
1015                 return err;
1016         }
1017         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].imsg_fd =
1018             imsg_fds[0];
1019         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].pid = pid;
1020         imsg_init(ibuf, imsg_fds[0]);
1021         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TREE].ibuf = ibuf;
1022
1023
1024         return request_tree(tree, repo, obj_fd, id);
1025 }
1026
1027 static const struct got_error *
1028 open_tree(struct got_tree_object **tree, struct got_repository *repo,
1029     struct got_object_id *id, int check_cache)
1030 {
1031         const struct got_error *err = NULL;
1032         struct got_packidx *packidx = NULL;
1033         int idx;
1034         char *path_packfile = NULL;
1035
1036         if (check_cache) {
1037                 *tree = got_repo_get_cached_tree(repo, id);
1038                 if (*tree != NULL) {
1039                         (*tree)->refcnt++;
1040                         return NULL;
1041                 }
1042         } else
1043                 *tree = NULL;
1044
1045         err = got_repo_search_packidx(&packidx, &idx, repo, id);
1046         if (err == NULL) {
1047                 struct got_pack *pack = NULL;
1048
1049                 err = got_packidx_get_packfile_path(&path_packfile,
1050                     packidx->path_packidx);
1051                 if (err)
1052                         return err;
1053
1054                 pack = got_repo_get_cached_pack(repo, path_packfile);
1055                 if (pack == NULL) {
1056                         err = got_repo_cache_pack(&pack, repo, path_packfile,
1057                             packidx);
1058                         if (err)
1059                                 goto done;
1060                 }
1061                 err = read_packed_tree_privsep(tree, pack,
1062                     packidx, idx, id);
1063         } else if (err->code == GOT_ERR_NO_OBJ) {
1064                 int fd;
1065
1066                 err = got_object_open_loose_fd(&fd, id, repo);
1067                 if (err)
1068                         return err;
1069                 err = read_tree_privsep(tree, fd, id, repo);
1070         }
1071
1072         if (err == NULL) {
1073                 (*tree)->refcnt++;
1074                 err = got_repo_cache_tree(repo, id, *tree);
1075         }
1076 done:
1077         free(path_packfile);
1078         return err;
1079 }
1080
1081 const struct got_error *
1082 got_object_open_as_tree(struct got_tree_object **tree,
1083     struct got_repository *repo, struct got_object_id *id)
1084 {
1085         *tree = got_repo_get_cached_tree(repo, id);
1086         if (*tree != NULL) {
1087                 (*tree)->refcnt++;
1088                 return NULL;
1089         }
1090
1091         return open_tree(tree, repo, id, 0);
1092 }
1093
1094 const struct got_error *
1095 got_object_tree_open(struct got_tree_object **tree,
1096     struct got_repository *repo, struct got_object *obj)
1097 {
1098         return open_tree(tree, repo, got_object_get_id(obj), 1);
1099 }
1100
1101 int
1102 got_object_tree_get_nentries(struct got_tree_object *tree)
1103 {
1104         return tree->nentries;
1105 }
1106
1107 struct got_tree_entry *
1108 got_object_tree_get_first_entry(struct got_tree_object *tree)
1109 {
1110         return got_object_tree_get_entry(tree, 0);
1111 }
1112
1113 struct got_tree_entry *
1114 got_object_tree_get_last_entry(struct got_tree_object *tree)
1115 {
1116         return got_object_tree_get_entry(tree, tree->nentries - 1);
1117 }
1118
1119 struct got_tree_entry *
1120 got_object_tree_get_entry(struct got_tree_object *tree, int i)
1121 {
1122         if (i < 0 || i >= tree->nentries)
1123                 return NULL;
1124         return &tree->entries[i];
1125 }
1126
1127 mode_t
1128 got_tree_entry_get_mode(struct got_tree_entry *te)
1129 {
1130         return te->mode;
1131 }
1132
1133 const char *
1134 got_tree_entry_get_name(struct got_tree_entry *te)
1135 {
1136         return &te->name[0];
1137 }
1138
1139 struct got_object_id *
1140 got_tree_entry_get_id(struct got_tree_entry *te)
1141 {
1142         return &te->id;
1143 }
1144
1145 const struct got_error *
1146 got_object_blob_read_to_str(char **s, struct got_blob_object *blob)
1147 {
1148         const struct got_error *err = NULL;
1149         size_t len, totlen, hdrlen, offset;
1150
1151         *s = NULL;
1152
1153         hdrlen = got_object_blob_get_hdrlen(blob);
1154         totlen = 0;
1155         offset = 0;
1156         do {
1157                 char *p;
1158
1159                 err = got_object_blob_read_block(&len, blob);
1160                 if (err)
1161                         return err;
1162
1163                 if (len == 0)
1164                         break;
1165
1166                 totlen += len - hdrlen;
1167                 p = realloc(*s, totlen + 1);
1168                 if (p == NULL) {
1169                         err = got_error_from_errno("realloc");
1170                         free(*s);
1171                         *s = NULL;
1172                         return err;
1173                 }
1174                 *s = p;
1175                 /* Skip blob object header first time around. */
1176                 memcpy(*s + offset,
1177                     got_object_blob_get_read_buf(blob) + hdrlen, len - hdrlen);
1178                 hdrlen = 0;
1179                 offset = totlen;
1180         } while (len > 0);
1181
1182         (*s)[totlen] = '\0';
1183         return NULL;
1184 }
1185
1186 const struct got_error *
1187 got_tree_entry_get_symlink_target(char **link_target, struct got_tree_entry *te,
1188     struct got_repository *repo)
1189 {
1190         const struct got_error *err = NULL;
1191         struct got_blob_object *blob = NULL;
1192
1193         *link_target = NULL;
1194
1195         if (!got_object_tree_entry_is_symlink(te))
1196                 return got_error(GOT_ERR_TREE_ENTRY_TYPE);
1197
1198         err = got_object_open_as_blob(&blob, repo,
1199             got_tree_entry_get_id(te), PATH_MAX);
1200         if (err)
1201                 return err;
1202
1203         err = got_object_blob_read_to_str(link_target, blob);
1204         got_object_blob_close(blob);
1205         if (err) {
1206                 free(*link_target);
1207                 *link_target = NULL;
1208         }
1209         return err;
1210 }
1211
1212 int
1213 got_tree_entry_get_index(struct got_tree_entry *te)
1214 {
1215         return te->idx;
1216 }
1217
1218 struct got_tree_entry *
1219 got_tree_entry_get_next(struct got_tree_object *tree,
1220     struct got_tree_entry *te)
1221 {
1222         return got_object_tree_get_entry(tree, te->idx + 1);
1223 }
1224
1225 struct got_tree_entry *
1226 got_tree_entry_get_prev(struct got_tree_object *tree,
1227     struct got_tree_entry *te)
1228 {
1229         return got_object_tree_get_entry(tree, te->idx - 1);
1230 }
1231
1232 static const struct got_error *
1233 request_packed_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen, int outfd,
1234     struct got_pack *pack, struct got_packidx *packidx, int idx,
1235     struct got_object_id *id)
1236 {
1237         const struct got_error *err = NULL;
1238         int outfd_child;
1239         int basefd, accumfd; /* temporary files for delta application */
1240
1241         basefd = got_opentempfd();
1242         if (basefd == -1)
1243                 return got_error_from_errno("got_opentempfd");
1244         accumfd = got_opentempfd();
1245         if (accumfd == -1)
1246                 return got_error_from_errno("got_opentempfd");
1247
1248         outfd_child = dup(outfd);
1249         if (outfd_child == -1)
1250                 return got_error_from_errno("dup");
1251
1252         err = got_privsep_send_blob_req(pack->privsep_child->ibuf, -1, id, idx);
1253         if (err)
1254                 return err;
1255
1256         err = got_privsep_send_blob_outfd(pack->privsep_child->ibuf,
1257             outfd_child);
1258         if (err) {
1259                 close(basefd);
1260                 close(accumfd);
1261                 return err;
1262         }
1263
1264         err = got_privsep_send_tmpfd(pack->privsep_child->ibuf,
1265             basefd);
1266         if (err) {
1267                 close(accumfd);
1268                 return err;
1269         }
1270
1271         err = got_privsep_send_tmpfd(pack->privsep_child->ibuf,
1272             accumfd);
1273         if (err)
1274                 return err;
1275
1276         err = got_privsep_recv_blob(outbuf, size, hdrlen,
1277             pack->privsep_child->ibuf);
1278         if (err)
1279                 return err;
1280
1281         if (lseek(outfd, SEEK_SET, 0) == -1)
1282                 err = got_error_from_errno("lseek");
1283
1284         return err;
1285 }
1286
1287 static const struct got_error *
1288 read_packed_blob_privsep(uint8_t **outbuf, size_t *size, size_t *hdrlen,
1289     int outfd, struct got_pack *pack, struct got_packidx *packidx, int idx,
1290     struct got_object_id *id)
1291 {
1292         const struct got_error *err = NULL;
1293
1294         if (pack->privsep_child == NULL) {
1295                 err = start_pack_privsep_child(pack, packidx);
1296                 if (err)
1297                         return err;
1298         }
1299
1300         return request_packed_blob(outbuf, size, hdrlen, outfd, pack, packidx,
1301             idx, id);
1302 }
1303
1304 static const struct got_error *
1305 request_blob(uint8_t **outbuf, size_t *size, size_t *hdrlen, int outfd,
1306     int infd, struct got_object_id *id, struct imsgbuf *ibuf)
1307 {
1308         const struct got_error *err = NULL;
1309         int outfd_child;
1310
1311         outfd_child = dup(outfd);
1312         if (outfd_child == -1)
1313                 return got_error_from_errno("dup");
1314
1315         err = got_privsep_send_blob_req(ibuf, infd, id, -1);
1316         if (err)
1317                 return err;
1318
1319         err = got_privsep_send_blob_outfd(ibuf, outfd_child);
1320         if (err)
1321                 return err;
1322
1323         err = got_privsep_recv_blob(outbuf, size, hdrlen, ibuf);
1324         if (err)
1325                 return err;
1326
1327         if (lseek(outfd, SEEK_SET, 0) == -1)
1328                 return got_error_from_errno("lseek");
1329
1330         return err;
1331 }
1332
1333 static const struct got_error *
1334 read_blob_privsep(uint8_t **outbuf, size_t *size, size_t *hdrlen,
1335     int outfd, int infd, struct got_object_id *id, struct got_repository *repo)
1336 {
1337         const struct got_error *err;
1338         int imsg_fds[2];
1339         pid_t pid;
1340         struct imsgbuf *ibuf;
1341
1342         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd != -1) {
1343                 ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf;
1344                 return request_blob(outbuf, size, hdrlen, outfd, infd, id,
1345                     ibuf);
1346         }
1347
1348         ibuf = calloc(1, sizeof(*ibuf));
1349         if (ibuf == NULL)
1350                 return got_error_from_errno("calloc");
1351
1352         if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
1353                 err = got_error_from_errno("socketpair");
1354                 free(ibuf);
1355                 return err;
1356         }
1357
1358         pid = fork();
1359         if (pid == -1) {
1360                 err = got_error_from_errno("fork");
1361                 free(ibuf);
1362                 return err;
1363         }
1364         else if (pid == 0) {
1365                 got_privsep_exec_child(imsg_fds, GOT_PATH_PROG_READ_BLOB,
1366                     repo->path);
1367                 /* not reached */
1368         }
1369
1370         if (close(imsg_fds[1]) == -1) {
1371                 err = got_error_from_errno("close");
1372                 free(ibuf);
1373                 return err;
1374         }
1375         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].imsg_fd =
1376             imsg_fds[0];
1377         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].pid = pid;
1378         imsg_init(ibuf, imsg_fds[0]);
1379         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_BLOB].ibuf = ibuf;
1380
1381         return request_blob(outbuf, size, hdrlen, outfd, infd, id, ibuf);
1382 }
1383
1384 static const struct got_error *
1385 open_blob(struct got_blob_object **blob, struct got_repository *repo,
1386     struct got_object_id *id, size_t blocksize)
1387 {
1388         const struct got_error *err = NULL;
1389         struct got_packidx *packidx = NULL;
1390         int idx;
1391         char *path_packfile = NULL;
1392         uint8_t *outbuf;
1393         int outfd;
1394         size_t size, hdrlen;
1395         struct stat sb;
1396
1397         *blob = calloc(1, sizeof(**blob));
1398         if (*blob == NULL)
1399                 return got_error_from_errno("calloc");
1400
1401         outfd = got_opentempfd();
1402         if (outfd == -1)
1403                 return got_error_from_errno("got_opentempfd");
1404
1405         (*blob)->read_buf = malloc(blocksize);
1406         if ((*blob)->read_buf == NULL) {
1407                 err = got_error_from_errno("malloc");
1408                 goto done;
1409         }
1410
1411         err = got_repo_search_packidx(&packidx, &idx, repo, id);
1412         if (err == NULL) {
1413                 struct got_pack *pack = NULL;
1414
1415                 err = got_packidx_get_packfile_path(&path_packfile,
1416                     packidx->path_packidx);
1417                 if (err)
1418                         goto done;
1419
1420                 pack = got_repo_get_cached_pack(repo, path_packfile);
1421                 if (pack == NULL) {
1422                         err = got_repo_cache_pack(&pack, repo, path_packfile,
1423                             packidx);
1424                         if (err)
1425                                 goto done;
1426                 }
1427                 err = read_packed_blob_privsep(&outbuf, &size, &hdrlen, outfd,
1428                     pack, packidx, idx, id);
1429         } else if (err->code == GOT_ERR_NO_OBJ) {
1430                 int infd;
1431
1432                 err = got_object_open_loose_fd(&infd, id, repo);
1433                 if (err)
1434                         goto done;
1435                 err = read_blob_privsep(&outbuf, &size, &hdrlen, outfd, infd,
1436                     id, repo);
1437         }
1438         if (err)
1439                 goto done;
1440
1441         if (hdrlen > size) {
1442                 err = got_error(GOT_ERR_BAD_OBJ_HDR);
1443                 goto done;
1444         }
1445
1446         if (outbuf) {
1447                 if (close(outfd) == -1 && err == NULL)
1448                         err = got_error_from_errno("close");
1449                 outfd = -1;
1450                 (*blob)->f = fmemopen(outbuf, size, "rb");
1451                 if ((*blob)->f == NULL) {
1452                         err = got_error_from_errno("fmemopen");
1453                         free(outbuf);
1454                         goto done;
1455                 }
1456                 (*blob)->data = outbuf;
1457         } else {
1458                 if (fstat(outfd, &sb) == -1) {
1459                         err = got_error_from_errno("fstat");
1460                         goto done;
1461                 }
1462
1463                 if (sb.st_size != size) {
1464                         err = got_error(GOT_ERR_PRIVSEP_LEN);
1465                         goto done;
1466                 }
1467
1468                 (*blob)->f = fdopen(outfd, "rb");
1469                 if ((*blob)->f == NULL) {
1470                         err = got_error_from_errno("fdopen");
1471                         close(outfd);
1472                         outfd = -1;
1473                         goto done;
1474                 }
1475         }
1476
1477         (*blob)->hdrlen = hdrlen;
1478         (*blob)->blocksize = blocksize;
1479         memcpy(&(*blob)->id.sha1, id->sha1, SHA1_DIGEST_LENGTH);
1480
1481 done:
1482         free(path_packfile);
1483         if (err) {
1484                 if (*blob) {
1485                         got_object_blob_close(*blob);
1486                         *blob = NULL;
1487                 } else if (outfd != -1)
1488                         close(outfd);
1489         }
1490         return err;
1491 }
1492
1493 const struct got_error *
1494 got_object_open_as_blob(struct got_blob_object **blob,
1495     struct got_repository *repo, struct got_object_id *id,
1496     size_t blocksize)
1497 {
1498         return open_blob(blob, repo, id, blocksize);
1499 }
1500
1501 const struct got_error *
1502 got_object_blob_open(struct got_blob_object **blob,
1503     struct got_repository *repo, struct got_object *obj, size_t blocksize)
1504 {
1505         return open_blob(blob, repo, got_object_get_id(obj), blocksize);
1506 }
1507
1508 const struct got_error *
1509 got_object_blob_close(struct got_blob_object *blob)
1510 {
1511         const struct got_error *err = NULL;
1512         free(blob->read_buf);
1513         if (blob->f && fclose(blob->f) == EOF)
1514                 err = got_error_from_errno("fclose");
1515         free(blob->data);
1516         free(blob);
1517         return err;
1518 }
1519
1520 void
1521 got_object_blob_rewind(struct got_blob_object *blob)
1522 {
1523         if (blob->f)
1524                 rewind(blob->f);
1525 }
1526
1527 char *
1528 got_object_blob_id_str(struct got_blob_object *blob, char *buf, size_t size)
1529 {
1530         return got_sha1_digest_to_str(blob->id.sha1, buf, size);
1531 }
1532
1533 size_t
1534 got_object_blob_get_hdrlen(struct got_blob_object *blob)
1535 {
1536         return blob->hdrlen;
1537 }
1538
1539 const uint8_t *
1540 got_object_blob_get_read_buf(struct got_blob_object *blob)
1541 {
1542         return blob->read_buf;
1543 }
1544
1545 const struct got_error *
1546 got_object_blob_read_block(size_t *outlenp, struct got_blob_object *blob)
1547 {
1548         size_t n;
1549
1550         n = fread(blob->read_buf, 1, blob->blocksize, blob->f);
1551         if (n == 0 && ferror(blob->f))
1552                 return got_ferror(blob->f, GOT_ERR_IO);
1553         *outlenp = n;
1554         return NULL;
1555 }
1556
1557 const struct got_error *
1558 got_object_blob_dump_to_file(off_t *filesize, int *nlines,
1559     off_t **line_offsets, FILE *outfile, struct got_blob_object *blob)
1560 {
1561         const struct got_error *err = NULL;
1562         size_t n, len, hdrlen;
1563         const uint8_t *buf;
1564         int i;
1565         const int alloc_chunksz = 512;
1566         size_t nalloc = 0;
1567         off_t off = 0, total_len = 0;
1568
1569         if (line_offsets)
1570                 *line_offsets = NULL;
1571         if (filesize)
1572                 *filesize = 0;
1573         if (nlines)
1574                 *nlines = 0;
1575
1576         hdrlen = got_object_blob_get_hdrlen(blob);
1577         do {
1578                 err = got_object_blob_read_block(&len, blob);
1579                 if (err)
1580                         return err;
1581                 if (len == 0)
1582                         break;
1583                 buf = got_object_blob_get_read_buf(blob);
1584                 i = hdrlen;
1585                 if (nlines) {
1586                         if (line_offsets && *line_offsets == NULL) {
1587                                 /* Have some data but perhaps no '\n'. */
1588                                 *nlines = 1;
1589                                 nalloc = alloc_chunksz;
1590                                 *line_offsets = calloc(nalloc,
1591                                     sizeof(**line_offsets));
1592                                 if (*line_offsets == NULL)
1593                                         return got_error_from_errno("calloc");
1594
1595                                 /* Skip forward over end of first line. */
1596                                 while (i < len) {
1597                                         if (buf[i] == '\n')
1598                                                 break;
1599                                         i++;
1600                                 }
1601                         }
1602                         /* Scan '\n' offsets in remaining chunk of data. */
1603                         while (i < len) {
1604                                 if (buf[i] != '\n') {
1605                                         i++;
1606                                         continue;
1607                                 }
1608                                 (*nlines)++;
1609                                 if (line_offsets && nalloc < *nlines) {
1610                                         size_t n = *nlines + alloc_chunksz;
1611                                         off_t *o = recallocarray(*line_offsets,
1612                                             nalloc, n, sizeof(**line_offsets));
1613                                         if (o == NULL) {
1614                                                 free(*line_offsets);
1615                                                 *line_offsets = NULL;
1616                                                 return got_error_from_errno(
1617                                                     "recallocarray");
1618                                         }
1619                                         *line_offsets = o;
1620                                         nalloc = n;
1621                                 }
1622                                 if (line_offsets) {
1623                                         off = total_len + i - hdrlen + 1;
1624                                         (*line_offsets)[*nlines - 1] = off;
1625                                 }
1626                                 i++;
1627                         }
1628                 }
1629                 /* Skip blob object header first time around. */
1630                 n = fwrite(buf + hdrlen, 1, len - hdrlen, outfile);
1631                 if (n != len - hdrlen)
1632                         return got_ferror(outfile, GOT_ERR_IO);
1633                 total_len += len - hdrlen;
1634                 hdrlen = 0;
1635         } while (len != 0);
1636
1637         if (fflush(outfile) != 0)
1638                 return got_error_from_errno("fflush");
1639         rewind(outfile);
1640
1641         if (filesize)
1642                 *filesize = total_len;
1643
1644         return NULL;
1645 }
1646
1647 static const struct got_error *
1648 request_packed_tag(struct got_tag_object **tag, struct got_pack *pack,
1649     int pack_idx, struct got_object_id *id)
1650 {
1651         const struct got_error *err = NULL;
1652
1653         err = got_privsep_send_tag_req(pack->privsep_child->ibuf, -1, id,
1654             pack_idx);
1655         if (err)
1656                 return err;
1657
1658         return got_privsep_recv_tag(tag, pack->privsep_child->ibuf);
1659 }
1660
1661 static const struct got_error *
1662 read_packed_tag_privsep(struct got_tag_object **tag,
1663     struct got_pack *pack, struct got_packidx *packidx, int idx,
1664     struct got_object_id *id)
1665 {
1666         const struct got_error *err = NULL;
1667
1668         if (pack->privsep_child)
1669                 return request_packed_tag(tag, pack, idx, id);
1670
1671         err = start_pack_privsep_child(pack, packidx);
1672         if (err)
1673                 return err;
1674
1675         return request_packed_tag(tag, pack, idx, id);
1676 }
1677
1678 static const struct got_error *
1679 request_tag(struct got_tag_object **tag, struct got_repository *repo,
1680     int fd, struct got_object_id *id)
1681 {
1682         const struct got_error *err = NULL;
1683         struct imsgbuf *ibuf;
1684
1685         ibuf = repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].ibuf;
1686
1687         err = got_privsep_send_tag_req(ibuf, fd, id, -1);
1688         if (err)
1689                 return err;
1690
1691         return got_privsep_recv_tag(tag, ibuf);
1692 }
1693
1694 static const struct got_error *
1695 read_tag_privsep(struct got_tag_object **tag, int obj_fd,
1696     struct got_object_id *id, struct got_repository *repo)
1697 {
1698         const struct got_error *err;
1699         int imsg_fds[2];
1700         pid_t pid;
1701         struct imsgbuf *ibuf;
1702
1703         if (repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].imsg_fd != -1)
1704                 return request_tag(tag, repo, obj_fd, id);
1705
1706         ibuf = calloc(1, sizeof(*ibuf));
1707         if (ibuf == NULL)
1708                 return got_error_from_errno("calloc");
1709
1710         if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1) {
1711                 err = got_error_from_errno("socketpair");
1712                 free(ibuf);
1713                 return err;
1714         }
1715
1716         pid = fork();
1717         if (pid == -1) {
1718                 err = got_error_from_errno("fork");
1719                 free(ibuf);
1720                 return err;
1721         }
1722         else if (pid == 0) {
1723                 got_privsep_exec_child(imsg_fds, GOT_PATH_PROG_READ_TAG,
1724                     repo->path);
1725                 /* not reached */
1726         }
1727
1728         if (close(imsg_fds[1]) == -1) {
1729                 err = got_error_from_errno("close");
1730                 free(ibuf);
1731                 return err;
1732         }
1733         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].imsg_fd =
1734             imsg_fds[0];
1735         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].pid = pid;
1736         imsg_init(ibuf, imsg_fds[0]);
1737         repo->privsep_children[GOT_REPO_PRIVSEP_CHILD_TAG].ibuf = ibuf;
1738
1739         return request_tag(tag, repo, obj_fd, id);
1740 }
1741
1742 static const struct got_error *
1743 open_tag(struct got_tag_object **tag, struct got_repository *repo,
1744     struct got_object_id *id, int check_cache)
1745 {
1746         const struct got_error *err = NULL;
1747         struct got_packidx *packidx = NULL;
1748         int idx;
1749         char *path_packfile = NULL;
1750         struct got_object *obj = NULL;
1751         int obj_type = GOT_OBJ_TYPE_ANY;
1752
1753         if (check_cache) {
1754                 *tag = got_repo_get_cached_tag(repo, id);
1755                 if (*tag != NULL) {
1756                         (*tag)->refcnt++;
1757                         return NULL;
1758                 }
1759         } else
1760                 *tag = NULL;
1761
1762         err = got_repo_search_packidx(&packidx, &idx, repo, id);
1763         if (err == NULL) {
1764                 struct got_pack *pack = NULL;
1765
1766                 err = got_packidx_get_packfile_path(&path_packfile,
1767                     packidx->path_packidx);
1768                 if (err)
1769                         return err;
1770
1771                 pack = got_repo_get_cached_pack(repo, path_packfile);
1772                 if (pack == NULL) {
1773                         err = got_repo_cache_pack(&pack, repo, path_packfile,
1774                             packidx);
1775                         if (err)
1776                                 goto done;
1777                 }
1778
1779                 /* Beware of "lightweight" tags: Check object type first. */
1780                 err = read_packed_object_privsep(&obj, repo, pack, packidx,
1781                     idx, id);
1782                 if (err)
1783                         goto done;
1784                 obj_type = obj->type;
1785                 got_object_close(obj);
1786                 if (obj_type != GOT_OBJ_TYPE_TAG) {
1787                         err = got_error(GOT_ERR_OBJ_TYPE);
1788                         goto done;
1789                 }
1790                 err = read_packed_tag_privsep(tag, pack, packidx, idx, id);
1791         } else if (err->code == GOT_ERR_NO_OBJ) {
1792                 int fd;
1793
1794                 err = got_object_open_loose_fd(&fd, id, repo);
1795                 if (err)
1796                         return err;
1797                 err = got_object_read_header_privsep(&obj, id, repo, fd);
1798                 if (err)
1799                         return err;
1800                 obj_type = obj->type;
1801                 got_object_close(obj);
1802                 if (obj_type != GOT_OBJ_TYPE_TAG)
1803                         return got_error(GOT_ERR_OBJ_TYPE);
1804
1805                 err = got_object_open_loose_fd(&fd, id, repo);
1806                 if (err)
1807                         return err;
1808                 err = read_tag_privsep(tag, fd, id, repo);
1809         }
1810
1811         if (err == NULL) {
1812                 (*tag)->refcnt++;
1813                 err = got_repo_cache_tag(repo, id, *tag);
1814         }
1815 done:
1816         free(path_packfile);
1817         return err;
1818 }
1819
1820 const struct got_error *
1821 got_object_open_as_tag(struct got_tag_object **tag,
1822     struct got_repository *repo, struct got_object_id *id)
1823 {
1824         *tag = got_repo_get_cached_tag(repo, id);
1825         if (*tag != NULL) {
1826                 (*tag)->refcnt++;
1827                 return NULL;
1828         }
1829
1830         return open_tag(tag, repo, id, 0);
1831 }
1832
1833 const struct got_error *
1834 got_object_tag_open(struct got_tag_object **tag,
1835     struct got_repository *repo, struct got_object *obj)
1836 {
1837         return open_tag(tag, repo, got_object_get_id(obj), 1);
1838 }
1839
1840 const char *
1841 got_object_tag_get_name(struct got_tag_object *tag)
1842 {
1843         return tag->tag;
1844 }
1845
1846 int
1847 got_object_tag_get_object_type(struct got_tag_object *tag)
1848 {
1849         return tag->obj_type;
1850 }
1851
1852 struct got_object_id *
1853 got_object_tag_get_object_id(struct got_tag_object *tag)
1854 {
1855         return &tag->id;
1856 }
1857
1858 time_t
1859 got_object_tag_get_tagger_time(struct got_tag_object *tag)
1860 {
1861         return tag->tagger_time;
1862 }
1863
1864 time_t
1865 got_object_tag_get_tagger_gmtoff(struct got_tag_object *tag)
1866 {
1867         return tag->tagger_gmtoff;
1868 }
1869
1870 const char *
1871 got_object_tag_get_tagger(struct got_tag_object *tag)
1872 {
1873         return tag->tagger;
1874 }
1875
1876 const char *
1877 got_object_tag_get_message(struct got_tag_object *tag)
1878 {
1879         return tag->tagmsg;
1880 }
1881
1882 static struct got_tree_entry *
1883 find_entry_by_name(struct got_tree_object *tree, const char *name, size_t len)
1884 {
1885         int i;
1886
1887         /* Note that tree entries are sorted in strncmp() order. */
1888         for (i = 0; i < tree->nentries; i++) {
1889                 struct got_tree_entry *te = &tree->entries[i];
1890                 int cmp = strncmp(te->name, name, len);
1891                 if (cmp < 0)
1892                         continue;
1893                 if (cmp > 0)
1894                         break;
1895                 if (te->name[len] == '\0')
1896                         return te;
1897         }
1898         return NULL;
1899 }
1900
1901 struct got_tree_entry *
1902 got_object_tree_find_entry(struct got_tree_object *tree, const char *name)
1903 {
1904         return find_entry_by_name(tree, name, strlen(name));
1905 }
1906
1907 const struct got_error *
1908 got_object_id_by_path(struct got_object_id **id, struct got_repository *repo,
1909     struct got_object_id *commit_id, const char *path)
1910 {
1911         const struct got_error *err = NULL;
1912         struct got_commit_object *commit = NULL;
1913         struct got_tree_object *tree = NULL;
1914         struct got_tree_entry *te = NULL;
1915         const char *seg, *s;
1916         size_t seglen;
1917
1918         *id = NULL;
1919
1920         err = got_object_open_as_commit(&commit, repo, commit_id);
1921         if (err)
1922                 goto done;
1923
1924         /* Handle opening of root of commit's tree. */
1925         if (got_path_is_root_dir(path)) {
1926                 *id = got_object_id_dup(commit->tree_id);
1927                 if (*id == NULL)
1928                         err = got_error_from_errno("got_object_id_dup");
1929                 goto done;
1930         }
1931
1932         err = got_object_open_as_tree(&tree, repo, commit->tree_id);
1933         if (err)
1934                 goto done;
1935
1936         s = path;
1937         while (s[0] == '/')
1938                 s++;
1939         seg = s;
1940         seglen = 0;
1941         while (*s) {
1942                 struct got_tree_object *next_tree;
1943
1944                 if (*s != '/') {
1945                         s++;
1946                         seglen++;
1947                         if (*s)
1948                                 continue;
1949                 }
1950
1951                 te = find_entry_by_name(tree, seg, seglen);
1952                 if (te == NULL) {
1953                         err = got_error_path(path, GOT_ERR_NO_TREE_ENTRY);
1954                         goto done;
1955                 }
1956
1957                 if (*s == '\0')
1958                         break;
1959
1960                 seg = s + 1;
1961                 seglen = 0;
1962                 s++;
1963                 if (*s) {
1964                         err = got_object_open_as_tree(&next_tree, repo,
1965                             &te->id);
1966                         te = NULL;
1967                         if (err)
1968                                 goto done;
1969                         got_object_tree_close(tree);
1970                         tree = next_tree;
1971                 }
1972         }
1973
1974         if (te) {
1975                 *id = got_object_id_dup(&te->id);
1976                 if (*id == NULL)
1977                         return got_error_from_errno("got_object_id_dup");
1978         } else
1979                 err = got_error_path(path, GOT_ERR_NO_TREE_ENTRY);
1980 done:
1981         if (commit)
1982                 got_object_commit_close(commit);
1983         if (tree)
1984                 got_object_tree_close(tree);
1985         return err;
1986 }
1987
1988 /*
1989  * Normalize file mode bits to avoid false positive tree entry differences
1990  * in case tree entries have unexpected mode bits set.
1991  */
1992 static mode_t
1993 normalize_mode_for_comparison(mode_t mode)
1994 {
1995         /*
1996          * For directories, the only relevant bit is the IFDIR bit.
1997          * This allows us to detect paths changing from a directory
1998          * to a file and vice versa.
1999          */
2000         if (S_ISDIR(mode))
2001                 return mode & S_IFDIR;
2002
2003         /*
2004          * For symlinks, the only relevant bit is the IFLNK bit.
2005          * This allows us to detect paths changing from a symlinks
2006          * to a file or directory and vice versa.
2007          */
2008         if (S_ISLNK(mode))
2009                 return mode & S_IFLNK;
2010
2011         /* For files, the only change we care about is the executable bit. */
2012         return mode & S_IXUSR;
2013 }
2014
2015 const struct got_error *
2016 got_object_tree_path_changed(int *changed,
2017     struct got_tree_object *tree01, struct got_tree_object *tree02,
2018     const char *path, struct got_repository *repo)
2019 {
2020         const struct got_error *err = NULL;
2021         struct got_tree_object *tree1 = NULL, *tree2 = NULL;
2022         struct got_tree_entry *te1 = NULL, *te2 = NULL;
2023         const char *seg, *s;
2024         size_t seglen;
2025
2026         *changed = 0;
2027
2028         /* We not do support comparing the root path. */
2029         if (got_path_is_root_dir(path))
2030                 return got_error_path(path, GOT_ERR_BAD_PATH);
2031
2032         tree1 = tree01;
2033         tree2 = tree02;
2034         s = path;
2035         while (*s == '/')
2036                 s++;
2037         seg = s;
2038         seglen = 0;
2039         while (*s) {
2040                 struct got_tree_object *next_tree1, *next_tree2;
2041                 mode_t mode1, mode2;
2042
2043                 if (*s != '/') {
2044                         s++;
2045                         seglen++;
2046                         if (*s)
2047                                 continue;
2048                 }
2049
2050                 te1 = find_entry_by_name(tree1, seg, seglen);
2051                 if (te1 == NULL) {
2052                         err = got_error(GOT_ERR_NO_OBJ);
2053                         goto done;
2054                 }
2055
2056                 if (tree2)
2057                         te2 = find_entry_by_name(tree2, seg, seglen);
2058
2059                 if (te2) {
2060                         mode1 = normalize_mode_for_comparison(te1->mode);
2061                         mode2 = normalize_mode_for_comparison(te2->mode);
2062                         if (mode1 != mode2) {
2063                                 *changed = 1;
2064                                 goto done;
2065                         }
2066
2067                         if (got_object_id_cmp(&te1->id, &te2->id) == 0) {
2068                                 *changed = 0;
2069                                 goto done;
2070                         }
2071                 }
2072
2073                 if (*s == '\0') { /* final path element */
2074                         *changed = 1;
2075                         goto done;
2076                 }
2077
2078                 seg = s + 1;
2079                 s++;
2080                 seglen = 0;
2081                 if (*s) {
2082                         err = got_object_open_as_tree(&next_tree1, repo,
2083                             &te1->id);
2084                         te1 = NULL;
2085                         if (err)
2086                                 goto done;
2087                         if (tree1 != tree01)
2088                                 got_object_tree_close(tree1);
2089                         tree1 = next_tree1;
2090
2091                         if (te2) {
2092                                 err = got_object_open_as_tree(&next_tree2, repo,
2093                                     &te2->id);
2094                                 te2 = NULL;
2095                                 if (err)
2096                                         goto done;
2097                                 if (tree2 != tree02)
2098                                         got_object_tree_close(tree2);
2099                                 tree2 = next_tree2;
2100                         } else if (tree2) {
2101                                 if (tree2 != tree02)
2102                                         got_object_tree_close(tree2);
2103                                 tree2 = NULL;
2104                         }
2105                 }
2106         }
2107 done:
2108         if (tree1 && tree1 != tree01)
2109                 got_object_tree_close(tree1);
2110         if (tree2 && tree2 != tree02)
2111                 got_object_tree_close(tree2);
2112         return err;
2113 }
2114
2115 const struct got_error *
2116 got_object_tree_entry_dup(struct got_tree_entry **new_te,
2117     struct got_tree_entry *te)
2118 {
2119         const struct got_error *err = NULL;
2120
2121         *new_te = calloc(1, sizeof(**new_te));
2122         if (*new_te == NULL)
2123                 return got_error_from_errno("calloc");
2124
2125         (*new_te)->mode = te->mode;
2126         memcpy((*new_te)->name, te->name, sizeof((*new_te)->name));
2127         memcpy(&(*new_te)->id, &te->id, sizeof((*new_te)->id));
2128         return err;
2129 }
2130
2131 int
2132 got_object_tree_entry_is_submodule(struct got_tree_entry *te)
2133 {
2134         return (te->mode & S_IFMT) == (S_IFDIR | S_IFLNK);
2135 }
2136
2137 int
2138 got_object_tree_entry_is_symlink(struct got_tree_entry *te)
2139 {
2140         /* S_IFDIR check avoids confusing symlinks with submodules. */
2141         return ((te->mode & (S_IFDIR | S_IFLNK)) == S_IFLNK);
2142 }
2143
2144 static const struct got_error *
2145 resolve_symlink(char **link_target, const char *path,
2146     struct got_object_id *commit_id, struct got_repository *repo)
2147 {
2148         const struct got_error *err = NULL;
2149         char buf[PATH_MAX];
2150         char *name, *parent_path = NULL;
2151         struct got_object_id *tree_obj_id = NULL;
2152         struct got_tree_object *tree = NULL;
2153         struct got_tree_entry *te = NULL;
2154
2155         *link_target = NULL;
2156
2157         if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf))
2158                 return got_error(GOT_ERR_NO_SPACE);
2159
2160         name = basename(buf);
2161         if (name == NULL)
2162                 return got_error_from_errno2("basename", path);
2163
2164         err = got_path_dirname(&parent_path, path);
2165         if (err)
2166                 return err;
2167
2168         err = got_object_id_by_path(&tree_obj_id, repo, commit_id,
2169             parent_path);
2170         if (err) {
2171                 if (err->code == GOT_ERR_NO_TREE_ENTRY) {
2172                         /* Display the complete path in error message. */
2173                         err = got_error_path(path, err->code);
2174                 }
2175                 goto done;
2176         }
2177
2178         err = got_object_open_as_tree(&tree, repo, tree_obj_id);
2179         if (err)
2180                 goto done;
2181
2182         te = got_object_tree_find_entry(tree, name);
2183         if (te == NULL) {
2184                 err = got_error_path(path, GOT_ERR_NO_TREE_ENTRY);
2185                 goto done;
2186         }
2187
2188         if (got_object_tree_entry_is_symlink(te)) {
2189                 err = got_tree_entry_get_symlink_target(link_target, te, repo);
2190                 if (err)
2191                         goto done;
2192                 if (!got_path_is_absolute(*link_target)) {
2193                         char *abspath;
2194                         if (asprintf(&abspath, "%s/%s", parent_path,
2195                             *link_target) == -1) {
2196                                 err = got_error_from_errno("asprintf");
2197                                 goto done;
2198                         }
2199                         free(*link_target);
2200                         *link_target = malloc(PATH_MAX);
2201                         if (*link_target == NULL) {
2202                                 err = got_error_from_errno("malloc");
2203                                 goto done;
2204                         }
2205                         err = got_canonpath(abspath, *link_target, PATH_MAX);
2206                         free(abspath);
2207                         if (err)
2208                                 goto done;
2209                 }
2210         }
2211 done:
2212         free(tree_obj_id);
2213         if (tree)
2214                 got_object_tree_close(tree);
2215         if (err) {
2216                 free(*link_target);
2217                 *link_target = NULL;
2218         }
2219         return err;
2220 }
2221
2222 const struct got_error *
2223 got_object_resolve_symlinks(char **link_target, const char *path,
2224     struct got_object_id *commit_id, struct got_repository *repo)
2225 {
2226         const struct got_error *err = NULL;
2227         char *next_target = NULL;
2228         int max_recursion = 40; /* matches Git */
2229
2230         *link_target = NULL;
2231
2232         do {
2233                 err = resolve_symlink(&next_target,
2234                     *link_target ? *link_target : path, commit_id, repo);
2235                 if (err)
2236                         break;
2237                 if (next_target) {
2238                         free(*link_target);
2239                         if (--max_recursion == 0) {
2240                                 err = got_error_path(path, GOT_ERR_RECURSION);
2241                                 *link_target = NULL;
2242                                 break;
2243                         }
2244                         *link_target = next_target;
2245                 }
2246         } while (next_target);
2247
2248         return err;
2249 }
2250
2251 const struct got_error *
2252 got_traverse_packed_commits(struct got_object_id_queue *traversed_commits,
2253     struct got_object_id *commit_id, const char *path,
2254     struct got_repository *repo)
2255 {
2256         const struct got_error *err = NULL;
2257         struct got_pack *pack = NULL;
2258         struct got_packidx *packidx = NULL;
2259         char *path_packfile = NULL;
2260         struct got_commit_object *changed_commit = NULL;
2261         struct got_object_id *changed_commit_id = NULL;
2262         int idx;
2263
2264         err = got_repo_search_packidx(&packidx, &idx, repo, commit_id);
2265         if (err) {
2266                 if (err->code != GOT_ERR_NO_OBJ)
2267                         return err;
2268                 return NULL;
2269         }
2270
2271         err = got_packidx_get_packfile_path(&path_packfile,
2272             packidx->path_packidx);
2273         if (err)
2274                 return err;
2275
2276         pack = got_repo_get_cached_pack(repo, path_packfile);
2277         if (pack == NULL) {
2278                 err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
2279                 if (err)
2280                         goto done;
2281         }
2282
2283         if (pack->privsep_child == NULL) {
2284                 err = start_pack_privsep_child(pack, packidx);
2285                 if (err)
2286                         goto done;
2287         }
2288
2289         err = got_privsep_send_commit_traversal_request(
2290             pack->privsep_child->ibuf, commit_id, idx, path);
2291         if (err)
2292                 goto done;
2293
2294         err = got_privsep_recv_traversed_commits(&changed_commit,
2295             &changed_commit_id, traversed_commits, pack->privsep_child->ibuf);
2296         if (err)
2297                 goto done;
2298
2299         if (changed_commit) {
2300                 /*
2301                  * Cache the commit in which the path was changed.
2302                  * This commit might be opened again soon.
2303                  */
2304                 changed_commit->refcnt++;
2305                 err = got_repo_cache_commit(repo, changed_commit_id,
2306                     changed_commit);
2307                 got_object_commit_close(changed_commit);
2308         }
2309 done:
2310         free(path_packfile);
2311         free(changed_commit_id);
2312         return err;
2313 }