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