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