gotwebd/got_operations.c

   1 /*
   2  * Copyright (c) 2020-2022 Tracey Emery <tracey@traceyemery.net>
   3  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include "got_compat.h"
  19
  20 #include <sys/queue.h>
  21 #include <sys/socket.h>
  22 #include <sys/stat.h>
  23
  24 #include <event.h>
  25 #include <imsg.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30
  31 #include "got_error.h"
  32 #include "got_object.h"
  33 #include "got_reference.h"
  34 #include "got_repository.h"
  35 #include "got_path.h"
  36 #include "got_cancel.h"
  37 #include "got_diff.h"
  38 #include "got_commit_graph.h"
  39 #include "got_blame.h"
  40 #include "got_privsep.h"
  41
  42 #include "proc.h"
  43 #include "gotwebd.h"
  44
  45 static const struct got_error *got_init_repo_commit(struct repo_commit **);
  46 static const struct got_error *got_init_repo_tag(struct repo_tag **);
  47 static const struct got_error *got_get_repo_commit(struct request *,
  48     struct repo_commit *, struct got_commit_object *, struct got_reflist_head *,
  49     struct got_object_id *);
  50 static const struct got_error *got_gotweb_dupfd(int *, int *);
  51 static const struct got_error *got_gotweb_openfile(FILE **, int *, int *);
  52 static const struct got_error *got_gotweb_blame_cb(void *, int, int,
  53     struct got_commit_object *,struct got_object_id *);
  54
  55 const struct got_error *
  56 got_gotweb_flushfile(FILE *f, int fd)
  57 {
  58         if (fseek(f, 0, SEEK_SET) == -1)
  59                 return got_error_from_errno("fseek");
  60
  61         if (ftruncate(fd, 0) == -1)
  62                 return got_error_from_errno("ftruncate");
  63
  64         if (fsync(fd) == -1)
  65                 return got_error_from_errno("fsync");
  66
  67         if (f && fclose(f) == EOF)
  68                 return got_error_from_errno("fclose");
  69
  70         if (fd != -1 && close(fd) != -1)
  71                 return got_error_from_errno("close");
  72
  73         return NULL;
  74 }
  75
  76 static const struct got_error *
  77 got_gotweb_openfile(FILE **f, int *priv_fd, int *fd)
  78 {
  79         *fd = dup(*priv_fd);
  80         if (*fd == -1)
  81                 return got_error_from_errno("dup");
  82
  83         *f = fdopen(*fd, "w+");
  84         if (*f == NULL) {
  85                 close(*fd);
  86                 return got_error(GOT_ERR_PRIVSEP_NO_FD);
  87         }
  88
  89         return NULL;
  90 }
  91
  92 static const struct got_error *
  93 got_gotweb_dupfd(int *priv_fd, int *fd)
  94 {
  95         *fd = dup(*priv_fd);
  96
  97         if (*fd == -1)
  98                 return got_error_from_errno("dup");
  99
 100         return NULL;
 101 }
 102
 103 const struct got_error *
 104 got_get_repo_owner(char **owner, struct request *c)
 105 {
 106         struct server *srv = c->srv;
 107         struct transport *t = c->t;
 108         struct got_repository *repo = t->repo;
 109         const char *gitconfig_owner;
 110
 111         *owner = NULL;
 112
 113         if (srv->show_repo_owner == 0)
 114                 return NULL;
 115
 116         gitconfig_owner = got_repo_get_gitconfig_owner(repo);
 117         if (gitconfig_owner) {
 118                 *owner = strdup(gitconfig_owner);
 119                 if (*owner == NULL)
 120                         return got_error_from_errno("strdup");
 121         } else {
 122                 *owner = strdup("");
 123                 if (*owner == NULL)
 124                         return got_error_from_errno("strdup");
 125         }
 126         return NULL;
 127 }
 128
 129 const struct got_error *
 130 got_get_repo_age(time_t *repo_age, struct request *c, const char *refname)
 131 {
 132         const struct got_error *error = NULL;
 133         struct server *srv = c->srv;
 134         struct transport *t = c->t;
 135         struct got_repository *repo = t->repo;
 136         struct got_commit_object *commit = NULL;
 137         struct got_reflist_head refs;
 138         struct got_reflist_entry *re;
 139         time_t committer_time = 0, cmp_time = 0;
 140
 141         TAILQ_INIT(&refs);
 142
 143         if (srv->show_repo_age == 0)
 144                 return NULL;
 145
 146         error = got_ref_list(&refs, repo, "refs/heads",
 147             got_ref_cmp_by_name, NULL);
 148         if (error)
 149                 goto done;
 150
 151         /*
 152          * Find the youngest branch tip in the repository, or the age of
 153          * the a specific branch tip if a name was provided by the caller.
 154          */
 155         TAILQ_FOREACH(re, &refs, entry) {
 156                 struct got_object_id *id = NULL;
 157
 158                 if (refname && strcmp(got_ref_get_name(re->ref), refname) != 0)
 159                         continue;
 160
 161                 error = got_ref_resolve(&id, repo, re->ref);
 162                 if (error)
 163                         goto done;
 164
 165                 error = got_object_open_as_commit(&commit, repo, id);
 166                 free(id);
 167                 if (error)
 168                         goto done;
 169
 170                 committer_time =
 171                     got_object_commit_get_committer_time(commit);
 172                 got_object_commit_close(commit);
 173                 if (cmp_time < committer_time)
 174                         cmp_time = committer_time;
 175
 176                 if (refname)
 177                         break;
 178         }
 179
 180         if (cmp_time != 0)
 181                 *repo_age = cmp_time;
 182 done:
 183         got_ref_list_free(&refs);
 184         return error;
 185 }
 186
 187 static const struct got_error *
 188 got_get_repo_commit(struct request *c, struct repo_commit *repo_commit,
 189     struct got_commit_object *commit, struct got_reflist_head *refs,
 190     struct got_object_id *id)
 191 {
 192         const struct got_error *error = NULL;
 193         struct got_reflist_entry *re;
 194         struct got_object_id *id2 = NULL;
 195         struct got_object_qid *parent_id;
 196         struct transport *t = c->t;
 197         struct querystring *qs = c->t->qs;
 198         char *commit_msg = NULL, *commit_msg0;
 199
 200         TAILQ_FOREACH(re, refs, entry) {
 201                 char *s;
 202                 const char *name;
 203                 struct got_tag_object *tag = NULL;
 204                 struct got_object_id *ref_id;
 205                 int cmp;
 206
 207                 if (got_ref_is_symbolic(re->ref))
 208                         continue;
 209
 210                 name = got_ref_get_name(re->ref);
 211                 if (strncmp(name, "refs/", 5) == 0)
 212                         name += 5;
 213                 if (strncmp(name, "got/", 4) == 0)
 214                         continue;
 215                 if (strncmp(name, "heads/", 6) == 0)
 216                         name += 6;
 217                 if (strncmp(name, "remotes/", 8) == 0) {
 218                         name += 8;
 219                         if (strstr(name, "/" GOT_REF_HEAD) != NULL)
 220                                 continue;
 221                 }
 222                 error = got_ref_resolve(&ref_id, t->repo, re->ref);
 223                 if (error)
 224                         return error;
 225                 if (strncmp(name, "tags/", 5) == 0) {
 226                         error = got_object_open_as_tag(&tag, t->repo, ref_id);
 227                         if (error) {
 228                                 if (error->code != GOT_ERR_OBJ_TYPE) {
 229                                         free(ref_id);
 230                                         continue;
 231                                 }
 232                                 /*
 233                                  * Ref points at something other
 234                                  * than a tag.
 235                                  */
 236                                 error = NULL;
 237                                 tag = NULL;
 238                         }
 239                 }
 240                 cmp = got_object_id_cmp(tag ?
 241                     got_object_tag_get_object_id(tag) : ref_id, id);
 242                 free(ref_id);
 243                 if (tag)
 244                         got_object_tag_close(tag);
 245                 if (cmp != 0)
 246                         continue;
 247                 s = repo_commit->refs_str;
 248                 if (asprintf(&repo_commit->refs_str, "%s%s%s", s ? s : "",
 249                     s ? ", " : "", name) == -1) {
 250                         error = got_error_from_errno("asprintf");
 251                         free(s);
 252                         repo_commit->refs_str = NULL;
 253                         return error;
 254                 }
 255                 free(s);
 256         }
 257
 258         error = got_object_id_str(&repo_commit->commit_id, id);
 259         if (error)
 260                 return error;
 261
 262         error = got_object_id_str(&repo_commit->tree_id,
 263             got_object_commit_get_tree_id(commit));
 264         if (error)
 265                 return error;
 266
 267         if (qs->action == DIFF) {
 268                 parent_id = STAILQ_FIRST(
 269                     got_object_commit_get_parent_ids(commit));
 270                 if (parent_id != NULL) {
 271                         id2 = got_object_id_dup(&parent_id->id);
 272                         error = got_object_id_str(&repo_commit->parent_id, id2);
 273                         if (error)
 274                                 return error;
 275                         free(id2);
 276                 } else {
 277                         repo_commit->parent_id = strdup("/dev/null");
 278                         if (repo_commit->parent_id == NULL) {
 279                                 error = got_error_from_errno("strdup");
 280                                 return error;
 281                         }
 282                 }
 283         }
 284
 285         repo_commit->committer_time =
 286             got_object_commit_get_committer_time(commit);
 287
 288         repo_commit->author =
 289             strdup(got_object_commit_get_author(commit));
 290         if (repo_commit->author == NULL) {
 291                 error = got_error_from_errno("strdup");
 292                 return error;
 293         }
 294         repo_commit->committer =
 295             strdup(got_object_commit_get_committer(commit));
 296         if (repo_commit->committer == NULL) {
 297                 error = got_error_from_errno("strdup");
 298                 return error;
 299         }
 300         error = got_object_commit_get_logmsg(&commit_msg0, commit);
 301         if (error)
 302                 return error;
 303
 304         commit_msg = commit_msg0;
 305         while (*commit_msg == '\n')
 306                 commit_msg++;
 307
 308         repo_commit->commit_msg = strdup(commit_msg);
 309         if (repo_commit->commit_msg == NULL)
 310                 error = got_error_from_errno("strdup");
 311         free(commit_msg0);
 312         return error;
 313 }
 314
 315 const struct got_error *
 316 got_get_repo_commits(struct request *c, int limit)
 317 {
 318         const struct got_error *error = NULL;
 319         struct got_object_id *id = NULL;
 320         struct got_commit_graph *graph = NULL;
 321         struct got_commit_object *commit = NULL;
 322         struct got_reflist_head refs;
 323         struct got_reference *ref = NULL;
 324         struct repo_commit *repo_commit = NULL;
 325         struct server *srv = c->srv;
 326         struct transport *t = c->t;
 327         struct got_repository *repo = t->repo;
 328         struct querystring *qs = t->qs;
 329         struct repo_dir *repo_dir = t->repo_dir;
 330         char *in_repo_path = NULL, *repo_path = NULL, *file_path = NULL;
 331         int chk_next = 0, chk_multi = 0;
 332
 333         TAILQ_INIT(&refs);
 334
 335         if (qs->file != NULL && strlen(qs->file) > 0)
 336                 if (asprintf(&file_path, "%s/%s", qs->folder ? qs->folder : "",
 337                     qs->file) == -1)
 338                         return got_error_from_errno("asprintf");
 339
 340         if (asprintf(&repo_path, "%s/%s", srv->repos_path,
 341             repo_dir->name) == -1) {
 342                 error = got_error_from_errno("asprintf");
 343                 goto done;
 344         }
 345
 346         if (qs->commit) {
 347                 error = got_repo_match_object_id_prefix(&id, qs->commit,
 348                     GOT_OBJ_TYPE_COMMIT, repo);
 349                 if (error)
 350                         goto done;
 351         } else {
 352                 error = got_ref_open(&ref, repo, qs->headref, 0);
 353                 if (error)
 354                         goto done;
 355
 356                 error = got_ref_resolve(&id, repo, ref);
 357                 if (error)
 358                         goto done;
 359         }
 360
 361         error = got_repo_map_path(&in_repo_path, repo, repo_path);
 362         if (error)
 363                 goto done;
 364
 365         error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
 366         if (error)
 367                 goto done;
 368
 369         if (qs->file != NULL && strlen(qs->file) > 0) {
 370                 error = got_commit_graph_open(&graph, file_path, 0);
 371                 if (error)
 372                         goto done;
 373         } else {
 374                 error = got_commit_graph_open(&graph, in_repo_path, 0);
 375                 if (error)
 376                         goto done;
 377         }
 378
 379         error = got_commit_graph_iter_start(graph, id, repo, NULL, NULL);
 380         if (error)
 381                 goto done;
 382
 383         for (;;) {
 384                 struct got_object_id next_id;
 385
 386                 error = got_commit_graph_iter_next(&next_id, graph, repo, NULL,
 387                     NULL);
 388                 if (error) {
 389                         if (error->code == GOT_ERR_ITER_COMPLETED)
 390                                 error = NULL;
 391                         goto done;
 392                 }
 393
 394                 error = got_object_open_as_commit(&commit, repo, &next_id);
 395                 if (error)
 396                         goto done;
 397
 398                 error = got_init_repo_commit(&repo_commit);
 399                 if (error)
 400                         goto done;
 401
 402                 error = got_get_repo_commit(c, repo_commit, commit,
 403                     &refs, &next_id);
 404                 if (error) {
 405                         gotweb_free_repo_commit(repo_commit);
 406                         goto done;
 407                 }
 408
 409                 TAILQ_INSERT_TAIL(&t->repo_commits, repo_commit, entry);
 410
 411                 if (!chk_multi || limit != 1 ||
 412                     srv->max_commits_display == 1) {
 413                         chk_multi = 1;
 414
 415                         /*
 416                          * check for one more commit before breaking,
 417                          * so we know whether to navigate through briefs
 418                          * commits and summary
 419                          */
 420                         if (chk_next && (qs->action == BRIEFS ||
 421                             qs->action == COMMITS || qs->action == SUMMARY)) {
 422                                 t->more_id = strdup(repo_commit->commit_id);
 423                                 if (t->more_id == NULL) {
 424                                         error = got_error_from_errno("strdup");
 425                                         goto done;
 426                                 }
 427                                 got_object_commit_close(commit);
 428                                 commit = NULL;
 429                                 TAILQ_REMOVE(&t->repo_commits, repo_commit,
 430                                     entry);
 431                                 gotweb_free_repo_commit(repo_commit);
 432                                 goto done;
 433                         }
 434                 }
 435                 if (error || (limit && --limit == 0)) {
 436                         if (qs->file != NULL && *qs->file != '\0')
 437                                 if (chk_multi == 0)
 438                                         break;
 439                         chk_next = 1;
 440                 }
 441                 if (commit) {
 442                         got_object_commit_close(commit);
 443                         commit = NULL;
 444                 }
 445         }
 446 done:
 447         if (ref)
 448                 got_ref_close(ref);
 449         if (commit)
 450                 got_object_commit_close(commit);
 451         if (graph)
 452                 got_commit_graph_close(graph);
 453         got_ref_list_free(&refs);
 454         free(in_repo_path);
 455         free(file_path);
 456         free(repo_path);
 457         free(id);
 458         return error;
 459 }
 460
 461 const struct got_error *
 462 got_get_repo_tags(struct request *c, int limit)
 463 {
 464         const struct got_error *error = NULL;
 465         struct got_object_id *id = NULL;
 466         struct got_commit_object *commit = NULL;
 467         struct got_reflist_head refs;
 468         struct got_reference *ref;
 469         struct got_reflist_entry *re;
 470         struct server *srv = c->srv;
 471         struct transport *t = c->t;
 472         struct got_repository *repo = t->repo;
 473         struct querystring *qs = t->qs;
 474         struct repo_dir *repo_dir = t->repo_dir;
 475         struct got_tag_object *tag = NULL;
 476         struct repo_tag *rt = NULL, *trt = NULL;
 477         char *in_repo_path = NULL, *repo_path = NULL, *id_str = NULL;
 478         char *tag_commit = NULL, *tag_commit0 = NULL;
 479         char *commit_msg = NULL, *commit_msg0 = NULL;
 480         int chk_next = 0, chk_multi = 1, commit_found = 0, c_cnt = 0;
 481
 482         TAILQ_INIT(&refs);
 483
 484         if (asprintf(&repo_path, "%s/%s", srv->repos_path,
 485             repo_dir->name) == -1)
 486                 return got_error_from_errno("asprintf");
 487
 488         if (qs->commit == NULL && (qs->action == TAGS || qs->action == RSS)) {
 489                 error = got_ref_open(&ref, repo, qs->headref, 0);
 490                 if (error)
 491                         goto err;
 492                 error = got_ref_resolve(&id, repo, ref);
 493                 got_ref_close(ref);
 494                 if (error)
 495                         goto err;
 496         } else if (qs->commit == NULL && qs->action == TAG) {
 497                 error = got_error_msg(GOT_ERR_EOF, "commit id missing");
 498                 goto err;
 499         } else {
 500                 error = got_repo_match_object_id_prefix(&id, qs->commit,
 501                     GOT_OBJ_TYPE_COMMIT, repo);
 502                 if (error)
 503                         goto err;
 504         }
 505
 506         if (qs->action != SUMMARY && qs->action != TAGS) {
 507                 error = got_object_open_as_commit(&commit, repo, id);
 508                 if (error)
 509                         goto err;
 510                 error = got_object_commit_get_logmsg(&commit_msg0, commit);
 511                 if (error)
 512                         goto err;
 513                 if (commit) {
 514                         got_object_commit_close(commit);
 515                         commit = NULL;
 516                 }
 517         }
 518
 519         error = got_repo_map_path(&in_repo_path, repo, repo_path);
 520         if (error)
 521                 goto err;
 522
 523         error = got_ref_list(&refs, repo, "refs/tags", got_ref_cmp_tags,
 524            repo);
 525         if (error)
 526                 goto err;
 527
 528         if (limit == 1)
 529                 chk_multi = 0;
 530
 531         /*
 532          * XXX: again, see previous message about caching
 533          */
 534
 535         TAILQ_FOREACH(re, &refs, entry) {
 536                 struct repo_tag *new_repo_tag = NULL;
 537                 error = got_init_repo_tag(&new_repo_tag);
 538                 if (error)
 539                         goto err;
 540
 541                 TAILQ_INSERT_TAIL(&t->repo_tags, new_repo_tag, entry);
 542
 543                 new_repo_tag->tag_name = strdup(got_ref_get_name(re->ref));
 544                 if (new_repo_tag->tag_name == NULL) {
 545                         error = got_error_from_errno("strdup");
 546                         goto err;
 547                 }
 548
 549                 free(id);
 550                 id = NULL;
 551
 552                 free(id_str);
 553                 id_str = NULL;
 554
 555                 error = got_ref_resolve(&id, repo, re->ref);
 556                 if (error)
 557                         goto done;
 558
 559                 if (tag)
 560                         got_object_tag_close(tag);
 561                 error = got_object_open_as_tag(&tag, repo, id);
 562                 if (error) {
 563                         if (error->code != GOT_ERR_OBJ_TYPE)
 564                                 goto done;
 565                         /* "lightweight" tag */
 566                         error = got_object_open_as_commit(&commit, repo, id);
 567                         if (error)
 568                                 goto done;
 569                         new_repo_tag->tagger =
 570                             strdup(got_object_commit_get_committer(commit));
 571                         if (new_repo_tag->tagger == NULL) {
 572                                 error = got_error_from_errno("strdup");
 573                                 goto err;
 574                         }
 575                         new_repo_tag->tagger_time =
 576                             got_object_commit_get_committer_time(commit);
 577                         error = got_object_id_str(&id_str, id);
 578                         if (error)
 579                                 goto err;
 580                 } else {
 581                         new_repo_tag->tagger =
 582                             strdup(got_object_tag_get_tagger(tag));
 583                         if (new_repo_tag->tagger == NULL) {
 584                                 error = got_error_from_errno("strdup");
 585                                 goto err;
 586                         }
 587                         new_repo_tag->tagger_time =
 588                             got_object_tag_get_tagger_time(tag);
 589                         error = got_object_id_str(&id_str,
 590                             got_object_tag_get_object_id(tag));
 591                         if (error)
 592                                 goto err;
 593                 }
 594
 595                 new_repo_tag->commit_id = strdup(id_str);
 596                 if (new_repo_tag->commit_id == NULL)
 597                         goto err;
 598
 599                 if (commit_found == 0 && qs->commit != NULL &&
 600                     strncmp(id_str, qs->commit, strlen(id_str)) != 0)
 601                         continue;
 602                 else
 603                         commit_found = 1;
 604
 605                 t->tag_count++;
 606
 607                 /*
 608                  * check for one more commit before breaking,
 609                  * so we know whether to navigate through briefs
 610                  * commits and summary
 611                  */
 612                 if (chk_next) {
 613                         t->next_id = strdup(new_repo_tag->commit_id);
 614                         if (t->next_id == NULL) {
 615                                 error = got_error_from_errno("strdup");
 616                                 goto err;
 617                         }
 618                         if (commit) {
 619                                 got_object_commit_close(commit);
 620                                 commit = NULL;
 621                         }
 622                         TAILQ_REMOVE(&t->repo_tags, new_repo_tag, entry);
 623                         gotweb_free_repo_tag(new_repo_tag);
 624                         goto done;
 625                 }
 626
 627                 if (commit) {
 628                         error = got_object_commit_get_logmsg(&tag_commit0,
 629                             commit);
 630                         if (error)
 631                                 goto err;
 632                         got_object_commit_close(commit);
 633                         commit = NULL;
 634                 } else {
 635                         tag_commit0 = strdup(got_object_tag_get_message(tag));
 636                         if (tag_commit0 == NULL) {
 637                                 error = got_error_from_errno("strdup");
 638                                 goto err;
 639                         }
 640                 }
 641
 642                 tag_commit = tag_commit0;
 643                 while (*tag_commit == '\n')
 644                         tag_commit++;
 645                 new_repo_tag->tag_commit = strdup(tag_commit);
 646                 if (new_repo_tag->tag_commit == NULL) {
 647                         error = got_error_from_errno("strdup");
 648                         free(tag_commit0);
 649                         goto err;
 650                 }
 651                 free(tag_commit0);
 652
 653                 if (qs->action != SUMMARY && qs->action != TAGS) {
 654                         commit_msg = commit_msg0;
 655                         while (*commit_msg == '\n')
 656                                 commit_msg++;
 657
 658                         new_repo_tag->commit_msg = strdup(commit_msg);
 659                         if (new_repo_tag->commit_msg == NULL) {
 660                                 error = got_error_from_errno("strdup");
 661                                 goto err;
 662                         }
 663                 }
 664
 665                 if (limit && --limit == 0) {
 666                         if (chk_multi == 0)
 667                                 break;
 668                         chk_next = 1;
 669                 }
 670         }
 671
 672 done:
 673         /*
 674          * we have tailq populated, so find previous commit id
 675          * for navigation through briefs and commits
 676          */
 677         if (t->tag_count == 0) {
 678                 TAILQ_FOREACH_SAFE(rt, &t->repo_tags, entry, trt) {
 679                         TAILQ_REMOVE(&t->repo_tags, rt, entry);
 680                         gotweb_free_repo_tag(rt);
 681                 }
 682         }
 683         if (t->tag_count > 0 && t->prev_id == NULL && qs->commit != NULL) {
 684                 commit_found = 0;
 685                 TAILQ_FOREACH_REVERSE(rt, &t->repo_tags, repo_tags_head,
 686                     entry) {
 687                         if (commit_found == 0 && rt->commit_id != NULL &&
 688                             strcmp(qs->commit, rt->commit_id) != 0) {
 689                                 continue;
 690                         } else
 691                                 commit_found = 1;
 692                         if (c_cnt == srv->max_commits_display ||
 693                             rt == TAILQ_FIRST(&t->repo_tags)) {
 694                                 t->prev_id = strdup(rt->commit_id);
 695                                 if (t->prev_id == NULL)
 696                                         error = got_error_from_errno("strdup");
 697                                 break;
 698                         }
 699                         c_cnt++;
 700                 }
 701         }
 702 err:
 703         if (commit)
 704                 got_object_commit_close(commit);
 705         if (tag)
 706                 got_object_tag_close(tag);
 707         got_ref_list_free(&refs);
 708         free(commit_msg0);
 709         free(in_repo_path);
 710         free(repo_path);
 711         free(id);
 712         free(id_str);
 713         return error;
 714 }
 715
 716 int
 717 got_output_repo_tree(struct request *c,
 718     int (*cb)(struct template *, struct got_tree_entry *))
 719 {
 720         const struct got_error *error = NULL;
 721         struct transport *t = c->t;
 722         struct got_commit_object *commit = NULL;
 723         struct got_repository *repo = t->repo;
 724         struct querystring *qs = t->qs;
 725         struct repo_commit *rc = NULL;
 726         struct got_object_id *tree_id = NULL, *commit_id = NULL;
 727         struct got_reflist_head refs;
 728         struct got_tree_object *tree = NULL;
 729         struct got_tree_entry *te;
 730         struct repo_dir *repo_dir = t->repo_dir;
 731         char *escaped_name = NULL, *path = NULL;
 732         int nentries, i;
 733
 734         TAILQ_INIT(&refs);
 735
 736         rc = TAILQ_FIRST(&t->repo_commits);
 737
 738         if (qs->folder != NULL) {
 739                 path = strdup(qs->folder);
 740                 if (path == NULL) {
 741                         error = got_error_from_errno("strdup");
 742                         goto done;
 743                 }
 744         } else {
 745                 error = got_repo_map_path(&path, repo, repo_dir->path);
 746                 if (error)
 747                         goto done;
 748         }
 749
 750         error = got_repo_match_object_id(&commit_id, NULL, rc->commit_id,
 751             GOT_OBJ_TYPE_COMMIT, &refs, repo);
 752         if (error)
 753                 goto done;
 754
 755         error = got_object_open_as_commit(&commit, repo, commit_id);
 756         if (error)
 757                 goto done;
 758
 759         error = got_object_id_by_path(&tree_id, repo, commit, path);
 760         if (error)
 761                 goto done;
 762
 763         error = got_object_open_as_tree(&tree, repo, tree_id);
 764         if (error)
 765                 goto done;
 766
 767         nentries = got_object_tree_get_nentries(tree);
 768
 769         for (i = 0; i < nentries; i++) {
 770                 te = got_object_tree_get_entry(tree, i);
 771                 if (cb(c->tp, te) == -1) {
 772                         error = got_error(GOT_ERR_CANCELLED);
 773                         break;
 774                 }
 775         }
 776 done:
 777         free(escaped_name);
 778         free(path);
 779         got_ref_list_free(&refs);
 780         if (commit)
 781                 got_object_commit_close(commit);
 782         if (tree)
 783                 got_object_tree_close(tree);
 784         free(commit_id);
 785         free(tree_id);
 786         if (error) {
 787                 log_warnx("%s: %s", __func__, error->msg);
 788                 return -1;
 789         }
 790         return 0;
 791 }
 792
 793 const struct got_error *
 794 got_open_blob_for_output(struct got_blob_object **blob, int *fd,
 795     int *binary, struct request *c)
 796 {
 797         const struct got_error *error = NULL;
 798         struct transport *t = c->t;
 799         struct got_repository *repo = t->repo;
 800         struct querystring *qs = c->t->qs;
 801         struct got_commit_object *commit = NULL;
 802         struct got_object_id *commit_id = NULL;
 803         struct got_reflist_head refs;
 804         char *path = NULL, *in_repo_path = NULL;
 805         int obj_type;
 806
 807         TAILQ_INIT(&refs);
 808
 809         *blob = NULL;
 810         *fd = -1;
 811         *binary = 0;
 812
 813         if (asprintf(&path, "%s%s%s", qs->folder ? qs->folder : "",
 814             qs->folder ? "/" : "", qs->file) == -1) {
 815                 error = got_error_from_errno("asprintf");
 816                 goto done;
 817         }
 818
 819         error = got_repo_map_path(&in_repo_path, repo, path);
 820         if (error)
 821                 goto done;
 822
 823         error = got_repo_match_object_id(&commit_id, NULL, qs->commit,
 824             GOT_OBJ_TYPE_COMMIT, &refs, repo);
 825         if (error)
 826                 goto done;
 827
 828         error = got_object_open_as_commit(&commit, repo, commit_id);
 829         if (error)
 830                 goto done;
 831
 832         error = got_object_id_by_path(&commit_id, repo, commit, in_repo_path);
 833         if (error)
 834                 goto done;
 835
 836         if (commit_id == NULL) {
 837                 error = got_error(GOT_ERR_NO_OBJ);
 838                 goto done;
 839         }
 840
 841         error = got_object_get_type(&obj_type, repo, commit_id);
 842         if (error)
 843                 goto done;
 844
 845         if (obj_type != GOT_OBJ_TYPE_BLOB) {
 846                 error = got_error(GOT_ERR_OBJ_TYPE);
 847                 goto done;
 848         }
 849
 850         error = got_gotweb_dupfd(&c->priv_fd[BLOB_FD_1], fd);
 851         if (error)
 852                 goto done;
 853
 854         error = got_object_open_as_blob(blob, repo, commit_id, BUF, *fd);
 855         if (error)
 856                 goto done;
 857
 858         error = got_object_blob_is_binary(binary, *blob);
 859         if (error)
 860                 goto done;
 861
 862  done:
 863         if (commit)
 864                 got_object_commit_close(commit);
 865
 866         if (error) {
 867                 if (*fd != -1)
 868                         close(*fd);
 869                 if (*blob)
 870                         got_object_blob_close(*blob);
 871                 *fd = -1;
 872                 *blob = NULL;
 873         }
 874
 875         free(in_repo_path);
 876         free(commit_id);
 877         free(path);
 878         return error;
 879 }
 880
 881 int
 882 got_output_blob_by_lines(struct template *tp, struct got_blob_object *blob,
 883     int (*cb)(struct template *, const char *, size_t))
 884 {
 885         const struct got_error  *err;
 886         char                    *line = NULL;
 887         size_t                   linesize = 0;
 888         size_t                   lineno = 0;
 889         ssize_t                  linelen = 0;
 890
 891         for (;;) {
 892                 err = got_object_blob_getline(&line, &linelen, &linesize,
 893                     blob);
 894                 if (err || linelen == -1)
 895                         break;
 896                 lineno++;
 897                 if (cb(tp, line, lineno) == -1) {
 898                         err = got_error(GOT_ERR_CANCELLED);
 899                         break;
 900                 }
 901         }
 902
 903         free(line);
 904
 905         if (err) {
 906                 log_warnx("%s: got_object_blob_getline failed: %s",
 907                     __func__, err->msg);
 908                 return -1;
 909         }
 910         return 0;
 911 }
 912
 913 struct blame_cb_args {
 914         struct blame_line *lines;
 915         int nlines;
 916         int nlines_prec;
 917         int lineno_cur;
 918         off_t *line_offsets;
 919         FILE *f;
 920         struct got_repository *repo;
 921         struct request *c;
 922         got_render_blame_line_cb cb;
 923 };
 924
 925 static const struct got_error *
 926 got_gotweb_blame_cb(void *arg, int nlines, int lineno,
 927     struct got_commit_object *commit, struct got_object_id *id)
 928 {
 929         const struct got_error *err = NULL;
 930         struct blame_cb_args *a = arg;
 931         struct blame_line *bline;
 932         struct request *c = a->c;
 933         char *line = NULL;
 934         size_t linesize = 0;
 935         off_t offset;
 936         struct tm tm;
 937         time_t committer_time;
 938
 939         if (nlines != a->nlines ||
 940             (lineno != -1 && lineno < 1) || lineno > a->nlines)
 941                 return got_error(GOT_ERR_RANGE);
 942
 943         if (lineno == -1)
 944                 return NULL; /* no change in this commit */
 945
 946         /* Annotate this line. */
 947         bline = &a->lines[lineno - 1];
 948         if (bline->annotated)
 949                 return NULL;
 950         err = got_object_id_str(&bline->id_str, id);
 951         if (err)
 952                 return err;
 953
 954         bline->committer = strdup(got_object_commit_get_committer(commit));
 955         if (bline->committer == NULL) {
 956                 err = got_error_from_errno("strdup");
 957                 goto done;
 958         }
 959
 960         committer_time = got_object_commit_get_committer_time(commit);
 961         if (gmtime_r(&committer_time, &tm) == NULL)
 962                 return got_error_from_errno("gmtime_r");
 963         if (strftime(bline->datebuf, sizeof(bline->datebuf), "%G-%m-%d",
 964             &tm) == 0) {
 965                 err = got_error(GOT_ERR_NO_SPACE);
 966                 goto done;
 967         }
 968         bline->annotated = 1;
 969
 970         /* Print lines annotated so far. */
 971         bline = &a->lines[a->lineno_cur - 1];
 972         if (!bline->annotated)
 973                 goto done;
 974
 975         offset = a->line_offsets[a->lineno_cur - 1];
 976         if (fseeko(a->f, offset, SEEK_SET) == -1) {
 977                 err = got_error_from_errno("fseeko");
 978                 goto done;
 979         }
 980
 981         while (a->lineno_cur <= a->nlines && bline->annotated) {
 982                 if (getline(&line, &linesize, a->f) == -1) {
 983                         if (ferror(a->f))
 984                                 err = got_error_from_errno("getline");
 985                         break;
 986                 }
 987
 988                 if (a->cb(c->tp, line, bline, a->nlines_prec,
 989                     a->lineno_cur) == -1) {
 990                         err = got_error(GOT_ERR_CANCELLED);
 991                         break;
 992                 }
 993
 994                 a->lineno_cur++;
 995                 bline = &a->lines[a->lineno_cur - 1];
 996         }
 997 done:
 998         free(line);
 999         return err;
1000 }
1001
1002 const struct got_error *
1003 got_output_file_blame(struct request *c, got_render_blame_line_cb cb)
1004 {
1005         const struct got_error *error = NULL;
1006         struct transport *t = c->t;
1007         struct got_repository *repo = t->repo;
1008         struct querystring *qs = c->t->qs;
1009         struct got_object_id *obj_id = NULL, *commit_id = NULL;
1010         struct got_commit_object *commit = NULL;
1011         struct got_reflist_head refs;
1012         struct got_blob_object *blob = NULL;
1013         char *path = NULL, *in_repo_path = NULL;
1014         struct blame_cb_args bca;
1015         int i, obj_type, fd1 = -1, fd2 = -1, fd3 = -1, fd4 = -1, fd5 = -1;
1016         int fd6 = -1;
1017         off_t filesize;
1018         FILE *f1 = NULL, *f2 = NULL;
1019
1020         TAILQ_INIT(&refs);
1021         bca.f = NULL;
1022         bca.lines = NULL;
1023         bca.cb = cb;
1024
1025         if (asprintf(&path, "%s%s%s", qs->folder ? qs->folder : "",
1026             qs->folder ? "/" : "", qs->file) == -1) {
1027                 error = got_error_from_errno("asprintf");
1028                 goto done;
1029         }
1030
1031         error = got_repo_map_path(&in_repo_path, repo, path);
1032         if (error)
1033                 goto done;
1034
1035         error = got_repo_match_object_id(&commit_id, NULL, qs->commit,
1036             GOT_OBJ_TYPE_COMMIT, &refs, repo);
1037         if (error)
1038                 goto done;
1039
1040         error = got_object_open_as_commit(&commit, repo, commit_id);
1041         if (error)
1042                 goto done;
1043
1044         error = got_object_id_by_path(&obj_id, repo, commit, in_repo_path);
1045         if (error)
1046                 goto done;
1047
1048         error = got_object_get_type(&obj_type, repo, obj_id);
1049         if (error)
1050                 goto done;
1051
1052         if (obj_type != GOT_OBJ_TYPE_BLOB) {
1053                 error = got_error(GOT_ERR_OBJ_TYPE);
1054                 goto done;
1055         }
1056
1057         error = got_gotweb_openfile(&bca.f, &c->priv_fd[BLAME_FD_1], &fd1);
1058         if (error)
1059                 goto done;
1060
1061         error = got_gotweb_dupfd(&c->priv_fd[BLAME_FD_2], &fd2);
1062         if (error)
1063                 goto done;
1064
1065         error = got_object_open_as_blob(&blob, repo, obj_id, BUF, fd2);
1066         if (error)
1067                 goto done;
1068
1069         error = got_object_blob_dump_to_file(&filesize, &bca.nlines,
1070             &bca.line_offsets, bca.f, blob);
1071         if (error || bca.nlines == 0)
1072                 goto done;
1073
1074         /* Don't include \n at EOF in the blame line count. */
1075         if (bca.line_offsets[bca.nlines - 1] == filesize)
1076                 bca.nlines--;
1077
1078         bca.lines = calloc(bca.nlines, sizeof(*bca.lines));
1079         if (bca.lines == NULL) {
1080                 error = got_error_from_errno("calloc");
1081                 goto done;
1082         }
1083         bca.lineno_cur = 1;
1084         bca.nlines_prec = 0;
1085         i = bca.nlines;
1086         while (i > 0) {
1087                 i /= 10;
1088                 bca.nlines_prec++;
1089         }
1090         bca.repo = repo;
1091         bca.c = c;
1092
1093         error = got_gotweb_dupfd(&c->priv_fd[BLAME_FD_3], &fd3);
1094         if (error)
1095                 goto done;
1096
1097         error = got_gotweb_dupfd(&c->priv_fd[BLAME_FD_4], &fd4);
1098         if (error)
1099                 goto done;
1100
1101         error = got_gotweb_openfile(&f1, &c->priv_fd[BLAME_FD_5], &fd5);
1102         if (error)
1103                 goto done;
1104
1105         error = got_gotweb_openfile(&f2, &c->priv_fd[BLAME_FD_6], &fd6);
1106         if (error)
1107                 goto done;
1108
1109         error = got_blame(in_repo_path, commit_id, repo,
1110             GOT_DIFF_ALGORITHM_MYERS, got_gotweb_blame_cb, &bca, NULL, NULL,
1111             fd3, fd4, f1, f2);
1112
1113 done:
1114         if (bca.lines) {
1115                 free(bca.line_offsets);
1116                 for (i = 0; i < bca.nlines; i++) {
1117                         struct blame_line *bline = &bca.lines[i];
1118                         free(bline->id_str);
1119                         free(bline->committer);
1120                 }
1121         }
1122         free(bca.lines);
1123         if (fd2 != -1 && close(fd2) == -1 && error == NULL)
1124                 error = got_error_from_errno("close");
1125         if (fd3 != -1 && close(fd3) == -1 && error == NULL)
1126                 error = got_error_from_errno("close");
1127         if (fd4 != -1 && close(fd4) == -1 && error == NULL)
1128                 error = got_error_from_errno("close");
1129         if (bca.f) {
1130                 const struct got_error *bca_err =
1131                     got_gotweb_flushfile(bca.f, fd1);
1132                 if (error == NULL)
1133                         error = bca_err;
1134         }
1135         if (f1) {
1136                 const struct got_error *f1_err =
1137                     got_gotweb_flushfile(f1, fd5);
1138                 if (error == NULL)
1139                         error = f1_err;
1140         }
1141         if (f2) {
1142                 const struct got_error *f2_err =
1143                     got_gotweb_flushfile(f2, fd6);
1144                 if (error == NULL)
1145                         error = f2_err;
1146         }
1147         if (commit)
1148                 got_object_commit_close(commit);
1149         if (blob)
1150                 got_object_blob_close(blob);
1151         free(in_repo_path);
1152         free(commit_id);
1153         free(obj_id);
1154         free(path);
1155         got_ref_list_free(&refs);
1156         return error;
1157 }
1158
1159 const struct got_error *
1160 got_open_diff_for_output(FILE **fp, int *fd, struct request *c)
1161 {
1162         const struct got_error *error = NULL;
1163         struct transport *t = c->t;
1164         struct got_repository *repo = t->repo;
1165         struct repo_commit *rc = NULL;
1166         struct got_object_id *id1 = NULL, *id2 = NULL;
1167         struct got_reflist_head refs;
1168         FILE *f1 = NULL, *f2 = NULL, *f3 = NULL;
1169         int obj_type, fd1, fd2, fd3, fd4 = -1, fd5 = -1;
1170
1171         *fp = NULL;
1172         *fd = -1;
1173
1174         TAILQ_INIT(&refs);
1175
1176         error = got_gotweb_openfile(&f1, &c->priv_fd[DIFF_FD_1], &fd1);
1177         if (error)
1178                 return error;
1179
1180         error = got_gotweb_openfile(&f2, &c->priv_fd[DIFF_FD_2], &fd2);
1181         if (error)
1182                 return error;
1183
1184         error = got_gotweb_openfile(&f3, &c->priv_fd[DIFF_FD_3], &fd3);
1185         if (error)
1186                 return error;
1187
1188         rc = TAILQ_FIRST(&t->repo_commits);
1189
1190         if (rc->parent_id != NULL &&
1191             strncmp(rc->parent_id, "/dev/null", 9) != 0) {
1192                 error = got_repo_match_object_id(&id1, NULL,
1193                     rc->parent_id, GOT_OBJ_TYPE_ANY,
1194                     &refs, repo);
1195                 if (error)
1196                         goto done;
1197         }
1198
1199         error = got_repo_match_object_id(&id2, NULL, rc->commit_id,
1200             GOT_OBJ_TYPE_ANY, &refs, repo);
1201         if (error)
1202                 goto done;
1203
1204         error = got_object_get_type(&obj_type, repo, id2);
1205         if (error)
1206                 goto done;
1207
1208         error = got_gotweb_dupfd(&c->priv_fd[DIFF_FD_4], &fd4);
1209         if (error)
1210                 goto done;
1211
1212         error = got_gotweb_dupfd(&c->priv_fd[DIFF_FD_5], &fd5);
1213         if (error)
1214                 goto done;
1215
1216         switch (obj_type) {
1217         case GOT_OBJ_TYPE_BLOB:
1218                 error = got_diff_objects_as_blobs(NULL, NULL, f1, f2, fd4, fd5,
1219                      id1, id2, NULL, NULL, GOT_DIFF_ALGORITHM_MYERS, 3, 0, 0,
1220                      NULL, repo, f3);
1221                 break;
1222         case GOT_OBJ_TYPE_TREE:
1223                 error = got_diff_objects_as_trees(NULL, NULL, f1, f2, fd4, fd5,
1224                     id1, id2, NULL, "", "",  GOT_DIFF_ALGORITHM_MYERS, 3, 0, 0,
1225                     NULL, repo, f3);
1226                 break;
1227         case GOT_OBJ_TYPE_COMMIT:
1228                 error = got_diff_objects_as_commits(NULL, NULL, f1, f2, fd4,
1229                     fd5, id1, id2, NULL,  GOT_DIFF_ALGORITHM_MYERS, 3, 0, 0,
1230                     NULL, repo, f3);
1231                 break;
1232         default:
1233                 error = got_error(GOT_ERR_OBJ_TYPE);
1234         }
1235         if (error)
1236                 goto done;
1237
1238         if (fseek(f1, 0, SEEK_SET) == -1) {
1239                 error = got_ferror(f1, GOT_ERR_IO);
1240                 goto done;
1241         }
1242
1243         if (fseek(f2, 0, SEEK_SET) == -1) {
1244                 error = got_ferror(f2, GOT_ERR_IO);
1245                 goto done;
1246         }
1247
1248         if (fseek(f3, 0, SEEK_SET) == -1) {
1249                 error = got_ferror(f3, GOT_ERR_IO);
1250                 goto done;
1251         }
1252
1253         *fp = f3;
1254         *fd = fd3;
1255
1256 done:
1257         if (fd4 != -1 && close(fd4) == -1 && error == NULL)
1258                 error = got_error_from_errno("close");
1259         if (fd5 != -1 && close(fd5) == -1 && error == NULL)
1260                 error = got_error_from_errno("close");
1261         if (f1) {
1262                 const struct got_error *f1_err =
1263                     got_gotweb_flushfile(f1, fd1);
1264                 if (error == NULL)
1265                         error = f1_err;
1266         }
1267         if (f2) {
1268                 const struct got_error *f2_err =
1269                     got_gotweb_flushfile(f2, fd2);
1270                 if (error == NULL)
1271                         error = f2_err;
1272         }
1273         if (error && f3) {
1274                 got_gotweb_flushfile(f3, fd3);
1275                 *fp = NULL;
1276                 *fd = -1;
1277         }
1278         got_ref_list_free(&refs);
1279         free(id1);
1280         free(id2);
1281         return error;
1282 }
1283
1284 static const struct got_error *
1285 got_init_repo_commit(struct repo_commit **rc)
1286 {
1287         *rc = calloc(1, sizeof(**rc));
1288         if (*rc == NULL)
1289                 return got_error_from_errno2("%s: calloc", __func__);
1290
1291         (*rc)->path = NULL;
1292         (*rc)->refs_str = NULL;
1293         (*rc)->commit_id = NULL;
1294         (*rc)->committer = NULL;
1295         (*rc)->author = NULL;
1296         (*rc)->parent_id = NULL;
1297         (*rc)->tree_id = NULL;
1298         (*rc)->commit_msg = NULL;
1299
1300         return NULL;
1301 }
1302
1303 static const struct got_error *
1304 got_init_repo_tag(struct repo_tag **rt)
1305 {
1306         *rt = calloc(1, sizeof(**rt));
1307         if (*rt == NULL)
1308                 return got_error_from_errno2("%s: calloc", __func__);
1309
1310         (*rt)->commit_id = NULL;
1311         (*rt)->tag_name = NULL;
1312         (*rt)->tag_commit = NULL;
1313         (*rt)->commit_msg = NULL;
1314         (*rt)->tagger = NULL;
1315
1316         return NULL;
1317 }