lib/gitweb.pm

   1 co#!/usr/bin/perl
   2
   3 # gitweb - simple web interface to track changes in git repositories
   4 #
   5 # (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
   6 # (C) 2005, Christian Gierke
   7 #
   8 # This program is licensed under the GPLv2
   9 package gitweb;
  10
  11 use strict;
  12 use warnings;
  13 use CGI qw(:standard :escapeHTML -nosticky);
  14 use CGI::Util qw(unescape);
  15 use CGI::Carp qw(fatalsToBrowser);
  16 use Encode;
  17 use Fcntl ':mode';
  18 use File::Find qw();
  19 use File::Basename qw(basename);
  20 use FindBin;
  21 binmode STDOUT, ':utf8';
  22
  23 BEGIN {
  24         CGI->compile();
  25 }
  26
  27 use vars qw(
  28         $cgi $version $my_url $my_uri $base_url $path_info $GIT $projectroot
  29         $project_maxdepth $home_link $home_link_str $site_name $site_header
  30         $home_text $site_footer @stylesheets $stylesheet $logo $favicon
  31         $logo_url $logo_label $logo_url $logo_label $projects_list
  32         $projects_list_description_width $default_projects_order
  33         $export_ok $export_auth_hook $strict_export @git_base_url_list
  34         $default_blob_plain_mimetype $default_text_plain_charset
  35         $mimetypes_file $fallback_encoding @diff_opts $prevent_xss
  36         %known_snapshot_formats %known_snapshot_format_aliases %feature
  37         $GITWEB_CONFIG $GITWEB_CONFIG $GITWEB_CONFIG_SYSTEM $git_version
  38         %input_params @cgi_param_mapping %cgi_param_mapping %actions
  39         %allowed_options $action $project $file_name $file_parent $hash
  40         $hash_parent $hash_base @extra_options $hash_parent_base $page
  41         $searchtype $search_use_regexp $searchtext $search_regexp $git_dir
  42         @snapshot_fmts
  43
  44         $c
  45 );
  46
  47 sub main {
  48         our $c   = shift;
  49
  50         our $cgi = new CGI;
  51         our $version = "1.6.3.3";
  52         our $my_url = $cgi->url();
  53         our $my_uri = $cgi->url(-absolute => 1);
  54
  55         # Base URL for relative URLs in gitweb ($logo, $favicon, ...),
  56         # needed and used only for URLs with nonempty PATH_INFO
  57         our $base_url = $my_url;
  58
  59         # When the script is used as DirectoryIndex, the URL does not contain the name
  60         # of the script file itself, and $cgi->url() fails to strip PATH_INFO, so we
  61         # have to do it ourselves. We make $path_info global because it's also used
  62         # later on.
  63         #
  64         # Another issue with the script being the DirectoryIndex is that the resulting
  65         # $my_url data is not the full script URL: this is good, because we want
  66         # generated links to keep implying the script name if it wasn't explicitly
  67         # indicated in the URL we're handling, but it means that $my_url cannot be used
  68         # as base URL.
  69         # Therefore, if we needed to strip PATH_INFO, then we know that we have
  70         # to build the base URL ourselves:
  71         our $path_info = $ENV{"PATH_INFO"};
  72         if ($path_info) {
  73                 if ($my_url =~ s,\Q$path_info\E$,, &&
  74                     $my_uri =~ s,\Q$path_info\E$,, &&
  75                     defined $ENV{'SCRIPT_NAME'}) {
  76                         $base_url = $cgi->url(-base => 1) . $ENV{'SCRIPT_NAME'};
  77                 }
  78         }
  79
  80         # core git executable to use
  81         # this can just be "git" if your webserver has a sensible PATH
  82         our $GIT = "/usr/bin/git";
  83
  84         # absolute fs-path which will be prepended to the project path
  85         our $projectroot = "/pub/scm";
  86
  87         # fs traversing limit for getting project list
  88         # the number is relative to the projectroot
  89         our $project_maxdepth = 2007;
  90
  91         # target of the home link on top of all pages
  92         our $home_link = $my_uri || "/";
  93
  94         # string of the home link on top of all pages
  95         our $home_link_str = "Project Gitalist";
  96
  97         # name of your site or organization to appear in page titles
  98         # replace this with something more descriptive for clearer bookmarks
  99         our $site_name = ""
 100                          || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
 101
 102         # filename of html text to include at top of each page
 103         our $site_header = "";
 104         # html text to include at home page
 105         our $home_text = "indextext.html";
 106         # filename of html text to include at bottom of each page
 107         our $site_footer = "";
 108
 109         # URI of stylesheets
 110         our @stylesheets = ("gitweb.css");
 111         # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
 112         our $stylesheet = undef;
 113         # URI of GIT logo (72x27 size)
 114         our $logo = "git-logo.png";
 115         # URI of GIT favicon, assumed to be image/png type
 116         our $favicon = "git-favicon.png";
 117
 118         # URI and label (title) of GIT logo link
 119         our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
 120         our $logo_label = "git documentation";
 121
 122         # source of projects list
 123         our $projects_list = "";
 124
 125         # the width (in characters) of the projects list "Description" column
 126         our $projects_list_description_width = 25;
 127
 128         # default order of projects list
 129         # valid values are none, project, descr, owner, and age
 130         our $default_projects_order = "project";
 131
 132         # show repository only if this file exists
 133         # (only effective if this variable evaluates to true)
 134         our $export_ok = "";
 135
 136         # show repository only if this subroutine returns true
 137         # when given the path to the project, for example:
 138         #    sub { return -e "$_[0]/git-daemon-export-ok"; }
 139         our $export_auth_hook = undef;
 140
 141         # only allow viewing of repositories also shown on the overview page
 142         our $strict_export = "";
 143
 144         # list of git base URLs used for URL to where fetch project from,
 145         # i.e. full URL is "$git_base_url/$project"
 146         our @git_base_url_list = grep { $_ ne '' } ("");
 147
 148         # default blob_plain mimetype and default charset for text/plain blob
 149         our $default_blob_plain_mimetype = 'text/plain';
 150         our $default_text_plain_charset  = undef;
 151
 152         # file to use for guessing MIME types before trying /etc/mime.types
 153         # (relative to the current git repository)
 154         our $mimetypes_file = undef;
 155
 156         # assume this charset if line contains non-UTF-8 characters;
 157         # it should be valid encoding (see Encoding::Supported(3pm) for list),
 158         # for which encoding all byte sequences are valid, for example
 159         # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
 160         # could be even 'utf-8' for the old behavior)
 161         our $fallback_encoding = 'latin1';
 162
 163         # rename detection options for git-diff and git-diff-tree
 164         # - default is '-M', with the cost proportional to
 165         #   (number of removed files) * (number of new files).
 166         # - more costly is '-C' (which implies '-M'), with the cost proportional to
 167         #   (number of changed files + number of removed files) * (number of new files)
 168         # - even more costly is '-C', '--find-copies-harder' with cost
 169         #   (number of files in the original tree) * (number of new files)
 170         # - one might want to include '-B' option, e.g. '-B', '-M'
 171         our @diff_opts = ('-M'); # taken from git_commit
 172
 173         # Disables features that would allow repository owners to inject script into
 174         # the gitweb domain.
 175         our $prevent_xss = 0;
 176
 177         # information about snapshot formats that gitweb is capable of serving
 178         our %known_snapshot_formats = (
 179                 # name => {
 180                 #       'display' => display name,
 181                 #       'type' => mime type,
 182                 #       'suffix' => filename suffix,
 183                 #       'format' => --format for git-archive,
 184                 #       'compressor' => [compressor command and arguments]
 185                 #                       (array reference, optional)}
 186                 #
 187                 'tgz' => {
 188                         'display' => 'tar.gz',
 189                         'type' => 'application/x-gzip',
 190                         'suffix' => '.tar.gz',
 191                         'format' => 'tar',
 192                         'compressor' => ['gzip']},
 193
 194                 'tbz2' => {
 195                         'display' => 'tar.bz2',
 196                         'type' => 'application/x-bzip2',
 197                         'suffix' => '.tar.bz2',
 198                         'format' => 'tar',
 199                         'compressor' => ['bzip2']},
 200
 201                 'zip' => {
 202                         'display' => 'zip',
 203                         'type' => 'application/x-zip',
 204                         'suffix' => '.zip',
 205                         'format' => 'zip'},
 206         );
 207
 208         # Aliases so we understand old gitweb.snapshot values in repository
 209         # configuration.
 210         our %known_snapshot_format_aliases = (
 211                 'gzip'  => 'tgz',
 212                 'bzip2' => 'tbz2',
 213
 214                 # backward compatibility: legacy gitweb config support
 215                 'x-gzip' => undef, 'gz' => undef,
 216                 'x-bzip2' => undef, 'bz2' => undef,
 217                 'x-zip' => undef, '' => undef,
 218         );
 219
 220         my $feature_bool = sub {
 221                 my $key = shift;
 222                 my ($val) = git_get_project_config($key, '--bool');
 223
 224                 if (!defined $val) {
 225                         return ($_[0]);
 226                 } elsif ($val eq 'true') {
 227                         return (1);
 228                 } elsif ($val eq 'false') {
 229                         return (0);
 230                 }
 231         };
 232
 233         my $feature_snapshot = sub {
 234                 my (@fmts) = @_;
 235
 236                 my ($val) = git_get_project_config('snapshot');
 237
 238                 if ($val) {
 239                         @fmts = ($val eq 'none' ? () : split /\s*[,\s]\s*/, $val);
 240                 }
 241
 242                 return @fmts;
 243         };
 244
 245         my $feature_patches = sub {
 246                 my @val = (git_get_project_config('patches', '--int'));
 247
 248                 if (@val) {
 249                         return @val;
 250                 }
 251
 252                 return ($_[0]);
 253         };
 254
 255
 256         # You define site-wide feature defaults here; override them with
 257         # $GITWEB_CONFIG as necessary.
 258         our %feature = (
 259                 # feature => {
 260                 #       'sub' => feature-sub (subroutine),
 261                 #       'override' => allow-override (boolean),
 262                 #       'default' => [ default options...] (array reference)}
 263                 #
 264                 # if feature is overridable (it means that allow-override has true value),
 265                 # then feature-sub will be called with default options as parameters;
 266                 # return value of feature-sub indicates if to enable specified feature
 267                 #
 268                 # if there is no 'sub' key (no feature-sub), then feature cannot be
 269                 # overriden
 270                 #
 271                 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
 272                 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
 273                 # is enabled
 274
 275                 # Enable the 'blame' blob view, showing the last commit that modified
 276                 # each line in the file. This can be very CPU-intensive.
 277
 278                 # To enable system wide have in $GITWEB_CONFIG
 279                 # $feature{'blame'}{'default'} = [1];
 280                 # To have project specific config enable override in $GITWEB_CONFIG
 281                 # $feature{'blame'}{'override'} = 1;
 282                 # and in project config gitweb.blame = 0|1;
 283                 'blame' => {
 284                         'sub' => sub { &$feature_bool('blame', @_) },
 285                         'override' => 0,
 286                         'default' => [0]},
 287
 288                 # Enable the 'snapshot' link, providing a compressed archive of any
 289                 # tree. This can potentially generate high traffic if you have large
 290                 # project.
 291
 292                 # Value is a list of formats defined in %known_snapshot_formats that
 293                 # you wish to offer.
 294                 # To disable system wide have in $GITWEB_CONFIG
 295                 # $feature{'snapshot'}{'default'} = [];
 296                 # To have project specific config enable override in $GITWEB_CONFIG
 297                 # $feature{'snapshot'}{'override'} = 1;
 298                 # and in project config, a comma-separated list of formats or "none"
 299                 # to disable.  Example: gitweb.snapshot = tbz2,zip;
 300                 'snapshot' => {
 301                         'sub' => $feature_snapshot,
 302                         'override' => 0,
 303                         'default' => ['tgz']},
 304
 305                 # Enable text search, which will list the commits which match author,
 306                 # committer or commit text to a given string.  Enabled by default.
 307                 # Project specific override is not supported.
 308                 'search' => {
 309                         'override' => 0,
 310                         'default' => [1]},
 311
 312                 # Enable grep search, which will list the files in currently selected
 313                 # tree containing the given string. Enabled by default. This can be
 314                 # potentially CPU-intensive, of course.
 315
 316                 # To enable system wide have in $GITWEB_CONFIG
 317                 # $feature{'grep'}{'default'} = [1];
 318                 # To have project specific config enable override in $GITWEB_CONFIG
 319                 # $feature{'grep'}{'override'} = 1;
 320                 # and in project config gitweb.grep = 0|1;
 321                 'grep' => {
 322                         'sub' => sub { &$feature_bool('grep', @_) },
 323                         'override' => 0,
 324                         'default' => [1]},
 325
 326                 # Enable the pickaxe search, which will list the commits that modified
 327                 # a given string in a file. This can be practical and quite faster
 328                 # alternative to 'blame', but still potentially CPU-intensive.
 329
 330                 # To enable system wide have in $GITWEB_CONFIG
 331                 # $feature{'pickaxe'}{'default'} = [1];
 332                 # To have project specific config enable override in $GITWEB_CONFIG
 333                 # $feature{'pickaxe'}{'override'} = 1;
 334                 # and in project config gitweb.pickaxe = 0|1;
 335                 'pickaxe' => {
 336                         'sub' => sub { &$feature_bool('pickaxe', @_) },
 337                         'override' => 0,
 338                         'default' => [1]},
 339
 340                 # Make gitweb use an alternative format of the URLs which can be
 341                 # more readable and natural-looking: project name is embedded
 342                 # directly in the path and the query string contains other
 343                 # auxiliary information. All gitweb installations recognize
 344                 # URL in either format; this configures in which formats gitweb
 345                 # generates links.
 346
 347                 # To enable system wide have in $GITWEB_CONFIG
 348                 # $feature{'pathinfo'}{'default'} = [1];
 349                 # Project specific override is not supported.
 350
 351                 # Note that you will need to change the default location of CSS,
 352                 # favicon, logo and possibly other files to an absolute URL. Also,
 353                 # if gitweb.cgi serves as your indexfile, you will need to force
 354                 # $my_uri to contain the script name in your $GITWEB_CONFIG.
 355                 'pathinfo' => {
 356                         'override' => 0,
 357                         'default' => [0]},
 358
 359                 # Make gitweb consider projects in project root subdirectories
 360                 # to be forks of existing projects. Given project $projname.git,
 361                 # projects matching $projname/*.git will not be shown in the main
 362                 # projects list, instead a '+' mark will be added to $projname
 363                 # there and a 'forks' view will be enabled for the project, listing
 364                 # all the forks. If project list is taken from a file, forks have
 365                 # to be listed after the main project.
 366
 367                 # To enable system wide have in $GITWEB_CONFIG
 368                 # $feature{'forks'}{'default'} = [1];
 369                 # Project specific override is not supported.
 370                 'forks' => {
 371                         'override' => 0,
 372                         'default' => [0]},
 373
 374                 # Insert custom links to the action bar of all project pages.
 375                 # This enables you mainly to link to third-party scripts integrating
 376                 # into gitweb; e.g. git-browser for graphical history representation
 377                 # or custom web-based repository administration interface.
 378
 379                 # The 'default' value consists of a list of triplets in the form
 380                 # (label, link, position) where position is the label after which
 381                 # to insert the link and link is a format string where %n expands
 382                 # to the project name, %f to the project path within the filesystem,
 383                 # %h to the current hash (h gitweb parameter) and %b to the current
 384                 # hash base (hb gitweb parameter); %% expands to %.
 385
 386                 # To enable system wide have in $GITWEB_CONFIG e.g.
 387                 # $feature{'actions'}{'default'} = [('graphiclog',
 388                 #       '/git-browser/by-commit.html?r=%n', 'summary')];
 389                 # Project specific override is not supported.
 390                 'actions' => {
 391                         'override' => 0,
 392                         'default' => []},
 393
 394                 # Allow gitweb scan project content tags described in ctags/
 395                 # of project repository, and display the popular Web 2.0-ish
 396                 # "tag cloud" near the project list. Note that this is something
 397                 # COMPLETELY different from the normal Git tags.
 398
 399                 # gitweb by itself can show existing tags, but it does not handle
 400                 # tagging itself; you need an external application for that.
 401                 # For an example script, check Girocco's cgi/tagproj.cgi.
 402                 # You may want to install the HTML::TagCloud Perl module to get
 403                 # a pretty tag cloud instead of just a list of tags.
 404
 405                 # To enable system wide have in $GITWEB_CONFIG
 406                 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
 407                 # Project specific override is not supported.
 408                 'ctags' => {
 409                         'override' => 0,
 410                         'default' => [0]},
 411
 412                 # The maximum number of patches in a patchset generated in patch
 413                 # view. Set this to 0 or undef to disable patch view, or to a
 414                 # negative number to remove any limit.
 415
 416                 # To disable system wide have in $GITWEB_CONFIG
 417                 # $feature{'patches'}{'default'} = [0];
 418                 # To have project specific config enable override in $GITWEB_CONFIG
 419                 # $feature{'patches'}{'override'} = 1;
 420                 # and in project config gitweb.patches = 0|n;
 421                 # where n is the maximum number of patches allowed in a patchset.
 422                 'patches' => {
 423                         'sub' => $feature_patches,
 424                         'override' => 0,
 425                         'default' => [16]},
 426         );
 427
 428         our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "gitweb_config.perl";
 429         if (-e $GITWEB_CONFIG) {
 430                 do $GITWEB_CONFIG;
 431         } else {
 432                 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "$FindBin::Bin/../gitweb.conf";
 433                 do $GITWEB_CONFIG_SYSTEM if -e $GITWEB_CONFIG_SYSTEM;
 434         }
 435
 436         # version of the core git binary
 437         our $git_version = qx("$GIT" --version) =~ m/git version (.*)$/ ? $1 : "unknown";
 438
 439         $projects_list ||= $projectroot;
 440
 441         # ======================================================================
 442         # input validation and dispatch
 443
 444         # input parameters can be collected from a variety of sources (presently, CGI
 445         # and PATH_INFO), so we define an %input_params hash that collects them all
 446         # together during validation: this allows subsequent uses (e.g. href()) to be
 447         # agnostic of the parameter origin
 448
 449         our %input_params = ();
 450
 451         # input parameters are stored with the long parameter name as key. This will
 452         # also be used in the href subroutine to convert parameters to their CGI
 453         # equivalent, and since the href() usage is the most frequent one, we store
 454         # the name -> CGI key mapping here, instead of the reverse.
 455         #
 456         # XXX: Warning: If you touch this, check the search form for updating,
 457         # too.
 458
 459         our @cgi_param_mapping = (
 460                 project => "p",
 461                 action => "a",
 462                 file_name => "f",
 463                 file_parent => "fp",
 464                 hash => "h",
 465                 hash_parent => "hp",
 466                 hash_base => "hb",
 467                 hash_parent_base => "hpb",
 468                 page => "pg",
 469                 order => "o",
 470                 searchtext => "s",
 471                 searchtype => "st",
 472                 snapshot_format => "sf",
 473                 extra_options => "opt",
 474                 search_use_regexp => "sr",
 475         );
 476         our %cgi_param_mapping = @cgi_param_mapping;
 477
 478         # we will also need to know the possible actions, for validation
 479         our %actions = (
 480                 "blame" => \&git_blame,
 481                 "blobdiff" => \&git_blobdiff,
 482                 "blobdiff_plain" => \&git_blobdiff_plain,
 483                 "blob" => \&git_blob,
 484                 "blob_plain" => \&git_blob_plain,
 485                 "commitdiff" => \&git_commitdiff,
 486                 "commitdiff_plain" => \&git_commitdiff_plain,
 487                 "commit" => \&git_commit,
 488                 "forks" => \&git_forks,
 489                 "heads" => \&git_heads,
 490                 "history" => \&git_history,
 491                 "log" => \&git_log,
 492                 "patch" => \&git_patch,
 493                 "patches" => \&git_patches,
 494                 "rss" => \&git_rss,
 495                 "atom" => \&git_atom,
 496                 "search" => \&git_search,
 497                 "search_help" => \&git_search_help,
 498                 "shortlog" => \&git_shortlog,
 499                 "summary" => \&git_summary,
 500                 "tag" => \&git_tag,
 501                 "tags" => \&git_tags,
 502                 "tree" => \&git_tree,
 503                 "snapshot" => \&git_snapshot,
 504                 "object" => \&git_object,
 505                 # those below don't need $project
 506                 "opml" => \&git_opml,
 507                 "project_list" => \&git_project_list,
 508                 "project_index" => \&git_project_index,
 509         );
 510
 511         # finally, we have the hash of allowed extra_options for the commands that
 512         # allow them
 513         our %allowed_options = (
 514                 "--no-merges" => [ qw(rss atom log shortlog history) ],
 515         );
 516
 517         # fill %input_params with the CGI parameters. All values except for 'opt'
 518         # should be single values, but opt can be an array. We should probably
 519         # build an array of parameters that can be multi-valued, but since for the time
 520         # being it's only this one, we just single it out
 521         while (my ($name, $symbol) = each %cgi_param_mapping) {
 522                 if ($symbol eq 'opt') {
 523                         $input_params{$name} = [ $c->req->param($symbol) ];
 524                 } else {
 525                         $input_params{$name} = $c->req->param($symbol);
 526                 }
 527         }
 528
 529         # now read PATH_INFO and update the parameter list for missing parameters
 530         my $evaluate_path_info = sub {
 531                 return if defined $input_params{'project'};
 532                 return if !$path_info;
 533                 $path_info =~ s,^/+,,;
 534                 return if !$path_info;
 535
 536                 # find which part of PATH_INFO is project
 537                 my $project = $path_info;
 538                 $project =~ s,/+$,,;
 539                 while ($project && !check_head_link("$projectroot/$project")) {
 540                         $project =~ s,/*[^/]*$,,;
 541                 }
 542                 return unless $project;
 543                 $input_params{'project'} = $project;
 544
 545                 # do not change any parameters if an action is given using the query string
 546                 return if $input_params{'action'};
 547                 $path_info =~ s,^\Q$project\E/*,,;
 548
 549                 # next, check if we have an action
 550                 my $action = $path_info;
 551                 $action =~ s,/.*$,,;
 552                 if (exists $actions{$action}) {
 553                         $path_info =~ s,^$action/*,,;
 554                         $input_params{'action'} = $action;
 555                 }
 556
 557                 # list of actions that want hash_base instead of hash, but can have no
 558                 # pathname (f) parameter
 559                 my @wants_base = (
 560                         'tree',
 561                         'history',
 562                 );
 563
 564                 # we want to catch
 565                 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
 566                 my ($parentrefname, $parentpathname, $refname, $pathname) =
 567                         ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?(.+?)(?::(.+))?$/);
 568
 569                 # first, analyze the 'current' part
 570                 if (defined $pathname) {
 571                         # we got "branch:filename" or "branch:dir/"
 572                         # we could use git_get_type(branch:pathname), but:
 573                         # - it needs $git_dir
 574                         # - it does a git() call
 575                         # - the convention of terminating directories with a slash
 576                         #   makes it superfluous
 577                         # - embedding the action in the PATH_INFO would make it even
 578                         #   more superfluous
 579                         $pathname =~ s,^/+,,;
 580                         if (!$pathname || substr($pathname, -1) eq "/") {
 581                                 $input_params{'action'} ||= "tree";
 582                                 $pathname =~ s,/$,,;
 583                         } else {
 584                                 # the default action depends on whether we had parent info
 585                                 # or not
 586                                 if ($parentrefname) {
 587                                         $input_params{'action'} ||= "blobdiff_plain";
 588                                 } else {
 589                                         $input_params{'action'} ||= "blob_plain";
 590                                 }
 591                         }
 592                         $input_params{'hash_base'} ||= $refname;
 593                         $input_params{'file_name'} ||= $pathname;
 594                 } elsif (defined $refname) {
 595                         # we got "branch". In this case we have to choose if we have to
 596                         # set hash or hash_base.
 597                         #
 598                         # Most of the actions without a pathname only want hash to be
 599                         # set, except for the ones specified in @wants_base that want
 600                         # hash_base instead. It should also be noted that hand-crafted
 601                         # links having 'history' as an action and no pathname or hash
 602                         # set will fail, but that happens regardless of PATH_INFO.
 603                         $input_params{'action'} ||= "shortlog";
 604                         if (grep { $_ eq $input_params{'action'} } @wants_base) {
 605                                 $input_params{'hash_base'} ||= $refname;
 606                         } else {
 607                                 $input_params{'hash'} ||= $refname;
 608                         }
 609                 }
 610
 611                 # next, handle the 'parent' part, if present
 612                 if (defined $parentrefname) {
 613                         # a missing pathspec defaults to the 'current' filename, allowing e.g.
 614                         # someproject/blobdiff/oldrev..newrev:/filename
 615                         if ($parentpathname) {
 616                                 $parentpathname =~ s,^/+,,;
 617                                 $parentpathname =~ s,/$,,;
 618                                 $input_params{'file_parent'} ||= $parentpathname;
 619                         } else {
 620                                 $input_params{'file_parent'} ||= $input_params{'file_name'};
 621                         }
 622                         # we assume that hash_parent_base is wanted if a path was specified,
 623                         # or if the action wants hash_base instead of hash
 624                         if (defined $input_params{'file_parent'} ||
 625                                 grep { $_ eq $input_params{'action'} } @wants_base) {
 626                                 $input_params{'hash_parent_base'} ||= $parentrefname;
 627                         } else {
 628                                 $input_params{'hash_parent'} ||= $parentrefname;
 629                         }
 630                 }
 631
 632                 # for the snapshot action, we allow URLs in the form
 633                 # $project/snapshot/$hash.ext
 634                 # where .ext determines the snapshot and gets removed from the
 635                 # passed $refname to provide the $hash.
 636                 #
 637                 # To be able to tell that $refname includes the format extension, we
 638                 # require the following two conditions to be satisfied:
 639                 # - the hash input parameter MUST have been set from the $refname part
 640                 #   of the URL (i.e. they must be equal)
 641                 # - the snapshot format MUST NOT have been defined already (e.g. from
 642                 #   CGI parameter sf)
 643                 # It's also useless to try any matching unless $refname has a dot,
 644                 # so we check for that too
 645                 if (defined $input_params{'action'} &&
 646                         $input_params{'action'} eq 'snapshot' &&
 647                         defined $refname && index($refname, '.') != -1 &&
 648                         $refname eq $input_params{'hash'} &&
 649                         !defined $input_params{'snapshot_format'}) {
 650                         # We loop over the known snapshot formats, checking for
 651                         # extensions. Allowed extensions are both the defined suffix
 652                         # (which includes the initial dot already) and the snapshot
 653                         # format key itself, with a prepended dot
 654                         while (my ($fmt, $opt) = each %known_snapshot_formats) {
 655                                 my $hash = $refname;
 656                                 my $sfx;
 657                                 $hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//;
 658                                 next unless $sfx = $1;
 659                                 # a valid suffix was found, so set the snapshot format
 660                                 # and reset the hash parameter
 661                                 $input_params{'snapshot_format'} = $fmt;
 662                                 $input_params{'hash'} = $hash;
 663                                 # we also set the format suffix to the one requested
 664                                 # in the URL: this way a request for e.g. .tgz returns
 665                                 # a .tgz instead of a .tar.gz
 666                                 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
 667                                 last;
 668                         }
 669                 }
 670         };
 671
 672         &$evaluate_path_info();
 673
 674         gitweb_validate_setup();
 675
 676         return $actions{$action};
 677 }
 678
 679 sub gitweb_validate_setup {
 680         our $action = $input_params{'action'};
 681         if (defined $action) {
 682                 if (!validate_action($action)) {
 683                         die_error(400, "Invalid action parameter");
 684                 }
 685         }
 686
 687         # parameters which are pathnames
 688         our $project = $input_params{'project'};
 689         if (defined $project) {
 690                 if (!validate_project($project)) {
 691                         undef $project;
 692                         die_error(404, "No such project");
 693                 }
 694         }
 695
 696         our $file_name = $input_params{'file_name'};
 697         if (defined $file_name) {
 698                 if (!validate_pathname($file_name)) {
 699                         die_error(400, "Invalid file parameter");
 700                 }
 701         }
 702
 703         our $file_parent = $input_params{'file_parent'};
 704         if (defined $file_parent) {
 705                 if (!validate_pathname($file_parent)) {
 706                         die_error(400, "Invalid file parent parameter");
 707                 }
 708         }
 709
 710         # parameters which are refnames
 711         our $hash = $input_params{'hash'};
 712         if (defined $hash) {
 713                 if (!validate_refname($hash)) {
 714                         die_error(400, "Invalid hash parameter");
 715                 }
 716         }
 717
 718         our $hash_parent = $input_params{'hash_parent'};
 719         if (defined $hash_parent) {
 720                 if (!validate_refname($hash_parent)) {
 721                         die_error(400, "Invalid hash parent parameter");
 722                 }
 723         }
 724
 725         our $hash_base = $input_params{'hash_base'};
 726         if (defined $hash_base) {
 727                 if (!validate_refname($hash_base)) {
 728                         die_error(400, "Invalid hash base parameter");
 729                 }
 730         }
 731
 732         our @extra_options = @{$input_params{'extra_options'}};
 733         # @extra_options is always defined, since it can only be (currently) set from
 734         # CGI, and $c->req->param() returns the empty array in array context if the param
 735         # is not set
 736         foreach my $opt (@extra_options) {
 737                 if (not exists $allowed_options{$opt}) {
 738                         die_error(400, "Invalid option parameter");
 739                 }
 740                 if (not grep(/^$action$/, @{$allowed_options{$opt}})) {
 741                         die_error(400, "Invalid option parameter for this action");
 742                 }
 743         }
 744
 745         our $hash_parent_base = $input_params{'hash_parent_base'};
 746         if (defined $hash_parent_base) {
 747                 if (!validate_refname($hash_parent_base)) {
 748                         die_error(400, "Invalid hash parent base parameter");
 749                 }
 750         }
 751
 752         # other parameters
 753         our $page = $input_params{'page'};
 754         if (defined $page) {
 755                 if ($page =~ m/[^0-9]/) {
 756                         die_error(400, "Invalid page parameter");
 757                 }
 758         }
 759
 760         our $searchtype = $input_params{'searchtype'};
 761         if (defined $searchtype) {
 762                 if ($searchtype =~ m/[^a-z]/) {
 763                         die_error(400, "Invalid searchtype parameter");
 764                 }
 765         }
 766
 767         our $search_use_regexp = $input_params{'search_use_regexp'};
 768
 769         our $searchtext = $input_params{'searchtext'};
 770         our $search_regexp;
 771         if (defined $searchtext) {
 772                 if (length($searchtext) < 2) {
 773                         die_error(403, "At least two characters are required for search parameter");
 774                 }
 775                 $search_regexp = $search_use_regexp ? $searchtext : quotemeta $searchtext;
 776         }
 777
 778         # path to the current git repository
 779         our $git_dir;
 780         $git_dir = "$projectroot/$project" if $project;
 781
 782         # process alternate names for backward compatibility
 783         # filter out unsupported (unknown) snapshot formats
 784         my $filter_snapshot_fmts = sub {
 785                 my @fmts = @_;
 786
 787                 @fmts = map {
 788                         exists $known_snapshot_format_aliases{$_} ?
 789                                $known_snapshot_format_aliases{$_} : $_} @fmts;
 790                 @fmts = grep(exists $known_snapshot_formats{$_}, @fmts);
 791
 792         };
 793         # list of supported snapshot formats
 794         our @snapshot_fmts = gitweb_get_feature('snapshot');
 795         @snapshot_fmts = &$filter_snapshot_fmts(@snapshot_fmts);
 796
 797         # dispatch
 798         if (!defined $action) {
 799                 if (defined $hash) {
 800                         $action = git_get_type($hash);
 801                 } elsif (defined $hash_base && defined $file_name) {
 802                         $action = git_get_type("$hash_base:$file_name");
 803                 } elsif (defined $project) {
 804                         $action = 'summary';
 805                 } else {
 806                         $action = 'project_list';
 807                 }
 808         }
 809         if (!defined($actions{$action})) {
 810                 die_error(400, "Unknown action");
 811         }
 812         if ($action !~ m/^(opml|project_list|project_index)$/ &&
 813             !$project) {
 814                 die_error(400, "Project needed");
 815         }
 816 }
 817
 818 sub gitweb_get_feature {
 819         my ($name) = @_;
 820         return unless exists $feature{$name};
 821         my ($sub, $override, @defaults) = (
 822                 $feature{$name}{'sub'},
 823                 $feature{$name}{'override'},
 824                 @{$feature{$name}{'default'}});
 825         if (!$override) { return @defaults; }
 826         if (!defined $sub) {
 827                 warn "feature $name is not overrideable";
 828                 return @defaults;
 829         }
 830         return $sub->(@defaults);
 831 }
 832
 833 # A wrapper to check if a given feature is enabled.
 834 # With this, you can say
 835 #
 836 #   my $bool_feat = gitweb_check_feature('bool_feat');
 837 #   gitweb_check_feature('bool_feat') or somecode;
 838 #
 839 # instead of
 840 #
 841 #   my ($bool_feat) = gitweb_get_feature('bool_feat');
 842 #   (gitweb_get_feature('bool_feat'))[0] or somecode;
 843 #
 844 sub gitweb_check_feature {
 845         return (gitweb_get_feature(@_))[0];
 846 }
 847
 848 # checking HEAD file with -e is fragile if the repository was
 849 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
 850 # and then pruned.
 851 sub check_head_link {
 852         my ($dir) = @_;
 853         my $headfile = "$dir/HEAD";
 854         return ((-e $headfile) ||
 855                 (-l $headfile && readlink($headfile) =~ /^refs\/heads\//));
 856 }
 857
 858 sub check_export_ok {
 859         my ($dir) = @_;
 860         return (check_head_link($dir) &&
 861                 (!$export_ok || -e "$dir/$export_ok") &&
 862                 (!$export_auth_hook || $export_auth_hook->($dir)));
 863 }
 864
 865
 866 ## ======================================================================
 867 ## action links
 868
 869 sub href (%) {
 870         my %params = @_;
 871         # default is to use -absolute url() i.e. $my_uri
 872         my $href = $params{-full} ? $my_url : $my_uri;
 873
 874         $params{'project'} = $project unless exists $params{'project'};
 875
 876         if ($params{-replay}) {
 877                 while (my ($name, $symbol) = each %cgi_param_mapping) {
 878                         if (!exists $params{$name}) {
 879                                 $params{$name} = $input_params{$name};
 880                         }
 881                 }
 882         }
 883
 884         my $use_pathinfo = gitweb_check_feature('pathinfo');
 885         if ($use_pathinfo and defined $params{'project'}) {
 886                 # try to put as many parameters as possible in PATH_INFO:
 887                 #   - project name
 888                 #   - action
 889                 #   - hash_parent or hash_parent_base:/file_parent
 890                 #   - hash or hash_base:/filename
 891                 #   - the snapshot_format as an appropriate suffix
 892
 893                 # When the script is the root DirectoryIndex for the domain,
 894                 # $href here would be something like http://gitweb.example.com/
 895                 # Thus, we strip any trailing / from $href, to spare us double
 896                 # slashes in the final URL
 897                 $href =~ s,/$,,;
 898
 899                 # Then add the project name, if present
 900                 $href .= "/".esc_url($params{'project'});
 901                 delete $params{'project'};
 902
 903                 # since we destructively absorb parameters, we keep this
 904                 # boolean that remembers if we're handling a snapshot
 905                 my $is_snapshot = $params{'action'} eq 'snapshot';
 906
 907                 # Summary just uses the project path URL, any other action is
 908                 # added to the URL
 909                 if (defined $params{'action'}) {
 910                         $href .= "/".esc_url($params{'action'}) unless $params{'action'} eq 'summary';
 911                         delete $params{'action'};
 912                 }
 913
 914                 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
 915                 # stripping nonexistent or useless pieces
 916                 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
 917                         || $params{'hash_parent'} || $params{'hash'});
 918                 if (defined $params{'hash_base'}) {
 919                         if (defined $params{'hash_parent_base'}) {
 920                                 $href .= esc_url($params{'hash_parent_base'});
 921                                 # skip the file_parent if it's the same as the file_name
 922                                 delete $params{'file_parent'} if $params{'file_parent'} eq $params{'file_name'};
 923                                 if (defined $params{'file_parent'} && $params{'file_parent'} !~ /\.\./) {
 924                                         $href .= ":/".esc_url($params{'file_parent'});
 925                                         delete $params{'file_parent'};
 926                                 }
 927                                 $href .= "..";
 928                                 delete $params{'hash_parent'};
 929                                 delete $params{'hash_parent_base'};
 930                         } elsif (defined $params{'hash_parent'}) {
 931                                 $href .= esc_url($params{'hash_parent'}). "..";
 932                                 delete $params{'hash_parent'};
 933                         }
 934
 935                         $href .= esc_url($params{'hash_base'});
 936                         if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
 937                                 $href .= ":/".esc_url($params{'file_name'});
 938                                 delete $params{'file_name'};
 939                         }
 940                         delete $params{'hash'};
 941                         delete $params{'hash_base'};
 942                 } elsif (defined $params{'hash'}) {
 943                         $href .= esc_url($params{'hash'});
 944                         delete $params{'hash'};
 945                 }
 946
 947                 # If the action was a snapshot, we can absorb the
 948                 # snapshot_format parameter too
 949                 if ($is_snapshot) {
 950                         my $fmt = $params{'snapshot_format'};
 951                         # snapshot_format should always be defined when href()
 952                         # is called, but just in case some code forgets, we
 953                         # fall back to the default
 954                         $fmt ||= $snapshot_fmts[0];
 955                         $href .= $known_snapshot_formats{$fmt}{'suffix'};
 956                         delete $params{'snapshot_format'};
 957                 }
 958         }
 959
 960         # now encode the parameters explicitly
 961         my @result = ();
 962         for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
 963                 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
 964                 if (defined $params{$name}) {
 965                         if (ref($params{$name}) eq "ARRAY") {
 966                                 foreach my $par (@{$params{$name}}) {
 967                                         push @result, $symbol . "=" . esc_param($par);
 968                                 }
 969                         } else {
 970                                 push @result, $symbol . "=" . esc_param($params{$name});
 971                         }
 972                 }
 973         }
 974         $href .= "?" . join(';', @result) if scalar @result;
 975
 976         return $href;
 977 }
 978
 979
 980 ## ======================================================================
 981 ## validation, quoting/unquoting and escaping
 982
 983 sub validate_action {
 984         my $input = shift || return undef;
 985         return undef unless exists $actions{$input};
 986         return $input;
 987 }
 988
 989 sub validate_project {
 990         my $input = shift || return undef;
 991         if (!validate_pathname($input) ||
 992                 !(-d "$projectroot/$input") ||
 993                 !check_export_ok("$projectroot/$input") ||
 994                 ($strict_export && !project_in_list($input))) {
 995                 return undef;
 996         } else {
 997                 return $input;
 998         }
 999 }
1000
1001 sub validate_pathname {
1002         my $input = shift || return undef;
1003
1004         # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1005         # at the beginning, at the end, and between slashes.
1006         # also this catches doubled slashes
1007         if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1008                 return undef;
1009         }
1010         # no null characters
1011         if ($input =~ m!\0!) {
1012                 return undef;
1013         }
1014         return $input;
1015 }
1016
1017 sub validate_refname {
1018         my $input = shift || return undef;
1019
1020         # textual hashes are O.K.
1021         if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1022                 return $input;
1023         }
1024         # it must be correct pathname
1025         $input = validate_pathname($input)
1026                 or return undef;
1027         # restrictions on ref name according to git-check-ref-format
1028         if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1029                 return undef;
1030         }
1031         return $input;
1032 }
1033
1034 # decode sequences of octets in utf8 into Perl's internal form,
1035 # which is utf-8 with utf8 flag set if needed.  gitweb writes out
1036 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1037 sub to_utf8 {
1038         my $str = shift;
1039         if (utf8::valid($str)) {
1040                 utf8::decode($str);
1041                 return $str;
1042         } else {
1043                 return decode($fallback_encoding, $str, Encode::FB_DEFAULT);
1044         }
1045 }
1046
1047 # quote unsafe chars, but keep the slash, even when it's not
1048 # correct, but quoted slashes look too horrible in bookmarks
1049 sub esc_param {
1050         my $str = shift;
1051         $str =~ s/([^A-Za-z0-9\-_.~()\/:@])/sprintf("%%%02X", ord($1))/eg;
1052         $str =~ s/\+/%2B/g;
1053         $str =~ s/ /\+/g;
1054         return $str;
1055 }
1056
1057 # quote unsafe chars in whole URL, so some charactrs cannot be quoted
1058 sub esc_url {
1059         my $str = shift;
1060         $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&=])/sprintf("%%%02X", ord($1))/eg;
1061         $str =~ s/\+/%2B/g;
1062         $str =~ s/ /\+/g;
1063         return $str;
1064 }
1065
1066 # replace invalid utf8 character with SUBSTITUTION sequence
1067 sub esc_html ($;%) {
1068         my $str = shift;
1069         my %opts = @_;
1070
1071         $str = to_utf8($str);
1072         $str = $cgi->escapeHTML($str);
1073         if ($opts{'-nbsp'}) {
1074                 $str =~ s/ /&nbsp;/g;
1075         }
1076         $str =~ s|([[:cntrl:]])|(($1 ne "\t") ? quot_cec($1) : $1)|eg;
1077         return $str;
1078 }
1079
1080 # quote control characters and escape filename to HTML
1081 sub esc_path {
1082         my $str = shift;
1083         my %opts = @_;
1084
1085         $str = to_utf8($str);
1086         $str = $cgi->escapeHTML($str);
1087         if ($opts{'-nbsp'}) {
1088                 $str =~ s/ /&nbsp;/g;
1089         }
1090         $str =~ s|([[:cntrl:]])|quot_cec($1)|eg;
1091         return $str;
1092 }
1093
1094 # Make control characters "printable", using character escape codes (CEC)
1095 sub quot_cec {
1096         my $cntrl = shift;
1097         my %opts = @_;
1098         my %es = ( # character escape codes, aka escape sequences
1099                 "\t" => '\t',   # tab            (HT)
1100                 "\n" => '\n',   # line feed      (LF)
1101                 "\r" => '\r',   # carrige return (CR)
1102                 "\f" => '\f',   # form feed      (FF)
1103                 "\b" => '\b',   # backspace      (BS)
1104                 "\a" => '\a',   # alarm (bell)   (BEL)
1105                 "\e" => '\e',   # escape         (ESC)
1106                 "\013" => '\v', # vertical tab   (VT)
1107                 "\000" => '\0', # nul character  (NUL)
1108         );
1109         my $chr = ( (exists $es{$cntrl})
1110                     ? $es{$cntrl}
1111                     : sprintf('\%2x', ord($cntrl)) );
1112         if ($opts{-nohtml}) {
1113                 return $chr;
1114         } else {
1115                 return "<span class=\"cntrl\">$chr</span>";
1116         }
1117 }
1118
1119 # Alternatively use unicode control pictures codepoints,
1120 # Unicode "printable representation" (PR)
1121 sub quot_upr {
1122         my $cntrl = shift;
1123         my %opts = @_;
1124
1125         my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1126         if ($opts{-nohtml}) {
1127                 return $chr;
1128         } else {
1129                 return "<span class=\"cntrl\">$chr</span>";
1130         }
1131 }
1132
1133 # git may return quoted and escaped filenames
1134 sub unquote {
1135         my $str = shift;
1136
1137         sub unq {
1138                 my $seq = shift;
1139                 my %es = ( # character escape codes, aka escape sequences
1140                         't' => "\t",   # tab            (HT, TAB)
1141                         'n' => "\n",   # newline        (NL)
1142                         'r' => "\r",   # return         (CR)
1143                         'f' => "\f",   # form feed      (FF)
1144                         'b' => "\b",   # backspace      (BS)
1145                         'a' => "\a",   # alarm (bell)   (BEL)
1146                         'e' => "\e",   # escape         (ESC)
1147                         'v' => "\013", # vertical tab   (VT)
1148                 );
1149
1150                 if ($seq =~ m/^[0-7]{1,3}$/) {
1151                         # octal char sequence
1152                         return chr(oct($seq));
1153                 } elsif (exists $es{$seq}) {
1154                         # C escape sequence, aka character escape code
1155                         return $es{$seq};
1156                 }
1157                 # quoted ordinary character
1158                 return $seq;
1159         }
1160
1161         if ($str =~ m/^"(.*)"$/) {
1162                 # needs unquoting
1163                 $str = $1;
1164                 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1165         }
1166         return $str;
1167 }
1168
1169 # escape tabs (convert tabs to spaces)
1170 sub untabify {
1171         my $line = shift;
1172
1173         while ((my $pos = index($line, "\t")) != -1) {
1174                 if (my $count = (8 - ($pos % 8))) {
1175                         my $spaces = ' ' x $count;
1176                         $line =~ s/\t/$spaces/;
1177                 }
1178         }
1179
1180         return $line;
1181 }
1182
1183 sub project_in_list {
1184         my $project = shift;
1185         my @list = git_get_projects_list();
1186         return @list && scalar(grep { $_->{'path'} eq $project } @list);
1187 }
1188
1189 ## ----------------------------------------------------------------------
1190 ## HTML aware string manipulation
1191
1192 # Try to chop given string on a word boundary between position
1193 # $len and $len+$add_len. If there is no word boundary there,
1194 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1195 # (marking chopped part) would be longer than given string.
1196 sub chop_str {
1197         my $str = shift;
1198         my $len = shift;
1199         my $add_len = shift || 10;
1200         my $where = shift || 'right'; # 'left' | 'center' | 'right'
1201
1202         # Make sure perl knows it is utf8 encoded so we don't
1203         # cut in the middle of a utf8 multibyte char.
1204         $str = to_utf8($str);
1205
1206         # allow only $len chars, but don't cut a word if it would fit in $add_len
1207         # if it doesn't fit, cut it if it's still longer than the dots we would add
1208         # remove chopped character entities entirely
1209
1210         # when chopping in the middle, distribute $len into left and right part
1211         # return early if chopping wouldn't make string shorter
1212         if ($where eq 'center') {
1213                 return $str if ($len + 5 >= length($str)); # filler is length 5
1214                 $len = int($len/2);
1215         } else {
1216                 return $str if ($len + 4 >= length($str)); # filler is length 4
1217         }
1218
1219         # regexps: ending and beginning with word part up to $add_len
1220         my $endre = qr/.{$len}\w{0,$add_len}/;
1221         my $begre = qr/\w{0,$add_len}.{$len}/;
1222
1223         if ($where eq 'left') {
1224                 $str =~ m/^(.*?)($begre)$/;
1225                 my ($lead, $body) = ($1, $2);
1226                 if (length($lead) > 4) {
1227                         $body =~ s/^[^;]*;// if ($lead =~ m/&[^;]*$/);
1228                         $lead = " ...";
1229                 }
1230                 return "$lead$body";
1231
1232         } elsif ($where eq 'center') {
1233                 $str =~ m/^($endre)(.*)$/;
1234                 my ($left, $str)  = ($1, $2);
1235                 $str =~ m/^(.*?)($begre)$/;
1236                 my ($mid, $right) = ($1, $2);
1237                 if (length($mid) > 5) {
1238                         $left  =~ s/&[^;]*$//;
1239                         $right =~ s/^[^;]*;// if ($mid =~ m/&[^;]*$/);
1240                         $mid = " ... ";
1241                 }
1242                 return "$left$mid$right";
1243
1244         } else {
1245                 $str =~ m/^($endre)(.*)$/;
1246                 my $body = $1;
1247                 my $tail = $2;
1248                 if (length($tail) > 4) {
1249                         $body =~ s/&[^;]*$//;
1250                         $tail = "... ";
1251                 }
1252                 return "$body$tail";
1253         }
1254 }
1255
1256 # takes the same arguments as chop_str, but also wraps a <span> around the
1257 # result with a title attribute if it does get chopped. Additionally, the
1258 # string is HTML-escaped.
1259 sub chop_and_escape_str {
1260         my ($str) = @_;
1261
1262         my $chopped = chop_str(@_);
1263         if ($chopped eq $str) {
1264                 return esc_html($chopped);
1265         } else {
1266                 $str =~ s/([[:cntrl:]])/?/g;
1267                 return $cgi->span({-title=>$str}, esc_html($chopped));
1268         }
1269 }
1270
1271 ## ----------------------------------------------------------------------
1272 ## functions returning short strings
1273
1274 # CSS class for given age value (in seconds)
1275 sub age_class {
1276         my $age = shift;
1277
1278         if (!defined $age) {
1279                 return "noage";
1280         } elsif ($age < 60*60*2) {
1281                 return "age0";
1282         } elsif ($age < 60*60*24*2) {
1283                 return "age1";
1284         } else {
1285                 return "age2";
1286         }
1287 }
1288
1289 # convert age in seconds to "nn units ago" string
1290 sub age_string {
1291         my $age = shift;
1292         my $age_str;
1293
1294         if ($age > 60*60*24*365*2) {
1295                 $age_str = (int $age/60/60/24/365);
1296                 $age_str .= " years ago";
1297         } elsif ($age > 60*60*24*(365/12)*2) {
1298                 $age_str = int $age/60/60/24/(365/12);
1299                 $age_str .= " months ago";
1300         } elsif ($age > 60*60*24*7*2) {
1301                 $age_str = int $age/60/60/24/7;
1302                 $age_str .= " weeks ago";
1303         } elsif ($age > 60*60*24*2) {
1304                 $age_str = int $age/60/60/24;
1305                 $age_str .= " days ago";
1306         } elsif ($age > 60*60*2) {
1307                 $age_str = int $age/60/60;
1308                 $age_str .= " hours ago";
1309         } elsif ($age > 60*2) {
1310                 $age_str = int $age/60;
1311                 $age_str .= " min ago";
1312         } elsif ($age > 2) {
1313                 $age_str = int $age;
1314                 $age_str .= " sec ago";
1315         } else {
1316                 $age_str .= " right now";
1317         }
1318         return $age_str;
1319 }
1320
1321 use constant {
1322         S_IFINVALID => 0030000,
1323         S_IFGITLINK => 0160000,
1324 };
1325
1326 # submodule/subproject, a commit object reference
1327 sub S_ISGITLINK($) {
1328         my $mode = shift;
1329
1330         return (($mode & S_IFMT) == S_IFGITLINK)
1331 }
1332
1333 # convert file mode in octal to symbolic file mode string
1334 sub mode_str {
1335         my $mode = oct shift;
1336
1337         if (S_ISGITLINK($mode)) {
1338                 return 'm---------';
1339         } elsif (S_ISDIR($mode & S_IFMT)) {
1340                 return 'drwxr-xr-x';
1341         } elsif (S_ISLNK($mode)) {
1342                 return 'lrwxrwxrwx';
1343         } elsif (S_ISREG($mode)) {
1344                 # git cares only about the executable bit
1345                 if ($mode & S_IXUSR) {
1346                         return '-rwxr-xr-x';
1347                 } else {
1348                         return '-rw-r--r--';
1349                 };
1350         } else {
1351                 return '----------';
1352         }
1353 }
1354
1355 # convert file mode in octal to file type string
1356 sub file_type {
1357         my $mode = shift;
1358
1359         if ($mode !~ m/^[0-7]+$/) {
1360                 return $mode;
1361         } else {
1362                 $mode = oct $mode;
1363         }
1364
1365         if (S_ISGITLINK($mode)) {
1366                 return "submodule";
1367         } elsif (S_ISDIR($mode & S_IFMT)) {
1368                 return "directory";
1369         } elsif (S_ISLNK($mode)) {
1370                 return "symlink";
1371         } elsif (S_ISREG($mode)) {
1372                 return "file";
1373         } else {
1374                 return "unknown";
1375         }
1376 }
1377
1378 # convert file mode in octal to file type description string
1379 sub file_type_long {
1380         my $mode = shift;
1381
1382         if ($mode !~ m/^[0-7]+$/) {
1383                 return $mode;
1384         } else {
1385                 $mode = oct $mode;
1386         }
1387
1388         if (S_ISGITLINK($mode)) {
1389                 return "submodule";
1390         } elsif (S_ISDIR($mode & S_IFMT)) {
1391                 return "directory";
1392         } elsif (S_ISLNK($mode)) {
1393                 return "symlink";
1394         } elsif (S_ISREG($mode)) {
1395                 if ($mode & S_IXUSR) {
1396                         return "executable";
1397                 } else {
1398                         return "file";
1399                 };
1400         } else {
1401                 return "unknown";
1402         }
1403 }
1404
1405
1406 ## ----------------------------------------------------------------------
1407 ## functions returning short HTML fragments, or transforming HTML fragments
1408 ## which don't belong to other sections
1409
1410 # format line of commit message.
1411 sub format_log_line_html {
1412         my $line = shift;
1413
1414         $line = esc_html($line, -nbsp=>1);
1415         $line =~ s{\b([0-9a-fA-F]{8,40})\b}{
1416                 $cgi->a({-href => href(action=>"object", hash=>$1),
1417                                         -class => "text"}, $1);
1418         }eg;
1419
1420         return $line;
1421 }
1422
1423 # format marker of refs pointing to given object
1424
1425 # the destination action is chosen based on object type and current context:
1426 # - for annotated tags, we choose the tag view unless it's the current view
1427 #   already, in which case we go to shortlog view
1428 # - for other refs, we keep the current view if we're in history, shortlog or
1429 #   log view, and select shortlog otherwise
1430 sub format_ref_marker {
1431         my ($refs, $id) = @_;
1432         my $markers = '';
1433
1434         if (defined $refs->{$id}) {
1435                 foreach my $ref (@{$refs->{$id}}) {
1436                         # this code exploits the fact that non-lightweight tags are the
1437                         # only indirect objects, and that they are the only objects for which
1438                         # we want to use tag instead of shortlog as action
1439                         my ($type, $name) = qw();
1440                         my $indirect = ($ref =~ s/\^\{\}$//);
1441                         # e.g. tags/v2.6.11 or heads/next
1442                         if ($ref =~ m!^(.*?)s?/(.*)$!) {
1443                                 $type = $1;
1444                                 $name = $2;
1445                         } else {
1446                                 $type = "ref";
1447                                 $name = $ref;
1448                         }
1449
1450                         my $class = $type;
1451                         $class .= " indirect" if $indirect;
1452
1453                         my $dest_action = "shortlog";
1454
1455                         if ($indirect) {
1456                                 $dest_action = "tag" unless $action eq "tag";
1457                         } elsif ($action =~ /^(history|(short)?log)$/) {
1458                                 $dest_action = $action;
1459                         }
1460
1461                         my $dest = "";
1462                         $dest .= "refs/" unless $ref =~ m!^refs/!;
1463                         $dest .= $ref;
1464
1465                         my $link = $cgi->a({
1466                                 -href => href(
1467                                         action=>$dest_action,
1468                                         hash=>$dest
1469                                 )}, $name);
1470
1471                         $markers .= " <span class=\"$class\" title=\"$ref\">" .
1472                                 $link . "</span>";
1473                 }
1474         }
1475
1476         if ($markers) {
1477                 return ' <span class="refs">'. $markers . '</span>';
1478         } else {
1479                 return "";
1480         }
1481 }
1482
1483 # format, perhaps shortened and with markers, title line
1484 sub format_subject_html {
1485         my ($long, $short, $href, $extra) = @_;
1486         $extra = '' unless defined($extra);
1487
1488         if (length($short) < length($long)) {
1489                 return $cgi->a({-href => $href, -class => "list subject",
1490                                 -title => to_utf8($long)},
1491                        esc_html($short) . $extra);
1492         } else {
1493                 return $cgi->a({-href => $href, -class => "list subject"},
1494                        esc_html($long)  . $extra);
1495         }
1496 }
1497
1498 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1499 sub format_git_diff_header_line {
1500         my $line = shift;
1501         my $diffinfo = shift;
1502         my ($from, $to) = @_;
1503
1504         if ($diffinfo->{'nparents'}) {
1505                 # combined diff
1506                 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1507                 if ($to->{'href'}) {
1508                         $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
1509                                          esc_path($to->{'file'}));
1510                 } else { # file was deleted (no href)
1511                         $line .= esc_path($to->{'file'});
1512                 }
1513         } else {
1514                 # "ordinary" diff
1515                 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1516                 if ($from->{'href'}) {
1517                         $line .= $cgi->a({-href => $from->{'href'}, -class => "path"},
1518                                          'a/' . esc_path($from->{'file'}));
1519                 } else { # file was added (no href)
1520                         $line .= 'a/' . esc_path($from->{'file'});
1521                 }
1522                 $line .= ' ';
1523                 if ($to->{'href'}) {
1524                         $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
1525                                          'b/' . esc_path($to->{'file'}));
1526                 } else { # file was deleted
1527                         $line .= 'b/' . esc_path($to->{'file'});
1528                 }
1529         }
1530
1531         return "<div class=\"diff header\">$line</div>\n";
1532 }
1533
1534 # format extended diff header line, before patch itself
1535 sub format_extended_diff_header_line {
1536         my $line = shift;
1537         my $diffinfo = shift;
1538         my ($from, $to) = @_;
1539
1540         # match <path>
1541         if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1542                 $line .= $cgi->a({-href=>$from->{'href'}, -class=>"path"},
1543                                        esc_path($from->{'file'}));
1544         }
1545         if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1546                 $line .= $cgi->a({-href=>$to->{'href'}, -class=>"path"},
1547                                  esc_path($to->{'file'}));
1548         }
1549         # match single <mode>
1550         if ($line =~ m/\s(\d{6})$/) {
1551                 $line .= '<span class="info"> (' .
1552                          file_type_long($1) .
1553                          ')</span>';
1554         }
1555         # match <hash>
1556         if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1557                 # can match only for combined diff
1558                 $line = 'index ';
1559                 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1560                         if ($from->{'href'}[$i]) {
1561                                 $line .= $cgi->a({-href=>$from->{'href'}[$i],
1562                                                   -class=>"hash"},
1563                                                  substr($diffinfo->{'from_id'}[$i],0,7));
1564                         } else {
1565                                 $line .= '0' x 7;
1566                         }
1567                         # separator
1568                         $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1569                 }
1570                 $line .= '..';
1571                 if ($to->{'href'}) {
1572                         $line .= $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
1573                                          substr($diffinfo->{'to_id'},0,7));
1574                 } else {
1575                         $line .= '0' x 7;
1576                 }
1577
1578         } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
1579                 # can match only for ordinary diff
1580                 my ($from_link, $to_link);
1581                 if ($from->{'href'}) {
1582                         $from_link = $cgi->a({-href=>$from->{'href'}, -class=>"hash"},
1583                                              substr($diffinfo->{'from_id'},0,7));
1584                 } else {
1585                         $from_link = '0' x 7;
1586                 }
1587                 if ($to->{'href'}) {
1588                         $to_link = $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
1589                                            substr($diffinfo->{'to_id'},0,7));
1590                 } else {
1591                         $to_link = '0' x 7;
1592                 }
1593                 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
1594                 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
1595         }
1596
1597         return $line . "<br/>\n";
1598 }
1599
1600 # format from-file/to-file diff header
1601 sub format_diff_from_to_header {
1602         my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
1603         my $line;
1604         my $result = '';
1605
1606         $line = $from_line;
1607         #assert($line =~ m/^---/) if DEBUG;
1608         # no extra formatting for "^--- /dev/null"
1609         if (! $diffinfo->{'nparents'}) {
1610                 # ordinary (single parent) diff
1611                 if ($line =~ m!^--- "?a/!) {
1612                         if ($from->{'href'}) {
1613                                 $line = '--- a/' .
1614                                         $cgi->a({-href=>$from->{'href'}, -class=>"path"},
1615                                                 esc_path($from->{'file'}));
1616                         } else {
1617                                 $line = '--- a/' .
1618                                         esc_path($from->{'file'});
1619                         }
1620                 }
1621                 $result .= qq!<div class="diff from_file">$line</div>\n!;
1622
1623         } else {
1624                 # combined diff (merge commit)
1625                 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1626                         if ($from->{'href'}[$i]) {
1627                                 $line = '--- ' .
1628                                         $cgi->a({-href=>href(action=>"blobdiff",
1629                                                              hash_parent=>$diffinfo->{'from_id'}[$i],
1630                                                              hash_parent_base=>$parents[$i],
1631                                                              file_parent=>$from->{'file'}[$i],
1632                                                              hash=>$diffinfo->{'to_id'},
1633                                                              hash_base=>$hash,
1634                                                              file_name=>$to->{'file'}),
1635                                                  -class=>"path",
1636                                                  -title=>"diff" . ($i+1)},
1637                                                 $i+1) .
1638                                         '/' .
1639                                         $cgi->a({-href=>$from->{'href'}[$i], -class=>"path"},
1640                                                 esc_path($from->{'file'}[$i]));
1641                         } else {
1642                                 $line = '--- /dev/null';
1643                         }
1644                         $result .= qq!<div class="diff from_file">$line</div>\n!;
1645                 }
1646         }
1647
1648         $line = $to_line;
1649         #assert($line =~ m/^\+\+\+/) if DEBUG;
1650         # no extra formatting for "^+++ /dev/null"
1651         if ($line =~ m!^\+\+\+ "?b/!) {
1652                 if ($to->{'href'}) {
1653                         $line = '+++ b/' .
1654                                 $cgi->a({-href=>$to->{'href'}, -class=>"path"},
1655                                         esc_path($to->{'file'}));
1656                 } else {
1657                         $line = '+++ b/' .
1658                                 esc_path($to->{'file'});
1659                 }
1660         }
1661         $result .= qq!<div class="diff to_file">$line</div>\n!;
1662
1663         return $result;
1664 }
1665
1666 # create note for patch simplified by combined diff
1667 sub format_diff_cc_simplified {
1668         my ($diffinfo, @parents) = @_;
1669         my $result = '';
1670
1671         $result .= "<div class=\"diff header\">" .
1672                    "diff --cc ";
1673         if (!is_deleted($diffinfo)) {
1674                 $result .= $cgi->a({-href => href(action=>"blob",
1675                                                   hash_base=>$hash,
1676                                                   hash=>$diffinfo->{'to_id'},
1677                                                   file_name=>$diffinfo->{'to_file'}),
1678                                     -class => "path"},
1679                                    esc_path($diffinfo->{'to_file'}));
1680         } else {
1681                 $result .= esc_path($diffinfo->{'to_file'});
1682         }
1683         $result .= "</div>\n" . # class="diff header"
1684                    "<div class=\"diff nodifferences\">" .
1685                    "Simple merge" .
1686                    "</div>\n"; # class="diff nodifferences"
1687
1688         return $result;
1689 }
1690
1691 # format patch (diff) line (not to be used for diff headers)
1692 sub format_diff_line {
1693         my $line = shift;
1694         my ($from, $to) = @_;
1695         my $diff_class = "";
1696
1697         chomp $line;
1698
1699         if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
1700                 # combined diff
1701                 my $prefix = substr($line, 0, scalar @{$from->{'href'}});
1702                 if ($line =~ m/^\@{3}/) {
1703                         $diff_class = " chunk_header";
1704                 } elsif ($line =~ m/^\\/) {
1705                         $diff_class = " incomplete";
1706                 } elsif ($prefix =~ tr/+/+/) {
1707                         $diff_class = " add";
1708                 } elsif ($prefix =~ tr/-/-/) {
1709                         $diff_class = " rem";
1710                 }
1711         } else {
1712                 # assume ordinary diff
1713                 my $char = substr($line, 0, 1);
1714                 if ($char eq '+') {
1715                         $diff_class = " add";
1716                 } elsif ($char eq '-') {
1717                         $diff_class = " rem";
1718                 } elsif ($char eq '@') {
1719                         $diff_class = " chunk_header";
1720                 } elsif ($char eq "\\") {
1721                         $diff_class = " incomplete";
1722                 }
1723         }
1724         $line = untabify($line);
1725         if ($from && $to && $line =~ m/^\@{2} /) {
1726                 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
1727                         $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
1728
1729                 $from_lines = 0 unless defined $from_lines;
1730                 $to_lines   = 0 unless defined $to_lines;
1731
1732                 if ($from->{'href'}) {
1733                         $from_text = $cgi->a({-href=>"$from->{'href'}#l$from_start",
1734                                              -class=>"list"}, $from_text);
1735                 }
1736                 if ($to->{'href'}) {
1737                         $to_text   = $cgi->a({-href=>"$to->{'href'}#l$to_start",
1738                                              -class=>"list"}, $to_text);
1739                 }
1740                 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
1741                         "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
1742                 return "<div class=\"diff$diff_class\">$line</div>\n";
1743         } elsif ($from && $to && $line =~ m/^\@{3}/) {
1744                 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
1745                 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
1746
1747                 @from_text = split(' ', $ranges);
1748                 for (my $i = 0; $i < @from_text; ++$i) {
1749                         ($from_start[$i], $from_nlines[$i]) =
1750                                 (split(',', substr($from_text[$i], 1)), 0);
1751                 }
1752
1753                 $to_text   = pop @from_text;
1754                 $to_start  = pop @from_start;
1755                 $to_nlines = pop @from_nlines;
1756
1757                 $line = "<span class=\"chunk_info\">$prefix ";
1758                 for (my $i = 0; $i < @from_text; ++$i) {
1759                         if ($from->{'href'}[$i]) {
1760                                 $line .= $cgi->a({-href=>"$from->{'href'}[$i]#l$from_start[$i]",
1761                                                   -class=>"list"}, $from_text[$i]);
1762                         } else {
1763                                 $line .= $from_text[$i];
1764                         }
1765                         $line .= " ";
1766                 }
1767                 if ($to->{'href'}) {
1768                         $line .= $cgi->a({-href=>"$to->{'href'}#l$to_start",
1769                                           -class=>"list"}, $to_text);
1770                 } else {
1771                         $line .= $to_text;
1772                 }
1773                 $line .= " $prefix</span>" .
1774                          "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
1775                 return "<div class=\"diff$diff_class\">$line</div>\n";
1776         }
1777         return "<div class=\"diff$diff_class\">" . esc_html($line, -nbsp=>1) . "</div>\n";
1778 }
1779
1780 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
1781 # linked.  Pass the hash of the tree/commit to snapshot.
1782 sub format_snapshot_links {
1783         my ($hash) = @_;
1784         my $num_fmts = @snapshot_fmts;
1785         if ($num_fmts > 1) {
1786                 # A parenthesized list of links bearing format names.
1787                 # e.g. "snapshot (_tar.gz_ _zip_)"
1788                 return "snapshot (" . join(' ', map
1789                         $cgi->a({
1790                                 -href => href(
1791                                         action=>"snapshot",
1792                                         hash=>$hash,
1793                                         snapshot_format=>$_
1794                                 )
1795                         }, $known_snapshot_formats{$_}{'display'})
1796                 , @snapshot_fmts) . ")";
1797         } elsif ($num_fmts == 1) {
1798                 # A single "snapshot" link whose tooltip bears the format name.
1799                 # i.e. "_snapshot_"
1800                 my ($fmt) = @snapshot_fmts;
1801                 return
1802                         $cgi->a({
1803                                 -href => href(
1804                                         action=>"snapshot",
1805                                         hash=>$hash,
1806                                         snapshot_format=>$fmt
1807                                 ),
1808                                 -title => "in format: $known_snapshot_formats{$fmt}{'display'}"
1809                         }, "snapshot");
1810         } else { # $num_fmts == 0
1811                 return undef;
1812         }
1813 }
1814
1815 ## ......................................................................
1816 ## functions returning values to be passed, perhaps after some
1817 ## transformation, to other functions; e.g. returning arguments to href()
1818
1819 # returns hash to be passed to href to generate gitweb URL
1820 # in -title key it returns description of link
1821 sub get_feed_info {
1822         my $format = shift || 'Atom';
1823         my %res = (action => lc($format));
1824
1825         # feed links are possible only for project views
1826         return unless (defined $project);
1827         # some views should link to OPML, or to generic project feed,
1828         # or don't have specific feed yet (so they should use generic)
1829         return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
1830
1831         my $branch;
1832         # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
1833         # from tag links; this also makes possible to detect branch links
1834         if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
1835             (defined $hash      && $hash      =~ m!^refs/heads/(.*)$!)) {
1836                 $branch = $1;
1837         }
1838         # find log type for feed description (title)
1839         my $type = 'log';
1840         if (defined $file_name) {
1841                 $type  = "history of $file_name";
1842                 $type .= "/" if ($action eq 'tree');
1843                 $type .= " on '$branch'" if (defined $branch);
1844         } else {
1845                 $type = "log of $branch" if (defined $branch);
1846         }
1847
1848         $res{-title} = $type;
1849         $res{'hash'} = (defined $branch ? "refs/heads/$branch" : undef);
1850         $res{'file_name'} = $file_name;
1851
1852         return %res;
1853 }
1854
1855 ## ----------------------------------------------------------------------
1856 ## git utility subroutines, invoking git commands
1857
1858 # returns path to the core git executable and the --git-dir parameter as list
1859 sub git_cmd {
1860         return $GIT, '--git-dir='.$git_dir;
1861 }
1862
1863 # quote the given arguments for passing them to the shell
1864 # quote_command("command", "arg 1", "arg with ' and ! characters")
1865 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
1866 # Try to avoid using this function wherever possible.
1867 sub quote_command {
1868         return join(' ',
1869                     map( { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ ));
1870 }
1871
1872 # get HEAD ref of given project as hash
1873 sub git_get_head_hash {
1874         my $project = shift;
1875         my $o_git_dir = $git_dir;
1876         my $retval = undef;
1877         $git_dir = "$projectroot/$project";
1878         if (open my $fd, "-|", git_cmd(), "rev-parse", "--verify", "HEAD") {
1879                 my $head = <$fd>;
1880                 close $fd;
1881                 if (defined $head && $head =~ /^([0-9a-fA-F]{40})$/) {
1882                         $retval = $1;
1883                 }
1884         }
1885         if (defined $o_git_dir) {
1886                 $git_dir = $o_git_dir;
1887         }
1888         return $retval;
1889 }
1890
1891 # get type of given object
1892 sub git_get_type {
1893         my $hash = shift;
1894
1895         open my $fd, "-|", git_cmd(), "cat-file", '-t', $hash or return;
1896         my $type = <$fd>;
1897         close $fd or return;
1898         chomp $type;
1899         return $type;
1900 }
1901
1902 # repository configuration
1903 our $config_file = '';
1904 our %config;
1905
1906 # store multiple values for single key as anonymous array reference
1907 # single values stored directly in the hash, not as [ <value> ]
1908 sub hash_set_multi {
1909         my ($hash, $key, $value) = @_;
1910
1911         if (!exists $hash->{$key}) {
1912                 $hash->{$key} = $value;
1913         } elsif (!ref $hash->{$key}) {
1914                 $hash->{$key} = [ $hash->{$key}, $value ];
1915         } else {
1916                 push @{$hash->{$key}}, $value;
1917         }
1918 }
1919
1920 # return hash of git project configuration
1921 # optionally limited to some section, e.g. 'gitweb'
1922 sub git_parse_project_config {
1923         my $section_regexp = shift;
1924         my %config;
1925
1926         local $/ = "\0";
1927
1928         open my $fh, "-|", git_cmd(), "config", '-z', '-l',
1929                 or return;
1930
1931         while (my $keyval = <$fh>) {
1932                 chomp $keyval;
1933                 my ($key, $value) = split(/\n/, $keyval, 2);
1934
1935                 hash_set_multi(\%config, $key, $value)
1936                         if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
1937         }
1938         close $fh;
1939
1940         return %config;
1941 }
1942
1943 # convert config value to boolean: 'true' or 'false'
1944 # no value, number > 0, 'true' and 'yes' values are true
1945 # rest of values are treated as false (never as error)
1946 sub config_to_bool {
1947         my $val = shift;
1948
1949         return 1 if !defined $val;             # section.key
1950
1951         # strip leading and trailing whitespace
1952         $val =~ s/^\s+//;
1953         $val =~ s/\s+$//;
1954
1955         return (($val =~ /^\d+$/ && $val) ||   # section.key = 1
1956                 ($val =~ /^(?:true|yes)$/i));  # section.key = true
1957 }
1958
1959 # convert config value to simple decimal number
1960 # an optional value suffix of 'k', 'm', or 'g' will cause the value
1961 # to be multiplied by 1024, 1048576, or 1073741824
1962 sub config_to_int {
1963         my $val = shift;
1964
1965         # strip leading and trailing whitespace
1966         $val =~ s/^\s+//;
1967         $val =~ s/\s+$//;
1968
1969         if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
1970                 $unit = lc($unit);
1971                 # unknown unit is treated as 1
1972                 return $num * ($unit eq 'g' ? 1073741824 :
1973                                $unit eq 'm' ?    1048576 :
1974                                $unit eq 'k' ?       1024 : 1);
1975         }
1976         return $val;
1977 }
1978
1979 # convert config value to array reference, if needed
1980 sub config_to_multi {
1981         my $val = shift;
1982
1983         return ref($val) ? $val : (defined($val) ? [ $val ] : []);
1984 }
1985
1986 sub git_get_project_config {
1987         my ($key, $type) = @_;
1988
1989         # key sanity check
1990         return unless ($key);
1991         $key =~ s/^gitweb\.//;
1992         return if ($key =~ m/\W/);
1993
1994         # type sanity check
1995         if (defined $type) {
1996                 $type =~ s/^--//;
1997                 $type = undef
1998                         unless ($type eq 'bool' || $type eq 'int');
1999         }
2000
2001         # get config
2002         if (!defined $config_file ||
2003             $config_file ne "$git_dir/config") {
2004                 %config = git_parse_project_config('gitweb');
2005                 $config_file = "$git_dir/config";
2006         }
2007
2008         # check if config variable (key) exists
2009         return unless exists $config{"gitweb.$key"};
2010
2011         # ensure given type
2012         if (!defined $type) {
2013                 return $config{"gitweb.$key"};
2014         } elsif ($type eq 'bool') {
2015                 # backward compatibility: 'git config --bool' returns true/false
2016                 return config_to_bool($config{"gitweb.$key"}) ? 'true' : 'false';
2017         } elsif ($type eq 'int') {
2018                 return config_to_int($config{"gitweb.$key"});
2019         }
2020         return $config{"gitweb.$key"};
2021 }
2022
2023 # get hash of given path at given ref
2024 sub git_get_hash_by_path {
2025         my $base = shift;
2026         my $path = shift || return undef;
2027         my $type = shift;
2028
2029         $path =~ s,/+$,,;
2030
2031         open my $fd, "-|", git_cmd(), "ls-tree", $base, "--", $path
2032                 or die_error(500, "Open git-ls-tree failed");
2033         my $line = <$fd>;
2034         close $fd or return undef;
2035
2036         if (!defined $line) {
2037                 # there is no tree or hash given by $path at $base
2038                 return undef;
2039         }
2040
2041         #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
2042         $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2043         if (defined $type && $type ne $2) {
2044                 # type doesn't match
2045                 return undef;
2046         }
2047         return $3;
2048 }
2049
2050 # get path of entry with given hash at given tree-ish (ref)
2051 # used to get 'from' filename for combined diff (merge commit) for renames
2052 sub git_get_path_by_hash {
2053         my $base = shift || return;
2054         my $hash = shift || return;
2055
2056         local $/ = "\0";
2057
2058         open my $fd, "-|", git_cmd(), "ls-tree", '-r', '-t', '-z', $base
2059                 or return undef;
2060         while (my $line = <$fd>) {
2061                 chomp $line;
2062
2063                 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423  gitweb'
2064                 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f  gitweb/README'
2065                 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2066                         close $fd;
2067                         return $1;
2068                 }
2069         }
2070         close $fd;
2071         return undef;
2072 }
2073
2074 ## ......................................................................
2075 ## git utility functions, directly accessing git repository
2076
2077 sub git_get_project_description {
2078         my $path = shift;
2079
2080         $git_dir = "$projectroot/$path";
2081         open my $fd, "$git_dir/description"
2082                 or return git_get_project_config('description');
2083         my $descr = <$fd>;
2084         close $fd;
2085         if (defined $descr) {
2086                 chomp $descr;
2087         }
2088         return $descr;
2089 }
2090
2091 sub git_get_project_ctags {
2092         my $path = shift;
2093         my $ctags = {};
2094
2095         $git_dir = "$projectroot/$path";
2096         unless (opendir D, "$git_dir/ctags") {
2097                 return $ctags;
2098         }
2099         foreach (grep { -f $_ } map { "$git_dir/ctags/$_" } readdir(D)) {
2100                 open CT, $_ or next;
2101                 my $val = <CT>;
2102                 chomp $val;
2103                 close CT;
2104                 my $ctag = $_; $ctag =~ s#.*/##;
2105                 $ctags->{$ctag} = $val;
2106         }
2107         closedir D;
2108         $ctags;
2109 }
2110
2111 sub git_populate_project_tagcloud {
2112         my $ctags = shift;
2113
2114         # First, merge different-cased tags; tags vote on casing
2115         my %ctags_lc;
2116         foreach (keys %$ctags) {
2117                 $ctags_lc{lc $_}->{count} += $ctags->{$_};
2118                 if (not $ctags_lc{lc $_}->{topcount}
2119                     or $ctags_lc{lc $_}->{topcount} < $ctags->{$_}) {
2120                         $ctags_lc{lc $_}->{topcount} = $ctags->{$_};
2121                         $ctags_lc{lc $_}->{topname} = $_;
2122                 }
2123         }
2124
2125         my $cloud;
2126         if (eval { require HTML::TagCloud; 1; }) {
2127                 $cloud = HTML::TagCloud->new;
2128                 foreach (sort keys %ctags_lc) {
2129                         # Pad the title with spaces so that the cloud looks
2130                         # less crammed.
2131                         my $title = $ctags_lc{$_}->{topname};
2132                         $title =~ s/ /&nbsp;/g;
2133                         $title =~ s/^/&nbsp;/g;
2134                         $title =~ s/$/&nbsp;/g;
2135                         $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count});
2136                 }
2137         } else {
2138                 $cloud = \%ctags_lc;
2139         }
2140         $cloud;
2141 }
2142
2143 sub git_show_project_tagcloud {
2144         my ($cloud, $count) = @_;
2145         #print STDERR ref($cloud)."..\n";
2146         if (ref $cloud eq 'HTML::TagCloud') {
2147                 return $cloud->html_and_css($count);
2148         } else {
2149                 my @tags = sort { $cloud->{$a}->{count} <=> $cloud->{$b}->{count} } keys %$cloud;
2150                 return '<p align="center">' . join (', ', map {
2151                         "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
2152                 } splice(@tags, 0, $count)) . '</p>';
2153         }
2154 }
2155
2156 sub git_get_project_url_list {
2157         my $path = shift;
2158
2159         $git_dir = "$projectroot/$path";
2160         open my $fd, "$git_dir/cloneurl"
2161                 or return wantarray ?
2162                 @{ config_to_multi(git_get_project_config('url')) } :
2163                    config_to_multi(git_get_project_config('url'));
2164         my @git_project_url_list = map { chomp; $_ } <$fd>;
2165         close $fd;
2166
2167         return wantarray ? @git_project_url_list : \@git_project_url_list;
2168 }
2169
2170 sub git_get_projects_list {
2171         my ($filter) = @_;
2172         my @list;
2173
2174         $filter ||= '';
2175         $filter =~ s/\.git$//;
2176
2177         my $check_forks = gitweb_check_feature('forks');
2178
2179         if (-d $projects_list) {
2180                 # search in directory
2181                 my $dir = $projects_list . ($filter ? "/$filter" : '');
2182                 # remove the trailing "/"
2183                 $dir =~ s!/+$!!;
2184                 my $pfxlen = length("$dir");
2185                 my $pfxdepth = ($dir =~ tr!/!!);
2186
2187                 File::Find::find({
2188                         follow_fast => 1, # follow symbolic links
2189                         follow_skip => 2, # ignore duplicates
2190                         dangling_symlinks => 0, # ignore dangling symlinks, silently
2191                         wanted => sub {
2192                                 # skip project-list toplevel, if we get it.
2193                                 return if (m!^[/.]$!);
2194                                 # only directories can be git repositories
2195                                 return unless (-d $_);
2196                                 # don't traverse too deep (Find is super slow on os x)
2197                                 if (($File::Find::name =~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2198                                         $File::Find::prune = 1;
2199                                         return;
2200                                 }
2201
2202                                 my $subdir = substr($File::Find::name, $pfxlen + 1);
2203                                 # we check related file in $projectroot
2204                                 my $path = ($filter ? "$filter/" : '') . $subdir;
2205                                 if (check_export_ok("$projectroot/$path")) {
2206                                         push @list, { path => $path };
2207                                         $File::Find::prune = 1;
2208                                 }
2209                         },
2210                 }, "$dir");
2211
2212         } elsif (-f $projects_list) {
2213                 # read from file(url-encoded):
2214                 # 'git%2Fgit.git Linus+Torvalds'
2215                 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2216                 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2217                 my %paths;
2218                 open my ($fd), $projects_list or return;
2219         PROJECT:
2220                 while (my $line = <$fd>) {
2221                         chomp $line;
2222                         my ($path, $owner) = split ' ', $line;
2223                         $path = unescape($path);
2224                         $owner = unescape($owner);
2225                         if (!defined $path) {
2226                                 next;
2227                         }
2228                         if ($filter ne '') {
2229                                 # looking for forks;
2230                                 my $pfx = substr($path, 0, length($filter));
2231                                 if ($pfx ne $filter) {
2232                                         next PROJECT;
2233                                 }
2234                                 my $sfx = substr($path, length($filter));
2235                                 if ($sfx !~ /^\/.*\.git$/) {
2236                                         next PROJECT;
2237                                 }
2238                         } elsif ($check_forks) {
2239                         PATH:
2240                                 foreach my $filter (keys %paths) {
2241                                         # looking for forks;
2242                                         my $pfx = substr($path, 0, length($filter));
2243                                         if ($pfx ne $filter) {
2244                                                 next PATH;
2245                                         }
2246                                         my $sfx = substr($path, length($filter));
2247                                         if ($sfx !~ /^\/.*\.git$/) {
2248                                                 next PATH;
2249                                         }
2250                                         # is a fork, don't include it in
2251                                         # the list
2252                                         next PROJECT;
2253                                 }
2254                         }
2255                         if (check_export_ok("$projectroot/$path")) {
2256                                 my $pr = {
2257                                         path => $path,
2258                                         owner => to_utf8($owner),
2259                                 };
2260                                 push @list, $pr;
2261                                 (my $forks_path = $path) =~ s/\.git$//;
2262                                 $paths{$forks_path}++;
2263                         }
2264                 }
2265                 close $fd;
2266         }
2267         return @list;
2268 }
2269
2270 our $gitweb_project_owner = undef;
2271 sub git_get_project_list_from_file {
2272
2273         return if (defined $gitweb_project_owner);
2274
2275         $gitweb_project_owner = {};
2276         # read from file (url-encoded):
2277         # 'git%2Fgit.git Linus+Torvalds'
2278         # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2279         # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2280         if (-f $projects_list) {
2281                 open (my $fd , $projects_list);
2282                 while (my $line = <$fd>) {
2283                         chomp $line;
2284                         my ($pr, $ow) = split ' ', $line;
2285                         $pr = unescape($pr);
2286                         $ow = unescape($ow);
2287                         $gitweb_project_owner->{$pr} = to_utf8($ow);
2288                 }
2289                 close $fd;
2290         }
2291 }
2292
2293 sub git_get_project_owner {
2294         my $project = shift;
2295         my $owner;
2296
2297         return undef unless $project;
2298         $git_dir = "$projectroot/$project";
2299
2300         if (!defined $gitweb_project_owner) {
2301                 git_get_project_list_from_file();
2302         }
2303
2304         if (exists $gitweb_project_owner->{$project}) {
2305                 $owner = $gitweb_project_owner->{$project};
2306         }
2307         if (!defined $owner){
2308                 $owner = git_get_project_config('owner');
2309         }
2310         if (!defined $owner) {
2311                 $owner = get_file_owner("$git_dir");
2312         }
2313
2314         return $owner;
2315 }
2316
2317 sub git_get_last_activity {
2318         my ($path) = @_;
2319         my $fd;
2320
2321         $git_dir = "$projectroot/$path";
2322         open($fd, "-|", git_cmd(), 'for-each-ref',
2323              '--format=%(committer)',
2324              '--sort=-committerdate',
2325              '--count=1',
2326              'refs/heads') or return;
2327         my $most_recent = <$fd>;
2328         close $fd or return;
2329         if (defined $most_recent &&
2330             $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2331                 my $timestamp = $1;
2332                 my $age = time - $timestamp;
2333                 return ($age, age_string($age));
2334         }
2335         return (undef, undef);
2336 }
2337
2338 sub git_get_references {
2339         my $type = shift || "";
2340         my %refs;
2341         # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2342         # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2343         open my $fd, "-|", git_cmd(), "show-ref", "--dereference",
2344                 ($type ? ("--", "refs/$type") : ()) # use -- <pattern> if $type
2345                 or return;
2346
2347         while (my $line = <$fd>) {
2348                 chomp $line;
2349                 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2350                         if (defined $refs{$1}) {
2351                                 push @{$refs{$1}}, $2;
2352                         } else {
2353                                 $refs{$1} = [ $2 ];
2354                         }
2355                 }
2356         }
2357         close $fd or return;
2358         return \%refs;
2359 }
2360
2361 sub git_get_rev_name_tags {
2362         my $hash = shift || return undef;
2363
2364         open my $fd, "-|", git_cmd(), "name-rev", "--tags", $hash
2365                 or return;
2366         my $name_rev = <$fd>;
2367         close $fd;
2368
2369         if ($name_rev =~ m|^$hash tags/(.*)$|) {
2370                 return $1;
2371         } else {
2372                 # catches also '$hash undefined' output
2373                 return undef;
2374         }
2375 }
2376
2377 ## ----------------------------------------------------------------------
2378 ## parse to hash functions
2379
2380 sub parse_date {
2381         my $epoch = shift;
2382         my $tz = shift || "-0000";
2383
2384         my %date;
2385         my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2386         my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2387         my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2388         $date{'hour'} = $hour;
2389         $date{'minute'} = $min;
2390         $date{'mday'} = $mday;
2391         $date{'day'} = $days[$wday];
2392         $date{'month'} = $months[$mon];
2393         $date{'rfc2822'}   = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2394                              $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2395         $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2396                              $mday, $months[$mon], $hour ,$min;
2397         $date{'iso-8601'}  = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2398                              1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2399
2400         $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2401         my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2402         ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2403         $date{'hour_local'} = $hour;
2404         $date{'minute_local'} = $min;
2405         $date{'tz_local'} = $tz;
2406         $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2407                                   1900+$year, $mon+1, $mday,
2408                                   $hour, $min, $sec, $tz);
2409         return %date;
2410 }
2411
2412 sub parse_tag {
2413         my $tag_id = shift;
2414         my %tag;
2415         my @comment;
2416
2417         open my $fd, "-|", git_cmd(), "cat-file", "tag", $tag_id or return;
2418         $tag{'id'} = $tag_id;
2419         while (my $line = <$fd>) {
2420                 chomp $line;
2421                 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2422                         $tag{'object'} = $1;
2423                 } elsif ($line =~ m/^type (.+)$/) {
2424                         $tag{'type'} = $1;
2425                 } elsif ($line =~ m/^tag (.+)$/) {
2426                         $tag{'name'} = $1;
2427                 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2428                         $tag{'author'} = $1;
2429                         $tag{'epoch'} = $2;
2430                         $tag{'tz'} = $3;
2431                 } elsif ($line =~ m/--BEGIN/) {
2432                         push @comment, $line;
2433                         last;
2434                 } elsif ($line eq "") {
2435                         last;
2436                 }
2437         }
2438         push @comment, <$fd>;
2439         $tag{'comment'} = \@comment;
2440         close $fd or return;
2441         if (!defined $tag{'name'}) {
2442                 return
2443         };
2444         return %tag
2445 }
2446
2447 sub parse_commit_text {
2448         my ($commit_text, $withparents) = @_;
2449         my @commit_lines = split '\n', $commit_text;
2450         my %co;
2451
2452         pop @commit_lines; # Remove '\0'
2453
2454         if (! @commit_lines) {
2455                 return;
2456         }
2457
2458         my $header = shift @commit_lines;
2459         if ($header !~ m/^[0-9a-fA-F]{40}/) {
2460                 return;
2461         }
2462         ($co{'id'}, my @parents) = split ' ', $header;
2463         while (my $line = shift @commit_lines) {
2464                 last if $line eq "\n";
2465                 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2466                         $co{'tree'} = $1;
2467                 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2468                         push @parents, $1;
2469                 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2470                         $co{'author'} = $1;
2471                         $co{'author_epoch'} = $2;
2472                         $co{'author_tz'} = $3;
2473                         if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2474                                 $co{'author_name'}  = $1;
2475                                 $co{'author_email'} = $2;
2476                         } else {
2477                                 $co{'author_name'} = $co{'author'};
2478                         }
2479                 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2480                         $co{'committer'} = $1;
2481                         $co{'committer_epoch'} = $2;
2482                         $co{'committer_tz'} = $3;
2483                         $co{'committer_name'} = $co{'committer'};
2484                         if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2485                                 $co{'committer_name'}  = $1;
2486                                 $co{'committer_email'} = $2;
2487                         } else {
2488                                 $co{'committer_name'} = $co{'committer'};
2489                         }
2490                 }
2491         }
2492         if (!defined $co{'tree'}) {
2493                 return;
2494         };
2495         $co{'parents'} = \@parents;
2496         $co{'parent'} = $parents[0];
2497
2498         foreach my $title (@commit_lines) {
2499                 $title =~ s/^    //;
2500                 if ($title ne "") {
2501                         $co{'title'} = chop_str($title, 80, 5);
2502                         # remove leading stuff of merges to make the interesting part visible
2503                         if (length($title) > 50) {
2504                                 $title =~ s/^Automatic //;
2505                                 $title =~ s/^merge (of|with) /Merge ... /i;
2506                                 if (length($title) > 50) {
2507                                         $title =~ s/(http|rsync):\/\///;
2508                                 }
2509                                 if (length($title) > 50) {
2510                                         $title =~ s/(master|www|rsync)\.//;
2511                                 }
2512                                 if (length($title) > 50) {
2513                                         $title =~ s/kernel.org:?//;
2514                                 }
2515                                 if (length($title) > 50) {
2516                                         $title =~ s/\/pub\/scm//;
2517                                 }
2518                         }
2519                         $co{'title_short'} = chop_str($title, 50, 5);
2520                         last;
2521                 }
2522         }
2523         if (! defined $co{'title'} || $co{'title'} eq "") {
2524                 $co{'title'} = $co{'title_short'} = '(no commit message)';
2525         }
2526         # remove added spaces
2527         foreach my $line (@commit_lines) {
2528                 $line =~ s/^    //;
2529         }
2530         $co{'comment'} = \@commit_lines;
2531
2532         my $age = time - $co{'committer_epoch'};
2533         $co{'age'} = $age;
2534         $co{'age_string'} = age_string($age);
2535         my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2536         if ($age > 60*60*24*7*2) {
2537                 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2538                 $co{'age_string_age'} = $co{'age_string'};
2539         } else {
2540                 $co{'age_string_date'} = $co{'age_string'};
2541                 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2542         }
2543         return %co;
2544 }
2545
2546 sub parse_commit {
2547         my ($commit_id) = @_;
2548         my %co;
2549
2550         local $/ = "\0";
2551
2552         open my $fd, "-|", git_cmd(), "rev-list",
2553                 "--parents",
2554                 "--header",
2555                 "--max-count=1",
2556                 $commit_id,
2557                 "--",
2558                 or die_error(500, "Open git-rev-list failed");
2559         %co = parse_commit_text(<$fd>, 1);
2560         close $fd;
2561
2562         return %co;
2563 }
2564
2565 sub parse_commits {
2566         my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
2567         my @cos;
2568
2569         $maxcount ||= 1;
2570         $skip ||= 0;
2571
2572         local $/ = "\0";
2573
2574         open my $fd, "-|", git_cmd(), "rev-list",
2575                 "--header",
2576                 @args,
2577                 ("--max-count=" . $maxcount),
2578                 ("--skip=" . $skip),
2579                 @extra_options,
2580                 $commit_id,
2581                 "--",
2582                 ($filename ? ($filename) : ())
2583                 or die_error(500, "Open git-rev-list failed");
2584         while (my $line = <$fd>) {
2585                 my %co = parse_commit_text($line);
2586                 push @cos, \%co;
2587         }
2588         close $fd;
2589
2590         return wantarray ? @cos : \@cos;
2591 }
2592
2593 # parse line of git-diff-tree "raw" output
2594 sub parse_difftree_raw_line {
2595         my $line = shift;
2596         my %res;
2597
2598         # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M   ls-files.c'
2599         # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M   rev-tree.c'
2600         if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
2601                 $res{'from_mode'} = $1;
2602                 $res{'to_mode'} = $2;
2603                 $res{'from_id'} = $3;
2604                 $res{'to_id'} = $4;
2605                 $res{'status'} = $5;
2606                 $res{'similarity'} = $6;
2607                 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
2608                         ($res{'from_file'}, $res{'to_file'}) = map { unquote($_) } split("\t", $7);
2609                 } else {
2610                         $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote($7);
2611                 }
2612         }
2613         # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
2614         # combined diff (for merge commit)
2615         elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
2616                 $res{'nparents'}  = length($1);
2617                 $res{'from_mode'} = [ split(' ', $2) ];
2618                 $res{'to_mode'} = pop @{$res{'from_mode'}};
2619                 $res{'from_id'} = [ split(' ', $3) ];
2620                 $res{'to_id'} = pop @{$res{'from_id'}};
2621                 $res{'status'} = [ split('', $4) ];
2622                 $res{'to_file'} = unquote($5);
2623         }
2624         # 'c512b523472485aef4fff9e57b229d9d243c967f'
2625         elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
2626                 $res{'commit'} = $1;
2627         }
2628
2629         return wantarray ? %res : \%res;
2630 }
2631
2632 # wrapper: return parsed line of git-diff-tree "raw" output
2633 # (the argument might be raw line, or parsed info)
2634 sub parsed_difftree_line {
2635         my $line_or_ref = shift;
2636
2637         if (ref($line_or_ref) eq "HASH") {
2638                 # pre-parsed (or generated by hand)
2639                 return $line_or_ref;
2640         } else {
2641                 return parse_difftree_raw_line($line_or_ref);
2642         }
2643 }
2644
2645 # parse line of git-ls-tree output
2646 sub parse_ls_tree_line ($;%) {
2647         my $line = shift;
2648         my %opts = @_;
2649         my %res;
2650
2651         #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
2652         $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
2653
2654         $res{'mode'} = $1;
2655         $res{'type'} = $2;
2656         $res{'hash'} = $3;
2657         if ($opts{'-z'}) {
2658                 $res{'name'} = $4;
2659         } else {
2660                 $res{'name'} = unquote($4);
2661         }
2662
2663         return wantarray ? %res : \%res;
2664 }
2665
2666 # generates _two_ hashes, references to which are passed as 2 and 3 argument
2667 sub parse_from_to_diffinfo {
2668         my ($diffinfo, $from, $to, @parents) = @_;
2669
2670         if ($diffinfo->{'nparents'}) {
2671                 # combined diff
2672                 $from->{'file'} = [];
2673                 $from->{'href'} = [];
2674                 fill_from_file_info($diffinfo, @parents)
2675                         unless exists $diffinfo->{'from_file'};
2676                 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2677                         $from->{'file'}[$i] =
2678                                 defined $diffinfo->{'from_file'}[$i] ?
2679                                         $diffinfo->{'from_file'}[$i] :
2680                                         $diffinfo->{'to_file'};
2681                         if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
2682                                 $from->{'href'}[$i] = href(action=>"blob",
2683                                                            hash_base=>$parents[$i],
2684                                                            hash=>$diffinfo->{'from_id'}[$i],
2685                                                            file_name=>$from->{'file'}[$i]);
2686                         } else {
2687                                 $from->{'href'}[$i] = undef;
2688                         }
2689                 }
2690         } else {
2691                 # ordinary (not combined) diff
2692                 $from->{'file'} = $diffinfo->{'from_file'};
2693                 if ($diffinfo->{'status'} ne "A") { # not new (added) file
2694                         $from->{'href'} = href(action=>"blob", hash_base=>$hash_parent,
2695                                                hash=>$diffinfo->{'from_id'},
2696                                                file_name=>$from->{'file'});
2697                 } else {
2698                         delete $from->{'href'};
2699                 }
2700         }
2701
2702         $to->{'file'} = $diffinfo->{'to_file'};
2703         if (!is_deleted($diffinfo)) { # file exists in result
2704                 $to->{'href'} = href(action=>"blob", hash_base=>$hash,
2705                                      hash=>$diffinfo->{'to_id'},
2706                                      file_name=>$to->{'file'});
2707         } else {
2708                 delete $to->{'href'};
2709         }
2710 }
2711
2712 ## ......................................................................
2713 ## parse to array of hashes functions
2714
2715 sub git_get_heads_list {
2716         my $limit = shift;
2717         my @headslist;
2718
2719         open my $fd, '-|', git_cmd(), 'for-each-ref',
2720                 ($limit ? '--count='.($limit+1) : ()), '--sort=-committerdate',
2721                 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
2722                 'refs/heads'
2723                 or return;
2724         while (my $line = <$fd>) {
2725                 my %ref_item;
2726
2727                 chomp $line;
2728                 my ($refinfo, $committerinfo) = split(/\0/, $line);
2729                 my ($hash, $name, $title) = split(' ', $refinfo, 3);
2730                 my ($committer, $epoch, $tz) =
2731                         ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
2732                 $ref_item{'fullname'}  = $name;
2733                 $name =~ s!^refs/heads/!!;
2734
2735                 $ref_item{'name'}  = $name;
2736                 $ref_item{'id'}    = $hash;
2737                 $ref_item{'title'} = $title || '(no commit message)';
2738                 $ref_item{'epoch'} = $epoch;
2739                 if ($epoch) {
2740                         $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
2741                 } else {
2742                         $ref_item{'age'} = "unknown";
2743                 }
2744
2745                 push @headslist, \%ref_item;
2746         }
2747         close $fd;
2748
2749         return wantarray ? @headslist : \@headslist;
2750 }
2751
2752 sub git_get_tags_list {
2753         my $limit = shift;
2754         my @tagslist;
2755
2756         open my $fd, '-|', git_cmd(), 'for-each-ref',
2757                 ($limit ? '--count='.($limit+1) : ()), '--sort=-creatordate',
2758                 '--format=%(objectname) %(objecttype) %(refname) '.
2759                 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
2760                 'refs/tags'
2761                 or return;
2762         while (my $line = <$fd>) {
2763                 my %ref_item;
2764
2765                 chomp $line;
2766                 my ($refinfo, $creatorinfo) = split(/\0/, $line);
2767                 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
2768                 my ($creator, $epoch, $tz) =
2769                         ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
2770                 $ref_item{'fullname'} = $name;
2771                 $name =~ s!^refs/tags/!!;
2772
2773                 $ref_item{'type'} = $type;
2774                 $ref_item{'id'} = $id;
2775                 $ref_item{'name'} = $name;
2776                 if ($type eq "tag") {
2777                         $ref_item{'subject'} = $title;
2778                         $ref_item{'reftype'} = $reftype;
2779                         $ref_item{'refid'}   = $refid;
2780                 } else {
2781                         $ref_item{'reftype'} = $type;
2782                         $ref_item{'refid'}   = $id;
2783                 }
2784
2785                 if ($type eq "tag" || $type eq "commit") {
2786                         $ref_item{'epoch'} = $epoch;
2787                         if ($epoch) {
2788                                 $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
2789                         } else {
2790                                 $ref_item{'age'} = "unknown";
2791                         }
2792                 }
2793
2794                 push @tagslist, \%ref_item;
2795         }
2796         close $fd;
2797
2798         return wantarray ? @tagslist : \@tagslist;
2799 }
2800
2801 ## ----------------------------------------------------------------------
2802 ## filesystem-related functions
2803
2804 sub get_file_owner {
2805         my $path = shift;
2806
2807         my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
2808         my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
2809         if (!defined $gcos) {
2810                 return undef;
2811         }
2812         my $owner = $gcos;
2813         $owner =~ s/[,;].*$//;
2814         return to_utf8($owner);
2815 }
2816
2817 # assume that file exists
2818 sub insert_file {
2819         my $filename = shift;
2820
2821         open my $fd, '<', $filename;
2822         return join '', map to_utf8($_), <$fd>;
2823 }
2824
2825 ## ......................................................................
2826 ## mimetype related functions
2827
2828 sub mimetype_guess_file {
2829         my $filename = shift;
2830         my $mimemap = shift;
2831         -r $mimemap or return undef;
2832
2833         my %mimemap;
2834         open(MIME, $mimemap) or return undef;
2835         while (<MIME>) {
2836                 next if m/^#/; # skip comments
2837                 my ($mime, $exts) = split(/\t+/);
2838                 if (defined $exts) {
2839                         my @exts = split(/\s+/, $exts);
2840                         foreach my $ext (@exts) {
2841                                 $mimemap{$ext} = $mime;
2842                         }
2843                 }
2844         }
2845         close(MIME);
2846
2847         $filename =~ /\.([^.]*)$/;
2848         return $mimemap{$1};
2849 }
2850
2851 sub mimetype_guess {
2852         my $filename = shift;
2853         my $mime;
2854         $filename =~ /\./ or return undef;
2855
2856         if ($mimetypes_file) {
2857                 my $file = $mimetypes_file;
2858                 if ($file !~ m!^/!) { # if it is relative path
2859                         # it is relative to project
2860                         $file = "$projectroot/$project/$file";
2861                 }
2862                 $mime = mimetype_guess_file($filename, $file);
2863         }
2864         $mime ||= mimetype_guess_file($filename, '/etc/mime.types');
2865         return $mime;
2866 }
2867
2868 sub blob_mimetype {
2869         my $fd = shift;
2870         my $filename = shift;
2871
2872         if ($filename) {
2873                 my $mime = mimetype_guess($filename);
2874                 $mime and return $mime;
2875         }
2876
2877         # just in case
2878         return $default_blob_plain_mimetype unless $fd;
2879
2880         if (-T $fd) {
2881                 return 'text/plain';
2882         } elsif (! $filename) {
2883                 return 'application/octet-stream';
2884         } elsif ($filename =~ m/\.png$/i) {
2885                 return 'image/png';
2886         } elsif ($filename =~ m/\.gif$/i) {
2887                 return 'image/gif';
2888         } elsif ($filename =~ m/\.jpe?g$/i) {
2889                 return 'image/jpeg';
2890         } else {
2891                 return 'application/octet-stream';
2892         }
2893 }
2894
2895 sub blob_contenttype {
2896         my ($fd, $file_name, $type) = @_;
2897
2898         $type ||= blob_mimetype($fd, $file_name);
2899         if ($type eq 'text/plain' && defined $default_text_plain_charset) {
2900                 $type .= "; charset=$default_text_plain_charset";
2901         }
2902
2903         return $type;
2904 }
2905
2906 ## ======================================================================
2907 ## functions printing HTML: header, footer, error page
2908
2909 sub git_header_html {
2910         # XXX These aren't used, how odd.
2911         my $status = shift || "200 OK";
2912         my $expires = shift;
2913
2914         my $title = "$site_name";
2915         if (defined $project) {
2916                 $title .= " - " . to_utf8($project);
2917                 if (defined $action) {
2918                         $title .= "/$action";
2919                         if (defined $file_name) {
2920                                 $title .= " - " . esc_path($file_name);
2921                                 if ($action eq "tree" && $file_name !~ m|/$|) {
2922                                         $title .= "/";
2923                                 }
2924                         }
2925                 }
2926         }
2927
2928         $c->stash->{version} = $version;
2929         $c->stash->{git_version} = $git_version;
2930         $c->stash->{title} = $title;
2931
2932         # the stylesheet, favicon etc urls won't work correctly with path_info
2933         # unless we set the appropriate base URL
2934         $c->stash->{baseurl} = $ENV{PATH_INFO}
2935                                                  ? q[<base href="].esc_url($base_url).q[" />]
2936                                                  : '';
2937
2938         # print out each stylesheet that exist, providing backwards capability
2939         # for those people who defined $stylesheet in a config file
2940         my $ssfmt = q[<link rel="stylesheet" type="text/css" href="%s"/>];
2941         $c->stash->{stylesheets} = [defined $stylesheet
2942                 ? sprintf($ssfmt, $stylesheet)
2943                 : map(sprintf($ssfmt, $_), grep $_, @stylesheets)
2944         ];
2945
2946         $c->stash->{project} = defined $project;
2947         if (defined $project) {
2948                 my %href_params = get_feed_info();
2949                 if (!exists $href_params{'-title'}) {
2950                         $href_params{'-title'} = 'log';
2951                 }
2952
2953                 foreach my $format qw(RSS Atom) {
2954                         my $type = lc($format);
2955                         my %link_attr = (
2956                                 '-rel' => 'alternate',
2957                                 '-title' => "$project - $href_params{'-title'} - $format feed",
2958                                 '-type' => "application/$type+xml"
2959                         );
2960
2961                         $href_params{'action'} = $type;
2962                         $link_attr{'-href'} = href(%href_params);
2963                         $c->stash->{lc $format.'_link'} = "<link ".
2964                               "rel=\"$link_attr{'-rel'}\" ".
2965                               "title=\"$link_attr{'-title'}\" ".
2966                               "href=\"$link_attr{'-href'}\" ".
2967                               "type=\"$link_attr{'-type'}\" ".
2968                               "/>\n";
2969
2970                         $href_params{'extra_options'} = '--no-merges';
2971                         $link_attr{'-href'} = href(%href_params);
2972                         $link_attr{'-title'} .= ' (no merges)';
2973                         $c->stash->{lc $format.'_link_no_merges'} = "<link ".
2974                               "rel=\"$link_attr{'-rel'}\" ".
2975                               "title=\"$link_attr{'-title'}\" ".
2976                               "href=\"$link_attr{'-href'}\" ".
2977                               "type=\"$link_attr{'-type'}\" ".
2978                               "/>\n";
2979                 }
2980
2981         } else {
2982                 $c->stash->{projects_list} = sprintf('<link rel="alternate" title="%s projects list" '.
2983                        'href="%s" type="text/plain; charset=utf-8" />'."\n",
2984                        $site_name, href(project=>undef, action=>"project_index"));
2985                 $c->stash->{projects_feed} = sprintf('<link rel="alternate" title="%s projects feeds" '.
2986                        'href="%s" type="text/x-opml" />'."\n",
2987                        $site_name, href(project=>undef, action=>"opml"));
2988         }
2989
2990         $c->stash->{favicon} = defined $favicon
2991                 ? qq(<link rel="shortcut icon" href="$favicon" type="image/png" />)
2992                 : '';
2993
2994         # </head><body>
2995
2996         $c->stash->{site_header} = -f $site_header
2997                 ? insert_file($site_header)
2998                 : '';
2999
3000         $c->stash->{logo}
3001                 = $cgi->a({-href => esc_url($logo_url),
3002                                    -title => $logo_label},
3003                                    qq(<img src="$logo" width="72" height="27" alt="git" class="logo"/>));
3004         $c->stash->{home_link} =  $cgi->a({-href => esc_url($home_link)}, $home_link_str);
3005
3006         if(defined $project) {
3007                 $c->stash->{summary} = $cgi->a({-href => href(action=>"summary")}, esc_html($project));
3008                 $c->stash->{action}  = $action;
3009         }
3010
3011         my $have_search = $c->stash->{have_search} = gitweb_check_feature('search');
3012         if (defined $project && $have_search) {
3013                 if (!defined $searchtext) {
3014                         $searchtext = "";
3015                 }
3016                 my $search_hash;
3017                 if (defined $hash_base) {
3018                         $search_hash = $hash_base;
3019                 } elsif (defined $hash) {
3020                         $search_hash = $hash;
3021                 } else {
3022                         $search_hash = "HEAD";
3023                 }
3024                 my $action = $my_uri;
3025                 my $use_pathinfo = gitweb_check_feature('pathinfo');
3026                 if ($use_pathinfo) {
3027                         $action .= "/".esc_url($project);
3028                 }
3029                 # This could be done better, but meh.
3030                 $c->stash->{search_form} = $cgi->startform(-method => "get", -action => $action) .
3031                       (!$use_pathinfo &&
3032                       $cgi->input({-name=>"p", -value=>$project, -type=>"hidden"}) . "\n") .
3033                       $cgi->input({-name=>"a", -value=>"search", -type=>"hidden"}) . "\n" .
3034                       $cgi->input({-name=>"h", -value=>$search_hash, -type=>"hidden"}) . "\n" .
3035                       $cgi->popup_menu(-name => 'st', -default => 'commit',
3036                                        -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3037                       $cgi->sup($cgi->a({-href => href(action=>"search_help")}, "?")) .
3038                       " search:\n".
3039                       $cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
3040                       "<span title=\"Extended regular expression\">" .
3041                       $cgi->checkbox(-name => 'sr', -value => 1, -label => 're',
3042                                      -checked => $search_use_regexp) .
3043                       "</span>" .
3044                       $cgi->end_form() . "\n";
3045         }
3046 }
3047
3048 sub git_footer_html {
3049         my $feed_class = 'rss_logo';
3050
3051         if (defined $project) {
3052                 my $descr = git_get_project_description($project);
3053                 $c->stash->{project_description} = defined $descr
3054                         ? esc_html($descr)
3055                         : '';
3056
3057                 my %href_params = get_feed_info();
3058                 if (!%href_params) {
3059                         $feed_class .= ' generic';
3060                 }
3061                 $href_params{'-title'} ||= 'log';
3062
3063                 foreach my $format qw(RSS Atom) {
3064                         $href_params{'action'} = lc($format);
3065                         $c->stash->{lc $format.'_feed'} = $cgi->a({-href => href(%href_params),
3066                                       -title => "$href_params{'-title'} $format feed",
3067                                       -class => $feed_class}, $format);
3068                 }
3069
3070         } else {
3071                 $c->stash->{opml_feed} = $cgi->a({-href => href(project=>undef, action=>"opml"),
3072                               -class => $feed_class}, "OPML");
3073                 $c->stash->{index_feed} = $cgi->a({-href => href(project=>undef, action=>"project_index"),
3074                               -class => $feed_class}, "TXT");
3075         }
3076
3077         $c->stash->{site_footer} = -f $site_footer
3078                 ? insert_file($site_footer)
3079                 : '';
3080 }
3081
3082 # die_error(<http_status_code>, <error_message>)
3083 # Example: die_error(404, 'Hash not found')
3084 # By convention, use the following status codes (as defined in RFC 2616):
3085 # 400: Invalid or missing CGI parameters, or
3086 #      requested object exists but has wrong type.
3087 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
3088 #      this server or project.
3089 # 404: Requested object/revision/project doesn't exist.
3090 # 500: The server isn't configured properly, or
3091 #      an internal error occurred (e.g. failed assertions caused by bugs), or
3092 #      an unknown error occurred (e.g. the git binary died unexpectedly).
3093 sub die_error {
3094         my $status = shift || 500;
3095         my $error = shift || "Internal server error";
3096
3097         my %http_responses = (400 => '400 Bad Request',
3098                               403 => '403 Forbidden',
3099                               404 => '404 Not Found',
3100                               500 => '500 Internal Server Error');
3101         $c->response->status($http_responses{$status});
3102
3103         $c->stash->{content} = <<EOF;
3104         <div class="page_body">
3105         <br /><br />
3106         $status - $error
3107         <br />
3108         </div>
3109 EOF
3110         die bless {};
3111 }
3112
3113 ## ----------------------------------------------------------------------
3114 ## functions printing or outputting HTML: navigation
3115
3116 sub git_print_page_nav {
3117         my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3118         $extra = '' if !defined $extra; # pager or formats
3119
3120         my @navs = qw(summary shortlog log commit commitdiff tree);
3121         if ($suppress) {
3122                 @navs = grep { $_ ne $suppress } @navs;
3123         }
3124
3125         my %arg = map { $_ => {action=>$_} } @navs;
3126         if (defined $head) {
3127                 for (qw(commit commitdiff)) {
3128                         $arg{$_}{'hash'} = $head;
3129                 }
3130                 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3131                         for (qw(shortlog log)) {
3132                                 $arg{$_}{'hash'} = $head;
3133                         }
3134                 }
3135         }
3136
3137         $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3138         $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3139
3140         my @actions = gitweb_get_feature('actions');
3141         my %repl = (
3142                 '%' => '%',
3143                 'n' => $project,         # project name
3144                 'f' => $git_dir,         # project path within filesystem
3145                 'h' => $treehead || '',  # current hash ('h' parameter)
3146                 'b' => $treebase || '',  # hash base ('hb' parameter)
3147         );
3148         while (@actions) {
3149                 my ($label, $link, $pos) = splice(@actions,0,3);
3150                 # insert
3151                 @navs = map { $_ eq $pos ? ($_, $label) : $_ } @navs;
3152                 # munch munch
3153                 $link =~ s/%([%nfhb])/$repl{$1}/g;
3154                 $arg{$label}{'_href'} = $link;
3155         }
3156
3157         $c->stash->{page_nav} = 1;
3158         $c->stash->{nav_links} =
3159                 (join " | ",
3160                  map { $_ eq $current ?
3161                        $_ : $cgi->a({-href => ($arg{$_}{_href} ? $arg{$_}{_href} : href(%{$arg{$_}}))}, "$_")
3162                  } @navs);
3163         $c->stash->{extra} = $extra;
3164 }
3165
3166 sub format_paging_nav {
3167         my ($action, $hash, $head, $page, $has_next_link) = @_;
3168         my $paging_nav;
3169
3170
3171         if ($hash ne $head || $page) {
3172                 $paging_nav .= $cgi->a({-href => href(action=>$action)}, "HEAD");
3173         } else {
3174                 $paging_nav .= "HEAD";
3175         }
3176
3177         if ($page > 0) {
3178                 $paging_nav .= " &sdot; " .
3179                         $cgi->a({-href => href(-replay=>1, page=>$page-1),
3180                                  -accesskey => "p", -title => "Alt-p"}, "prev");
3181         } else {
3182                 $paging_nav .= " &sdot; prev";
3183         }
3184
3185         if ($has_next_link) {
3186                 $paging_nav .= " &sdot; " .
3187                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
3188                                  -accesskey => "n", -title => "Alt-n"}, "next");
3189         } else {
3190                 $paging_nav .= " &sdot; next";
3191         }
3192
3193         return $paging_nav;
3194 }
3195
3196 ## ......................................................................
3197 ## functions printing or outputting HTML: div
3198
3199 sub git_print_header_div {
3200         my ($action, $title, $hash, $hash_base) = @_;
3201         my %args = ();
3202
3203         $args{'action'} = $action;
3204         $args{'hash'} = $hash if $hash;
3205         $args{'hash_base'} = $hash_base if $hash_base;
3206
3207     print q[<div class="header">],
3208               $cgi->a({-href => href(%args), -class => "title"},
3209               $title ? $title : $action),
3210                   q[</div>];
3211 }
3212
3213 sub git_print_authorship {
3214         my $co = shift;
3215
3216         my %ad = parse_date($co->{'author_epoch'}, $co->{'author_tz'});
3217         print "<div class=\"author_date\">" .
3218               esc_html($co->{'author_name'}) .
3219               " [$ad{'rfc2822'}";
3220         if ($ad{'hour_local'} < 6) {
3221                 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3222                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
3223         } else {
3224                 printf(" (%02d:%02d %s)",
3225                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
3226         }
3227         print "]</div>\n";
3228 }
3229
3230 sub git_print_page_path {
3231         my $name = shift;
3232         my $type = shift;
3233         my $hb = shift;
3234
3235
3236         print "<div class=\"page_path\">";
3237         print $cgi->a({-href => href(action=>"tree", hash_base=>$hb),
3238                       -title => 'tree root'}, to_utf8("[$project]"));
3239         print " / ";
3240         if (defined $name) {
3241                 my @dirname = split '/', $name;
3242                 my $basename = pop @dirname;
3243                 my $fullname = '';
3244
3245                 foreach my $dir (@dirname) {
3246                         $fullname .= ($fullname ? '/' : '') . $dir;
3247                         print $cgi->a({-href => href(action=>"tree", file_name=>$fullname,
3248                                                      hash_base=>$hb),
3249                                       -title => $fullname}, esc_path($dir));
3250                         print " / ";
3251                 }
3252                 if (defined $type && $type eq 'blob') {
3253                         print $cgi->a({-href => href(action=>"blob_plain", file_name=>$file_name,
3254                                                      hash_base=>$hb),
3255                                       -title => $name}, esc_path($basename));
3256                 } elsif (defined $type && $type eq 'tree') {
3257                         print $cgi->a({-href => href(action=>"tree", file_name=>$file_name,
3258                                                      hash_base=>$hb),
3259                                       -title => $name}, esc_path($basename));
3260                         print " / ";
3261                 } else {
3262                         print esc_path($basename);
3263                 }
3264         }
3265         print "<br/></div>\n";
3266 }
3267
3268 # sub git_print_log (\@;%) {
3269 sub git_print_log ($;%) {
3270         my $log = shift;
3271         my %opts = @_;
3272
3273         if ($opts{'-remove_title'}) {
3274                 # remove title, i.e. first line of log
3275                 shift @$log;
3276         }
3277         # remove leading empty lines
3278         while (defined $log->[0] && $log->[0] eq "") {
3279                 shift @$log;
3280         }
3281
3282         # print log
3283         my $signoff = 0;
3284         my $empty = 0;
3285         foreach my $line (@$log) {
3286                 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3287                         $signoff = 1;
3288                         $empty = 0;
3289                         if (! $opts{'-remove_signoff'}) {
3290                                 print "<span class=\"signoff\">" . esc_html($line) . "</span><br/>\n";
3291                                 next;
3292                         } else {
3293                                 # remove signoff lines
3294                                 next;
3295                         }
3296                 } else {
3297                         $signoff = 0;
3298                 }
3299
3300                 # print only one empty line
3301                 # do not print empty line after signoff
3302                 if ($line eq "") {
3303                         next if ($empty || $signoff);
3304                         $empty = 1;
3305                 } else {
3306                         $empty = 0;
3307                 }
3308
3309                 print format_log_line_html($line) . "<br/>\n";
3310         }
3311
3312         if ($opts{'-final_empty_line'}) {
3313                 # end with single empty line
3314                 print "<br/>\n" unless $empty;
3315         }
3316 }
3317
3318 # return link target (what link points to)
3319 sub git_get_link_target {
3320         my $hash = shift;
3321         my $link_target;
3322
3323         # read link
3324         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
3325                 or return;
3326         {
3327                 local $/;
3328                 $link_target = <$fd>;
3329         }
3330         close $fd
3331                 or return;
3332
3333         return $link_target;
3334 }
3335
3336 # given link target, and the directory (basedir) the link is in,
3337 # return target of link relative to top directory (top tree);
3338 # return undef if it is not possible (including absolute links).
3339 sub normalize_link_target {
3340         my ($link_target, $basedir, $hash_base) = @_;
3341
3342         # we can normalize symlink target only if $hash_base is provided
3343         return unless $hash_base;
3344
3345         # absolute symlinks (beginning with '/') cannot be normalized
3346         return if (substr($link_target, 0, 1) eq '/');
3347
3348         # normalize link target to path from top (root) tree (dir)
3349         my $path;
3350         if ($basedir) {
3351                 $path = $basedir . '/' . $link_target;
3352         } else {
3353                 # we are in top (root) tree (dir)
3354                 $path = $link_target;
3355         }
3356
3357         # remove //, /./, and /../
3358         my @path_parts;
3359         foreach my $part (split('/', $path)) {
3360                 # discard '.' and ''
3361                 next if (!$part || $part eq '.');
3362                 # handle '..'
3363                 if ($part eq '..') {
3364                         if (@path_parts) {
3365                                 pop @path_parts;
3366                         } else {
3367                                 # link leads outside repository (outside top dir)
3368                                 return;
3369                         }
3370                 } else {
3371                         push @path_parts, $part;
3372                 }
3373         }
3374         $path = join('/', @path_parts);
3375
3376         return $path;
3377 }
3378
3379 # print tree entry (row of git_tree), but without encompassing <tr> element
3380 sub git_print_tree_entry {
3381         my ($t, $basedir, $hash_base, $have_blame) = @_;
3382
3383         my %base_key = ();
3384         $base_key{'hash_base'} = $hash_base if defined $hash_base;
3385
3386         # The format of a table row is: mode list link.  Where mode is
3387         # the mode of the entry, list is the name of the entry, an href,
3388         # and link is the action links of the entry.
3389
3390         print "<td class=\"mode\">" . mode_str($t->{'mode'}) . "</td>\n";
3391         if ($t->{'type'} eq "blob") {
3392                 print "<td class=\"list\">" .
3393                         $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
3394                                                file_name=>"$basedir$t->{'name'}", %base_key),
3395                                 -class => "list"}, esc_path($t->{'name'}));
3396                 if (S_ISLNK(oct $t->{'mode'})) {
3397                         my $link_target = git_get_link_target($t->{'hash'});
3398                         if ($link_target) {
3399                                 my $norm_target = normalize_link_target($link_target, $basedir, $hash_base);
3400                                 if (defined $norm_target) {
3401                                         print " -> " .
3402                                               $cgi->a({-href => href(action=>"object", hash_base=>$hash_base,
3403                                                                      file_name=>$norm_target),
3404                                                        -title => $norm_target}, esc_path($link_target));
3405                                 } else {
3406                                         print " -> " . esc_path($link_target);
3407                                 }
3408                         }
3409                 }
3410                 print "</td>\n";
3411                 print "<td class=\"link\">";
3412                 print $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
3413                                              file_name=>"$basedir$t->{'name'}", %base_key)},
3414                               "blob");
3415                 if ($have_blame) {
3416                         print " | " .
3417                               $cgi->a({-href => href(action=>"blame", hash=>$t->{'hash'},
3418                                                      file_name=>"$basedir$t->{'name'}", %base_key)},
3419                                       "blame");
3420                 }
3421                 if (defined $hash_base) {
3422                         print " | " .
3423                               $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
3424                                                      hash=>$t->{'hash'}, file_name=>"$basedir$t->{'name'}")},
3425                                       "history");
3426                 }
3427                 print " | " .
3428                         $cgi->a({-href => href(action=>"blob_plain", hash_base=>$hash_base,
3429                                                file_name=>"$basedir$t->{'name'}")},
3430                                 "raw");
3431                 print "</td>\n";
3432
3433         } elsif ($t->{'type'} eq "tree") {
3434                 print "<td class=\"list\">";
3435                 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
3436                                              file_name=>"$basedir$t->{'name'}", %base_key)},
3437                               esc_path($t->{'name'}));
3438                 print "</td>\n";
3439                 print "<td class=\"link\">";
3440                 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
3441                                              file_name=>"$basedir$t->{'name'}", %base_key)},
3442                               "tree");
3443                 if (defined $hash_base) {
3444                         print " | " .
3445                               $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
3446                                                      file_name=>"$basedir$t->{'name'}")},
3447                                       "history");
3448                 }
3449                 print "</td>\n";
3450         } else {
3451                 # unknown object: we can only present history for it
3452                 # (this includes 'commit' object, i.e. submodule support)
3453                 print "<td class=\"list\">" .
3454                       esc_path($t->{'name'}) .
3455                       "</td>\n";
3456                 print "<td class=\"link\">";
3457                 if (defined $hash_base) {
3458                         print $cgi->a({-href => href(action=>"history",
3459                                                      hash_base=>$hash_base,
3460                                                      file_name=>"$basedir$t->{'name'}")},
3461                                       "history");
3462                 }
3463                 print "</td>\n";
3464         }
3465 }
3466
3467 ## ......................................................................
3468 ## functions printing large fragments of HTML
3469
3470 # get pre-image filenames for merge (combined) diff
3471 sub fill_from_file_info {
3472         my ($diff, @parents) = @_;
3473
3474         $diff->{'from_file'} = [ ];
3475         $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
3476         for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3477                 if ($diff->{'status'}[$i] eq 'R' ||
3478                     $diff->{'status'}[$i] eq 'C') {
3479                         $diff->{'from_file'}[$i] =
3480                                 git_get_path_by_hash($parents[$i], $diff->{'from_id'}[$i]);
3481                 }
3482         }
3483
3484         return $diff;
3485 }
3486
3487 # is current raw difftree line of file deletion
3488 sub is_deleted {
3489         my $diffinfo = shift;
3490
3491         return $diffinfo->{'to_id'} eq ('0' x 40);
3492 }
3493
3494 # does patch correspond to [previous] difftree raw line
3495 # $diffinfo  - hashref of parsed raw diff format
3496 # $patchinfo - hashref of parsed patch diff format
3497 #              (the same keys as in $diffinfo)
3498 sub is_patch_split {
3499         my ($diffinfo, $patchinfo) = @_;
3500
3501         return defined $diffinfo && defined $patchinfo
3502                 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
3503 }
3504
3505
3506 sub git_difftree_body {
3507         my ($difftree, $hash, @parents) = @_;
3508         my ($parent) = $parents[0];
3509         my $have_blame = gitweb_check_feature('blame');
3510         print "<div class=\"list_head\">\n";
3511         if ($#{$difftree} > 10) {
3512                 print(($#{$difftree} + 1) . " files changed:\n");
3513         }
3514         print "</div>\n";
3515
3516         print "<table class=\"" .
3517               (@parents > 1 ? "combined " : "") .
3518               "diff_tree\">\n";
3519
3520         # header only for combined diff in 'commitdiff' view
3521         my $has_header = @$difftree && @parents > 1 && $action eq 'commitdiff';
3522         if ($has_header) {
3523                 # table header
3524                 print "<thead><tr>\n" .
3525                        "<th></th><th></th>\n"; # filename, patchN link
3526                 for (my $i = 0; $i < @parents; $i++) {
3527                         my $par = $parents[$i];
3528                         print "<th>" .
3529                               $cgi->a({-href => href(action=>"commitdiff",
3530                                                      hash=>$hash, hash_parent=>$par),
3531                                        -title => 'commitdiff to parent number ' .
3532                                                   ($i+1) . ': ' . substr($par,0,7)},
3533                                       $i+1) .
3534                               "&nbsp;</th>\n";
3535                 }
3536                 print "</tr></thead>\n<tbody>\n";
3537         }
3538
3539         my $alternate = 1;
3540         my $patchno = 0;
3541         foreach my $line (@{$difftree}) {
3542                 my $diff = parsed_difftree_line($line);
3543
3544                 if ($alternate) {
3545                         print "<tr class=\"dark\">\n";
3546                 } else {
3547                         print "<tr class=\"light\">\n";
3548                 }
3549                 $alternate ^= 1;
3550
3551                 if (exists $diff->{'nparents'}) { # combined diff
3552
3553                         fill_from_file_info($diff, @parents)
3554                                 unless exists $diff->{'from_file'};
3555
3556                         if (!is_deleted($diff)) {
3557                                 # file exists in the result (child) commit
3558                                 print "<td>" .
3559                                       $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3560                                                              file_name=>$diff->{'to_file'},
3561                                                              hash_base=>$hash),
3562                                               -class => "list"}, esc_path($diff->{'to_file'})) .
3563                                       "</td>\n";
3564                         } else {
3565                                 print "<td>" .
3566                                       esc_path($diff->{'to_file'}) .
3567                                       "</td>\n";
3568                         }
3569
3570                         if ($action eq 'commitdiff') {
3571                                 # link to patch
3572                                 $patchno++;
3573                                 print "<td class=\"link\">" .
3574                                       $cgi->a({-href => "#patch$patchno"}, "patch") .
3575                                       " | " .
3576                                       "</td>\n";
3577                         }
3578
3579                         my $has_history = 0;
3580                         my $not_deleted = 0;
3581                         for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3582                                 my $hash_parent = $parents[$i];
3583                                 my $from_hash = $diff->{'from_id'}[$i];
3584                                 my $from_path = $diff->{'from_file'}[$i];
3585                                 my $status = $diff->{'status'}[$i];
3586
3587                                 $has_history ||= ($status ne 'A');
3588                                 $not_deleted ||= ($status ne 'D');
3589
3590                                 if ($status eq 'A') {
3591                                         print "<td  class=\"link\" align=\"right\"> | </td>\n";
3592                                 } elsif ($status eq 'D') {
3593                                         print "<td class=\"link\">" .
3594                                               $cgi->a({-href => href(action=>"blob",
3595                                                                      hash_base=>$hash,
3596                                                                      hash=>$from_hash,
3597                                                                      file_name=>$from_path)},
3598                                                       "blob" . ($i+1)) .
3599                                               " | </td>\n";
3600                                 } else {
3601                                         if ($diff->{'to_id'} eq $from_hash) {
3602                                                 print "<td class=\"link nochange\">";
3603                                         } else {
3604                                                 print "<td class=\"link\">";
3605                                         }
3606                                         print $cgi->a({-href => href(action=>"blobdiff",
3607                                                                      hash=>$diff->{'to_id'},
3608                                                                      hash_parent=>$from_hash,
3609                                                                      hash_base=>$hash,
3610                                                                      hash_parent_base=>$hash_parent,
3611                                                                      file_name=>$diff->{'to_file'},
3612                                                                      file_parent=>$from_path)},
3613                                                       "diff" . ($i+1)) .
3614                                               " | </td>\n";
3615                                 }
3616                         }
3617
3618                         print "<td class=\"link\">";
3619                         if ($not_deleted) {
3620                                 print $cgi->a({-href => href(action=>"blob",
3621                                                              hash=>$diff->{'to_id'},
3622                                                              file_name=>$diff->{'to_file'},
3623                                                              hash_base=>$hash)},
3624                                               "blob");
3625                                 print " | " if ($has_history);
3626                         }
3627                         if ($has_history) {
3628                                 print $cgi->a({-href => href(action=>"history",
3629                                                              file_name=>$diff->{'to_file'},
3630                                                              hash_base=>$hash)},
3631                                               "history");
3632                         }
3633                         print "</td>\n";
3634
3635                         print "</tr>\n";
3636                         next; # instead of 'else' clause, to avoid extra indent
3637                 }
3638                 # else ordinary diff
3639
3640                 my ($to_mode_oct, $to_mode_str, $to_file_type);
3641                 my ($from_mode_oct, $from_mode_str, $from_file_type);
3642                 if ($diff->{'to_mode'} ne ('0' x 6)) {
3643                         $to_mode_oct = oct $diff->{'to_mode'};
3644                         if (S_ISREG($to_mode_oct)) { # only for regular file
3645                                 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
3646                         }
3647                         $to_file_type = file_type($diff->{'to_mode'});
3648                 }
3649                 if ($diff->{'from_mode'} ne ('0' x 6)) {
3650                         $from_mode_oct = oct $diff->{'from_mode'};
3651                         if (S_ISREG($to_mode_oct)) { # only for regular file
3652                                 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
3653                         }
3654                         $from_file_type = file_type($diff->{'from_mode'});
3655                 }
3656
3657                 if ($diff->{'status'} eq "A") { # created
3658                         my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
3659                         $mode_chng   .= " with mode: $to_mode_str" if $to_mode_str;
3660                         $mode_chng   .= "]</span>";
3661                         print "<td>";
3662                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3663                                                      hash_base=>$hash, file_name=>$diff->{'file'}),
3664                                       -class => "list"}, esc_path($diff->{'file'}));
3665                         print "</td>\n";
3666                         print "<td>$mode_chng</td>\n";
3667                         print "<td class=\"link\">";
3668                         if ($action eq 'commitdiff') {
3669                                 # link to patch
3670                                 $patchno++;
3671                                 print $cgi->a({-href => "#patch$patchno"}, "patch");
3672                                 print " | ";
3673                         }
3674                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3675                                                      hash_base=>$hash, file_name=>$diff->{'file'})},
3676                                       "blob");
3677                         print "</td>\n";
3678
3679                 } elsif ($diff->{'status'} eq "D") { # deleted
3680                         my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
3681                         print "<td>";
3682                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
3683                                                      hash_base=>$parent, file_name=>$diff->{'file'}),
3684                                        -class => "list"}, esc_path($diff->{'file'}));
3685                         print "</td>\n";
3686                         print "<td>$mode_chng</td>\n";
3687                         print "<td class=\"link\">";
3688                         if ($action eq 'commitdiff') {
3689                                 # link to patch
3690                                 $patchno++;
3691                                 print $cgi->a({-href => "#patch$patchno"}, "patch");
3692                                 print " | ";
3693                         }
3694                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
3695                                                      hash_base=>$parent, file_name=>$diff->{'file'})},
3696                                       "blob") . " | ";
3697                         if ($have_blame) {
3698                                 print $cgi->a({-href => href(action=>"blame", hash_base=>$parent,
3699                                                              file_name=>$diff->{'file'})},
3700                                               "blame") . " | ";
3701                         }
3702                         print $cgi->a({-href => href(action=>"history", hash_base=>$parent,
3703                                                      file_name=>$diff->{'file'})},
3704                                       "history");
3705                         print "</td>\n";
3706
3707                 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
3708                         my $mode_chnge = "";
3709                         if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3710                                 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
3711                                 if ($from_file_type ne $to_file_type) {
3712                                         $mode_chnge .= " from $from_file_type to $to_file_type";
3713                                 }
3714                                 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
3715                                         if ($from_mode_str && $to_mode_str) {
3716                                                 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
3717                                         } elsif ($to_mode_str) {
3718                                                 $mode_chnge .= " mode: $to_mode_str";
3719                                         }
3720                                 }
3721                                 $mode_chnge .= "]</span>\n";
3722                         }
3723                         print "<td>";
3724                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3725                                                      hash_base=>$hash, file_name=>$diff->{'file'}),
3726                                       -class => "list"}, esc_path($diff->{'file'}));
3727                         print "</td>\n";
3728                         print "<td>$mode_chnge</td>\n";
3729                         print "<td class=\"link\">";
3730                         if ($action eq 'commitdiff') {
3731                                 # link to patch
3732                                 $patchno++;
3733                                 print $cgi->a({-href => "#patch$patchno"}, "patch") .
3734                                       " | ";
3735                         } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3736                                 # "commit" view and modified file (not onlu mode changed)
3737                                 print $cgi->a({-href => href(action=>"blobdiff",
3738                                                              hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
3739                                                              hash_base=>$hash, hash_parent_base=>$parent,
3740                                                              file_name=>$diff->{'file'})},
3741                                               "diff") .
3742                                       " | ";
3743                         }
3744                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3745                                                      hash_base=>$hash, file_name=>$diff->{'file'})},
3746                                        "blob") . " | ";
3747                         if ($have_blame) {
3748                                 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
3749                                                              file_name=>$diff->{'file'})},
3750                                               "blame") . " | ";
3751                         }
3752                         print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
3753                                                      file_name=>$diff->{'file'})},
3754                                       "history");
3755                         print "</td>\n";
3756
3757                 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
3758                         my %status_name = ('R' => 'moved', 'C' => 'copied');
3759                         my $nstatus = $status_name{$diff->{'status'}};
3760                         my $mode_chng = "";
3761                         if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3762                                 # mode also for directories, so we cannot use $to_mode_str
3763                                 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
3764                         }
3765                         print "<td>" .
3766                               $cgi->a({-href => href(action=>"blob", hash_base=>$hash,
3767                                                      hash=>$diff->{'to_id'}, file_name=>$diff->{'to_file'}),
3768                                       -class => "list"}, esc_path($diff->{'to_file'})) . "</td>\n" .
3769                               "<td><span class=\"file_status $nstatus\">[$nstatus from " .
3770                               $cgi->a({-href => href(action=>"blob", hash_base=>$parent,
3771                                                      hash=>$diff->{'from_id'}, file_name=>$diff->{'from_file'}),
3772                                       -class => "list"}, esc_path($diff->{'from_file'})) .
3773                               " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
3774                               "<td class=\"link\">";
3775                         if ($action eq 'commitdiff') {
3776                                 # link to patch
3777                                 $patchno++;
3778                                 print $cgi->a({-href => "#patch$patchno"}, "patch") .
3779                                       " | ";
3780                         } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3781                                 # "commit" view and modified file (not only pure rename or copy)
3782                                 print $cgi->a({-href => href(action=>"blobdiff",
3783                                                              hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
3784                                                              hash_base=>$hash, hash_parent_base=>$parent,
3785                                                              file_name=>$diff->{'to_file'}, file_parent=>$diff->{'from_file'})},
3786                                               "diff") .
3787                                       " | ";
3788                         }
3789                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3790                                                      hash_base=>$parent, file_name=>$diff->{'to_file'})},
3791                                       "blob") . " | ";
3792                         if ($have_blame) {
3793                                 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
3794                                                              file_name=>$diff->{'to_file'})},
3795                                               "blame") . " | ";
3796                         }
3797                         print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
3798                                                     file_name=>$diff->{'to_file'})},
3799                                       "history");
3800                         print "</td>\n";
3801
3802                 } # we should not encounter Unmerged (U) or Unknown (X) status
3803                 print "</tr>\n";
3804         }
3805         print "</tbody>" if $has_header;
3806         print "</table>\n";
3807 }
3808
3809 sub git_patchset_body {
3810         my ($fd, $difftree, $hash, @hash_parents) = @_;
3811         my ($hash_parent) = $hash_parents[0];
3812
3813         my $is_combined = (@hash_parents > 1);
3814         my $patch_idx = 0;
3815         my $patch_number = 0;
3816         my $patch_line;
3817         my $diffinfo;
3818         my $to_name;
3819         my (%from, %to);
3820
3821         print "<div class=\"patchset\">\n";
3822
3823         # skip to first patch
3824         while ($patch_line = <$fd>) {
3825                 chomp $patch_line;
3826
3827                 last if ($patch_line =~ m/^diff /);
3828         }
3829
3830  PATCH:
3831         while ($patch_line) {
3832
3833                 # parse "git diff" header line
3834                 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
3835                         # $1 is from_name, which we do not use
3836                         $to_name = unquote($2);
3837                         $to_name =~ s!^b/!!;
3838                 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
3839                         # $1 is 'cc' or 'combined', which we do not use
3840                         $to_name = unquote($2);
3841                 } else {
3842                         $to_name = undef;
3843                 }
3844
3845                 # check if current patch belong to current raw line
3846                 # and parse raw git-diff line if needed
3847                 if (is_patch_split($diffinfo, { 'to_file' => $to_name })) {
3848                         # this is continuation of a split patch
3849                         print "<div class=\"patch cont\">\n";
3850                 } else {
3851                         # advance raw git-diff output if needed
3852                         $patch_idx++ if defined $diffinfo;
3853
3854                         # read and prepare patch information
3855                         $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
3856
3857                         # compact combined diff output can have some patches skipped
3858                         # find which patch (using pathname of result) we are at now;
3859                         if ($is_combined) {
3860                                 while ($to_name ne $diffinfo->{'to_file'}) {
3861                                         print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3862                                               format_diff_cc_simplified($diffinfo, @hash_parents) .
3863                                               "</div>\n";  # class="patch"
3864
3865                                         $patch_idx++;
3866                                         $patch_number++;
3867
3868                                         last if $patch_idx > $#$difftree;
3869                                         $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
3870                                 }
3871                         }
3872
3873                         # modifies %from, %to hashes
3874                         parse_from_to_diffinfo($diffinfo, \%from, \%to, @hash_parents);
3875
3876                         # this is first patch for raw difftree line with $patch_idx index
3877                         # we index @$difftree array from 0, but number patches from 1
3878                         print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
3879                 }
3880
3881                 # git diff header
3882                 #assert($patch_line =~ m/^diff /) if DEBUG;
3883                 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
3884                 $patch_number++;
3885                 # print "git diff" header
3886                 print format_git_diff_header_line($patch_line, $diffinfo,
3887                                                   \%from, \%to);
3888
3889                 # print extended diff header
3890                 print "<div class=\"diff extended_header\">\n";
3891         EXTENDED_HEADER:
3892                 while ($patch_line = <$fd>) {
3893                         chomp $patch_line;
3894
3895                         last EXTENDED_HEADER if ($patch_line =~ m/^--- |^diff /);
3896
3897                         print format_extended_diff_header_line($patch_line, $diffinfo,
3898                                                                \%from, \%to);
3899                 }
3900                 print "</div>\n"; # class="diff extended_header"
3901
3902                 # from-file/to-file diff header
3903                 if (! $patch_line) {
3904                         print "</div>\n"; # class="patch"
3905                         last PATCH;
3906                 }
3907                 next PATCH if ($patch_line =~ m/^diff /);
3908                 #assert($patch_line =~ m/^---/) if DEBUG;
3909
3910                 my $last_patch_line = $patch_line;
3911                 $patch_line = <$fd>;
3912                 chomp $patch_line;
3913                 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
3914
3915                 print format_diff_from_to_header($last_patch_line, $patch_line,
3916                                                  $diffinfo, \%from, \%to,
3917                                                  @hash_parents);
3918
3919                 # the patch itself
3920         LINE:
3921                 while ($patch_line = <$fd>) {
3922                         chomp $patch_line;
3923
3924                         next PATCH if ($patch_line =~ m/^diff /);
3925
3926                         print format_diff_line($patch_line, \%from, \%to);
3927                 }
3928
3929         } continue {
3930                 print "</div>\n"; # class="patch"
3931         }
3932
3933         # for compact combined (--cc) format, with chunk and patch simpliciaction
3934         # patchset might be empty, but there might be unprocessed raw lines
3935         for (++$patch_idx if $patch_number > 0;
3936              $patch_idx < @$difftree;
3937              ++$patch_idx) {
3938                 # read and prepare patch information
3939                 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
3940
3941                 # generate anchor for "patch" links in difftree / whatchanged part
3942                 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3943                       format_diff_cc_simplified($diffinfo, @hash_parents) .
3944                       "</div>\n";  # class="patch"
3945
3946                 $patch_number++;
3947         }
3948
3949         if ($patch_number == 0) {
3950                 if (@hash_parents > 1) {
3951                         print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
3952                 } else {
3953                         print "<div class=\"diff nodifferences\">No differences found</div>\n";
3954                 }
3955         }
3956
3957         print "</div>\n"; # class="patchset"
3958 }
3959
3960 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3961
3962 # fills project list info (age, description, owner, forks) for each
3963 # project in the list, removing invalid projects from returned list
3964 # NOTE: modifies $projlist, but does not remove entries from it
3965 sub fill_project_list_info {
3966         my ($projlist, $check_forks) = @_;
3967         my @projects;
3968
3969         my $show_ctags = gitweb_check_feature('ctags');
3970  PROJECT:
3971         foreach my $pr (@$projlist) {
3972                 my (@activity) = git_get_last_activity($pr->{'path'});
3973                 unless (@activity) {
3974                         next PROJECT;
3975                 }
3976                 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
3977                 if (!defined $pr->{'descr'}) {
3978                         my $descr = git_get_project_description($pr->{'path'}) || "";
3979                         $descr = to_utf8($descr);
3980                         $pr->{'descr_long'} = $descr;
3981                         $pr->{'descr'} = chop_str($descr, $projects_list_description_width, 5);
3982                 }
3983                 if (!defined $pr->{'owner'}) {
3984                         $pr->{'owner'} = git_get_project_owner("$pr->{'path'}") || "";
3985                 }
3986                 if ($check_forks) {
3987                         my $pname = $pr->{'path'};
3988                         if (($pname =~ s/\.git$//) &&
3989                             ($pname !~ /\/$/) &&
3990                             (-d "$projectroot/$pname")) {
3991                                 $pr->{'forks'} = "-d $projectroot/$pname";
3992                         }       else {
3993                                 $pr->{'forks'} = 0;
3994                         }
3995                 }
3996                 $show_ctags and $pr->{'ctags'} = git_get_project_ctags($pr->{'path'});
3997                 push @projects, $pr;
3998         }
3999
4000         return @projects;
4001 }
4002
4003 # print 'sort by' <th> element, generating 'sort by $name' replay link
4004 # if that order is not selected
4005 sub print_sort_th {
4006         my ($name, $order, $header) = @_;
4007         $header ||= ucfirst($name);
4008
4009         if ($order eq $name) {
4010                 print "<th>$header</th>\n";
4011         } else {
4012                 print "<th>" .
4013                       $cgi->a({-href => href(-replay=>1, order=>$name),
4014                                -class => "header"}, $header) .
4015                       "</th>\n";
4016         }
4017 }
4018
4019 sub git_project_list_body {
4020         # actually uses global variable $project
4021         my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
4022
4023         my $check_forks = gitweb_check_feature('forks');
4024         my @projects = fill_project_list_info($projlist, $check_forks);
4025
4026         $order ||= $default_projects_order;
4027         $from = 0 unless defined $from;
4028         $to = $#projects if (!defined $to || $#projects < $to);
4029
4030         my %order_info = (
4031                 project => { key => 'path', type => 'str' },
4032                 descr => { key => 'descr_long', type => 'str' },
4033                 owner => { key => 'owner', type => 'str' },
4034                 age => { key => 'age', type => 'num' }
4035         );
4036         my $oi = $order_info{$order};
4037         if ($oi->{'type'} eq 'str') {
4038                 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
4039         } else {
4040                 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
4041         }
4042
4043         my $show_ctags = gitweb_check_feature('ctags');
4044         if ($show_ctags) {
4045                 my %ctags;
4046                 foreach my $p (@projects) {
4047                         foreach my $ct (keys %{$p->{'ctags'}}) {
4048                                 $ctags{$ct} += $p->{'ctags'}->{$ct};
4049                         }
4050                 }
4051                 my $cloud = git_populate_project_tagcloud(\%ctags);
4052                 print git_show_project_tagcloud($cloud, 64);
4053         }
4054
4055         print "<table class=\"project_list\">\n";
4056         unless ($no_header) {
4057                 print "<tr>\n";
4058                 if ($check_forks) {
4059                         print "<th></th>\n";
4060                 }
4061                 print_sort_th('project', $order, 'Project');
4062                 print_sort_th('descr', $order, 'Description');
4063                 print_sort_th('owner', $order, 'Owner');
4064                 print_sort_th('age', $order, 'Last Change');
4065                 print "<th></th>\n" . # for links
4066                       "</tr>\n";
4067         }
4068         my $alternate = 1;
4069         my $tagfilter = $c->req->param('by_tag');
4070         for (my $i = $from; $i <= $to; $i++) {
4071                 my $pr = $projects[$i];
4072
4073                 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
4074                 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
4075                         and not $pr->{'descr_long'} =~ /$searchtext/;
4076                 # Weed out forks or non-matching entries of search
4077                 if ($check_forks) {
4078                         my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s#\.git$#/#;
4079                         $forkbase="^$forkbase" if $forkbase;
4080                         next if not $searchtext and not $tagfilter and $show_ctags
4081                                 and $pr->{'path'} =~ m#$forkbase.*/.*#; # regexp-safe
4082                 }
4083
4084                 if ($alternate) {
4085                         print "<tr class=\"dark\">\n";
4086                 } else {
4087                         print "<tr class=\"light\">\n";
4088                 }
4089                 $alternate ^= 1;
4090                 if ($check_forks) {
4091                         print "<td>";
4092                         if ($pr->{'forks'}) {
4093                                 print "<!-- $pr->{'forks'} -->\n";
4094                                 print $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "+");
4095                         }
4096                         print "</td>\n";
4097                 }
4098                 print "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
4099                                         -class => "list"}, esc_html($pr->{'path'})) . "</td>\n" .
4100                       "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
4101                                         -class => "list", -title => $pr->{'descr_long'}},
4102                                         esc_html($pr->{'descr'})) . "</td>\n" .
4103                       "<td><i>" . chop_and_escape_str($pr->{'owner'}, 15) . "</i></td>\n";
4104                 print "<td class=\"". age_class($pr->{'age'}) . "\">" .
4105                       (defined $pr->{'age_string'} ? $pr->{'age_string'} : "No commits") . "</td>\n" .
4106                       "<td class=\"link\">" .
4107                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary")}, "summary")   . " | " .
4108                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"shortlog")}, "shortlog") . " | " .
4109                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"log")}, "log") . " | " .
4110                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"tree")}, "tree") .
4111                       ($pr->{'forks'} ? " | " . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "forks") : '') .
4112                       "</td>\n" .
4113                       "</tr>\n";
4114         }
4115         if (defined $extra) {
4116                 print "<tr>\n";
4117                 if ($check_forks) {
4118                         print "<td></td>\n";
4119                 }
4120                 print "<td colspan=\"5\">$extra</td>\n" .
4121                       "</tr>\n";
4122         }
4123         print "</table>\n";
4124 }
4125
4126 sub git_shortlog_body {
4127         # uses global variable $project
4128         my ($commitlist, $from, $to, $refs, $extra) = @_;
4129
4130         $from = 0 unless defined $from;
4131         $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4132
4133         print "<table class=\"shortlog\">\n";
4134         my $alternate = 1;
4135         for (my $i = $from; $i <= $to; $i++) {
4136                 my %co = %{$commitlist->[$i]};
4137                 my $commit = $co{'id'};
4138                 my $ref = format_ref_marker($refs, $commit);
4139                 if ($alternate) {
4140                         print "<tr class=\"dark\">\n";
4141                 } else {
4142                         print "<tr class=\"light\">\n";
4143                 }
4144                 $alternate ^= 1;
4145                 my $author = chop_and_escape_str($co{'author_name'}, 10);
4146                 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4147                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4148                       "<td><i>" . $author . "</i></td>\n" .
4149                       "<td>";
4150                 print format_subject_html($co{'title'}, $co{'title_short'},
4151                                           href(action=>"commit", hash=>$commit), $ref);
4152                 print "</td>\n" .
4153                       "<td class=\"link\">" .
4154                       $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") . " | " .
4155                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") . " | " .
4156                       $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree");
4157                 my $snapshot_links = format_snapshot_links($commit);
4158                 if (defined $snapshot_links) {
4159                         print " | " . $snapshot_links;
4160                 }
4161                 print "</td>\n" .
4162                       "</tr>\n";
4163         }
4164         if (defined $extra) {
4165                 print "<tr>\n" .
4166                       "<td colspan=\"4\">$extra</td>\n" .
4167                       "</tr>\n";
4168         }
4169         print "</table>\n";
4170 }
4171
4172 sub git_history_body {
4173         # Warning: assumes constant type (blob or tree) during history
4174         my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
4175
4176         $from = 0 unless defined $from;
4177         $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
4178
4179         print "<table class=\"history\">\n";
4180         my $alternate = 1;
4181         for (my $i = $from; $i <= $to; $i++) {
4182                 my %co = %{$commitlist->[$i]};
4183                 if (!%co) {
4184                         next;
4185                 }
4186                 my $commit = $co{'id'};
4187
4188                 my $ref = format_ref_marker($refs, $commit);
4189
4190                 if ($alternate) {
4191                         print "<tr class=\"dark\">\n";
4192                 } else {
4193                         print "<tr class=\"light\">\n";
4194                 }
4195                 $alternate ^= 1;
4196         # shortlog uses      chop_str($co{'author_name'}, 10)
4197                 my $author = chop_and_escape_str($co{'author_name'}, 15, 3);
4198                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4199                       "<td><i>" . $author . "</i></td>\n" .
4200                       "<td>";
4201                 # originally git_history used chop_str($co{'title'}, 50)
4202                 print format_subject_html($co{'title'}, $co{'title_short'},
4203                                           href(action=>"commit", hash=>$commit), $ref);
4204                 print "</td>\n" .
4205                       "<td class=\"link\">" .
4206                       $cgi->a({-href => href(action=>$ftype, hash_base=>$commit, file_name=>$file_name)}, $ftype) . " | " .
4207                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff");
4208
4209                 if ($ftype eq 'blob') {
4210                         my $blob_current = git_get_hash_by_path($hash_base, $file_name);
4211                         my $blob_parent  = git_get_hash_by_path($commit, $file_name);
4212                         if (defined $blob_current && defined $blob_parent &&
4213                                         $blob_current ne $blob_parent) {
4214                                 print " | " .
4215                                         $cgi->a({-href => href(action=>"blobdiff",
4216                                                                hash=>$blob_current, hash_parent=>$blob_parent,
4217                                                                hash_base=>$hash_base, hash_parent_base=>$commit,
4218                                                                file_name=>$file_name)},
4219                                                 "diff to current");
4220                         }
4221                 }
4222                 print "</td>\n" .
4223                       "</tr>\n";
4224         }
4225         if (defined $extra) {
4226                 print "<tr>\n" .
4227                       "<td colspan=\"4\">$extra</td>\n" .
4228                       "</tr>\n";
4229         }
4230         print "</table>\n";
4231 }
4232
4233 sub git_tags_body {
4234         # uses global variable $project
4235         my ($taglist, $from, $to, $extra) = @_;
4236         $from = 0 unless defined $from;
4237         $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
4238
4239         print "<table class=\"tags\">\n";
4240         my $alternate = 1;
4241         for (my $i = $from; $i <= $to; $i++) {
4242                 my $entry = $taglist->[$i];
4243                 my %tag = %$entry;
4244                 my $comment = $tag{'subject'};
4245                 my $comment_short;
4246                 if (defined $comment) {
4247                         $comment_short = chop_str($comment, 30, 5);
4248                 }
4249                 if ($alternate) {
4250                         print "<tr class=\"dark\">\n";
4251                 } else {
4252                         print "<tr class=\"light\">\n";
4253                 }
4254                 $alternate ^= 1;
4255                 if (defined $tag{'age'}) {
4256                         print "<td><i>$tag{'age'}</i></td>\n";
4257                 } else {
4258                         print "<td></td>\n";
4259                 }
4260                 print "<td>" .
4261                       $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'}),
4262                                -class => "list name"}, esc_html($tag{'name'})) .
4263                       "</td>\n" .
4264                       "<td>";
4265                 if (defined $comment) {
4266                         print format_subject_html($comment, $comment_short,
4267                                                   href(action=>"tag", hash=>$tag{'id'}));
4268                 }
4269                 print "</td>\n" .
4270                       "<td class=\"selflink\">";
4271                 if ($tag{'type'} eq "tag") {
4272                         print $cgi->a({-href => href(action=>"tag", hash=>$tag{'id'})}, "tag");
4273                 } else {
4274                         print "&nbsp;";
4275                 }
4276                 print "</td>\n" .
4277                       "<td class=\"link\">" . " | " .
4278                       $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'})}, $tag{'reftype'});
4279                 if ($tag{'reftype'} eq "commit") {
4280                         print " | " . $cgi->a({-href => href(action=>"shortlog", hash=>$tag{'fullname'})}, "shortlog") .
4281                               " | " . $cgi->a({-href => href(action=>"log", hash=>$tag{'fullname'})}, "log");
4282                 } elsif ($tag{'reftype'} eq "blob") {
4283                         print " | " . $cgi->a({-href => href(action=>"blob_plain", hash=>$tag{'refid'})}, "raw");
4284                 }
4285                 print "</td>\n" .
4286                       "</tr>";
4287         }
4288         if (defined $extra) {
4289                 print "<tr>\n" .
4290                       "<td colspan=\"5\">$extra</td>\n" .
4291                       "</tr>\n";
4292         }
4293         print "</table>\n";
4294 }
4295
4296 sub git_heads_body {
4297         # uses global variable $project
4298         my ($headlist, $head, $from, $to, $extra) = @_;
4299         $from = 0 unless defined $from;
4300         $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4301
4302         print "<table class=\"heads\">\n";
4303         my $alternate = 1;
4304         for (my $i = $from; $i <= $to; $i++) {
4305                 my $entry = $headlist->[$i];
4306                 my %ref = %$entry;
4307                 my $curr = $ref{'id'} eq $head;
4308                 if ($alternate) {
4309                         print "<tr class=\"dark\">\n";
4310                 } else {
4311                         print "<tr class=\"light\">\n";
4312                 }
4313                 $alternate ^= 1;
4314                 print "<td><i>$ref{'age'}</i></td>\n" .
4315                       ($curr ? "<td class=\"current_head\">" : "<td>") .
4316                       $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'}),
4317                                -class => "list name"},esc_html($ref{'name'})) .
4318                       "</td>\n" .
4319                       "<td class=\"link\">" .
4320                       $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'})}, "shortlog") . " | " .
4321                       $cgi->a({-href => href(action=>"log", hash=>$ref{'fullname'})}, "log") . " | " .
4322                       $cgi->a({-href => href(action=>"tree", hash=>$ref{'fullname'}, hash_base=>$ref{'name'})}, "tree") .
4323                       "</td>\n" .
4324                       "</tr>";
4325         }
4326         if (defined $extra) {
4327                 print "<tr>\n" .
4328                       "<td colspan=\"3\">$extra</td>\n" .
4329                       "</tr>\n";
4330         }
4331         print "</table>\n";
4332 }
4333
4334 sub git_search_grep_body {
4335         my ($commitlist, $from, $to, $extra) = @_;
4336         $from = 0 unless defined $from;
4337         $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4338
4339         print "<table class=\"commit_search\">\n";
4340         my $alternate = 1;
4341         for (my $i = $from; $i <= $to; $i++) {
4342                 my %co = %{$commitlist->[$i]};
4343                 if (!%co) {
4344                         next;
4345                 }
4346                 my $commit = $co{'id'};
4347                 if ($alternate) {
4348                         print "<tr class=\"dark\">\n";
4349                 } else {
4350                         print "<tr class=\"light\">\n";
4351                 }
4352                 $alternate ^= 1;
4353                 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
4354                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4355                       "<td><i>" . $author . "</i></td>\n" .
4356                       "<td>" .
4357                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
4358                                -class => "list subject"},
4359                               chop_and_escape_str($co{'title'}, 50) . "<br/>");
4360                 my $comment = $co{'comment'};
4361                 foreach my $line (@$comment) {
4362                         if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
4363                                 my ($lead, $match, $trail) = ($1, $2, $3);
4364                                 $match = chop_str($match, 70, 5, 'center');
4365                                 my $contextlen = int((80 - length($match))/2);
4366                                 $contextlen = 30 if ($contextlen > 30);
4367                                 $lead  = chop_str($lead,  $contextlen, 10, 'left');
4368                                 $trail = chop_str($trail, $contextlen, 10, 'right');
4369
4370                                 $lead  = esc_html($lead);
4371                                 $match = esc_html($match);
4372                                 $trail = esc_html($trail);
4373
4374                                 print "$lead<span class=\"match\">$match</span>$trail<br />";
4375                         }
4376                 }
4377                 print "</td>\n" .
4378                       "<td class=\"link\">" .
4379                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
4380                       " | " .
4381                       $cgi->a({-href => href(action=>"commitdiff", hash=>$co{'id'})}, "commitdiff") .
4382                       " | " .
4383                       $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
4384                 print "</td>\n" .
4385                       "</tr>\n";
4386         }
4387         if (defined $extra) {
4388                 print "<tr>\n" .
4389                       "<td colspan=\"3\">$extra</td>\n" .
4390                       "</tr>\n";
4391         }
4392         print "</table>\n";
4393 }
4394
4395 ## ======================================================================
4396 ## ======================================================================
4397 ## actions
4398
4399 sub git_project_list {
4400         my $order = $input_params{'order'};
4401         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4402                 die_error(400, "Unknown order parameter");
4403         }
4404
4405         my @list = git_get_projects_list();
4406         if (!@list) {
4407                 die_error(404, "No projects found");
4408         }
4409
4410         if (-f $home_text) {
4411                 print "<div class=\"index_include\">\n";
4412                 print insert_file($home_text);
4413                 print "</div>\n";
4414         }
4415         print $cgi->startform(-method => "get") .
4416               "<p class=\"projsearch\">Search:\n" .
4417               $cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
4418               "</p>" .
4419               $cgi->end_form() . "\n";
4420         git_project_list_body(\@list, $order);
4421 }
4422
4423 sub git_forks {
4424         my $order = $input_params{'order'};
4425         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4426                 die_error(400, "Unknown order parameter");
4427         }
4428
4429         my @list = git_get_projects_list($project);
4430         if (!@list) {
4431                 die_error(404, "No forks found");
4432         }
4433
4434         git_print_page_nav('','');
4435         git_print_header_div('summary', "$project forks");
4436         git_project_list_body(\@list, $order);
4437 }
4438
4439 sub git_project_index {
4440         my @projects = git_get_projects_list($project);
4441
4442         print $cgi->header(
4443                 -type => 'text/plain',
4444                 -charset => 'utf-8',
4445                 -content_disposition => 'inline; filename="index.aux"');
4446
4447         foreach my $pr (@projects) {
4448                 if (!exists $pr->{'owner'}) {
4449                         $pr->{'owner'} = git_get_project_owner("$pr->{'path'}");
4450                 }
4451
4452                 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
4453                 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
4454                 $path  =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
4455                 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
4456                 $path  =~ s/ /\+/g;
4457                 $owner =~ s/ /\+/g;
4458
4459                 print "$path $owner\n";
4460         }
4461 }
4462
4463 sub git_summary {
4464         my $descr = git_get_project_description($project) || "none";
4465         my %co = parse_commit("HEAD");
4466         my %cd = %co ? parse_date($co{'committer_epoch'}, $co{'committer_tz'}) : ();
4467         my $head = $co{'id'};
4468
4469         my $owner = git_get_project_owner($project);
4470
4471         my $refs = git_get_references();
4472         # These get_*_list functions return one more to allow us to see if
4473         # there are more ...
4474         my @taglist  = git_get_tags_list(16);
4475         my @headlist = git_get_heads_list(16);
4476         my @forklist;
4477         my $check_forks = gitweb_check_feature('forks');
4478
4479         if ($check_forks) {
4480                 @forklist = git_get_projects_list($project);
4481         }
4482
4483         git_print_page_nav('summary','', $head);
4484
4485         print "<div class=\"title\">&nbsp;</div>\n";
4486         print "<table class=\"projects_list\">\n" .
4487               "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html($descr) . "</td></tr>\n" .
4488               "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html($owner) . "</td></tr>\n";
4489         if (defined $cd{'rfc2822'}) {
4490                 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
4491         }
4492
4493         # use per project git URL list in $projectroot/$project/cloneurl
4494         # or make project git URL from git base URL and project name
4495         my $url_tag = "URL";
4496         my @url_list = git_get_project_url_list($project);
4497         @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
4498         foreach my $git_url (@url_list) {
4499                 next unless $git_url;
4500                 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
4501                 $url_tag = "";
4502         }
4503
4504         # Tag cloud
4505         my $show_ctags = gitweb_check_feature('ctags');
4506         if ($show_ctags) {
4507                 my $ctags = git_get_project_ctags($project);
4508                 my $cloud = git_populate_project_tagcloud($ctags);
4509                 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
4510                 print "</td>\n<td>" unless %$ctags;
4511                 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
4512                 print "</td>\n<td>" if %$ctags;
4513                 print git_show_project_tagcloud($cloud, 48);
4514                 print "</td></tr>";
4515         }
4516
4517         print "</table>\n";
4518
4519         # If XSS prevention is on, we don't include README.html.
4520         # TODO: Allow a readme in some safe format.
4521         if (!$prevent_xss && -s "$projectroot/$project/README.html") {
4522                 print "<div class=\"title\">readme</div>\n" .
4523                       "<div class=\"readme\">\n";
4524                 print insert_file("$projectroot/$project/README.html");
4525                 print "\n</div>\n"; # class="readme"
4526         }
4527
4528         # we need to request one more than 16 (0..15) to check if
4529         # those 16 are all
4530         my @commitlist = $head ? parse_commits($head, 17) : ();
4531         if (@commitlist) {
4532                 git_print_header_div('shortlog');
4533                 git_shortlog_body(\@commitlist, 0, 15, $refs,
4534                                   $#commitlist <=  15 ? undef :
4535                                   $cgi->a({-href => href(action=>"shortlog")}, "..."));
4536         }
4537
4538         if (@taglist) {
4539                 git_print_header_div('tags');
4540                 git_tags_body(\@taglist, 0, 15,
4541                               $#taglist <=  15 ? undef :
4542                               $cgi->a({-href => href(action=>"tags")}, "..."));
4543         }
4544
4545         if (@headlist) {
4546                 git_print_header_div('heads');
4547                 git_heads_body(\@headlist, $head, 0, 15,
4548                                $#headlist <= 15 ? undef :
4549                                $cgi->a({-href => href(action=>"heads")}, "..."));
4550         }
4551
4552         if (@forklist) {
4553                 git_print_header_div('forks');
4554                 git_project_list_body(\@forklist, 'age', 0, 15,
4555                                       $#forklist <= 15 ? undef :
4556                                       $cgi->a({-href => href(action=>"forks")}, "..."),
4557                                       'no_header');
4558         }
4559
4560 }
4561
4562 sub git_tag {
4563         my $head = git_get_head_hash($project);
4564         git_print_page_nav('','', $head,undef,$head);
4565         my %tag = parse_tag($hash);
4566
4567         if (! %tag) {
4568                 die_error(404, "Unknown tag object");
4569         }
4570
4571         git_print_header_div('commit', esc_html($tag{'name'}), $hash);
4572         print "<div class=\"title_text\">\n" .
4573               "<table class=\"object_header\">\n" .
4574               "<tr>\n" .
4575               "<td>object</td>\n" .
4576               "<td>" . $cgi->a({-class => "list", -href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
4577                                $tag{'object'}) . "</td>\n" .
4578               "<td class=\"link\">" . $cgi->a({-href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
4579                                               $tag{'type'}) . "</td>\n" .
4580               "</tr>\n";
4581         if (defined($tag{'author'})) {
4582                 my %ad = parse_date($tag{'epoch'}, $tag{'tz'});
4583                 print "<tr><td>author</td><td>" . esc_html($tag{'author'}) . "</td></tr>\n";
4584                 print "<tr><td></td><td>" . $ad{'rfc2822'} .
4585                         sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
4586                         "</td></tr>\n";
4587         }
4588         print "</table>\n\n" .
4589               "</div>\n";
4590         print "<div class=\"page_body\">";
4591         my $comment = $tag{'comment'};
4592         foreach my $line (@$comment) {
4593                 chomp $line;
4594                 print esc_html($line, -nbsp=>1) . "<br/>\n";
4595         }
4596         print "</div>\n";
4597 }
4598
4599 sub git_blame {
4600         # permissions
4601         gitweb_check_feature('blame')
4602                 or die_error(403, "Blame view not allowed");
4603
4604         # error checking
4605         die_error(400, "No file name given") unless $file_name;
4606         $hash_base ||= git_get_head_hash($project);
4607         die_error(404, "Couldn't find base commit") unless $hash_base;
4608         my %co = parse_commit($hash_base)
4609                 or die_error(404, "Commit not found");
4610         my $ftype = "blob";
4611         if (!defined $hash) {
4612                 $hash = git_get_hash_by_path($hash_base, $file_name, "blob")
4613                         or die_error(404, "Error looking up file");
4614         } else {
4615                 $ftype = git_get_type($hash);
4616                 if ($ftype !~ "blob") {
4617                         die_error(400, "Object is not a blob - $hash");
4618                 }
4619         }
4620
4621         # run git-blame --porcelain
4622         open my $fd, "-|", git_cmd(), "blame", '-p',
4623                 $hash_base, '--', $file_name
4624                 or die_error(500, "Open git-blame failed");
4625
4626         # page header
4627         my $formats_nav =
4628                 $cgi->a({-href => href(action=>"blob", -replay=>1)},
4629                         "blob") .
4630                 " | " .
4631                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4632                         "history") .
4633                 " | " .
4634                 $cgi->a({-href => href(action=>"blame", file_name=>$file_name)},
4635                         "HEAD");
4636         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4637         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
4638         git_print_page_path($file_name, $ftype, $hash_base);
4639
4640         # page body
4641         my @rev_color = qw(light2 dark2);
4642         my $num_colors = scalar(@rev_color);
4643         my $current_color = 0;
4644         my %metainfo = ();
4645
4646         print <<HTML;
4647 <div class="page_body">
4648 <table class="blame">
4649 <tr><th>Commit</th><th>Line</th><th>Data</th></tr>
4650 HTML
4651  LINE:
4652         while (my $line = <$fd>) {
4653                 chomp $line;
4654                 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
4655                 # no <lines in group> for subsequent lines in group of lines
4656                 my ($full_rev, $orig_lineno, $lineno, $group_size) =
4657                    ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
4658                 if (!exists $metainfo{$full_rev}) {
4659                         $metainfo{$full_rev} = {};
4660                 }
4661                 my $meta = $metainfo{$full_rev};
4662                 my $data;
4663                 while ($data = <$fd>) {
4664                         chomp $data;
4665                         last if ($data =~ s/^\t//); # contents of line
4666                         if ($data =~ /^(\S+) (.*)$/) {
4667                                 $meta->{$1} = $2;
4668                         }
4669                 }
4670                 my $short_rev = substr($full_rev, 0, 8);
4671                 my $author = $meta->{'author'};
4672                 my %date =
4673                         parse_date($meta->{'author-time'}, $meta->{'author-tz'});
4674                 my $date = $date{'iso-tz'};
4675                 if ($group_size) {
4676                         $current_color = ($current_color + 1) % $num_colors;
4677                 }
4678                 print "<tr id=\"l$lineno\" class=\"$rev_color[$current_color]\">\n";
4679                 if ($group_size) {
4680                         print "<td class=\"sha1\"";
4681                         print " title=\"". esc_html($author) . ", $date\"";
4682                         print " rowspan=\"$group_size\"" if ($group_size > 1);
4683                         print ">";
4684                         print $cgi->a({-href => href(action=>"commit",
4685                                                      hash=>$full_rev,
4686                                                      file_name=>$file_name)},
4687                                       esc_html($short_rev));
4688                         print "</td>\n";
4689                 }
4690                 my $parent_commit;
4691                 if (!exists $meta->{'parent'}) {
4692                         open (my $dd, "-|", git_cmd(), "rev-parse", "$full_rev^")
4693                                 or die_error(500, "Open git-rev-parse failed");
4694                         $parent_commit = <$dd>;
4695                         close $dd;
4696                         chomp($parent_commit);
4697                         $meta->{'parent'} = $parent_commit;
4698                 } else {
4699                         $parent_commit = $meta->{'parent'};
4700                 }
4701                 my $blamed = href(action => 'blame',
4702                                   file_name => $meta->{'filename'},
4703                                   hash_base => $parent_commit);
4704                 print "<td class=\"linenr\">";
4705                 print $cgi->a({ -href => "$blamed#l$orig_lineno",
4706                                 -class => "linenr" },
4707                               esc_html($lineno));
4708                 print "</td>";
4709                 print "<td class=\"pre\">" . esc_html($data) . "</td>\n";
4710                 print "</tr>\n";
4711         }
4712         print "</table>\n";
4713         print "</div>";
4714         close $fd
4715                 or print "Reading blob failed\n";
4716
4717         # page footer
4718 }
4719
4720 sub git_tags {
4721         my $head = git_get_head_hash($project);
4722         git_print_page_nav('','', $head,undef,$head);
4723         git_print_header_div('summary', $project);
4724
4725         my @tagslist = git_get_tags_list();
4726         if (@tagslist) {
4727                 git_tags_body(\@tagslist);
4728         }
4729 }
4730
4731 sub git_heads {
4732         my $head = git_get_head_hash($project);
4733         git_print_page_nav('','', $head,undef,$head);
4734         git_print_header_div('summary', $project);
4735
4736         my @headslist = git_get_heads_list();
4737         if (@headslist) {
4738                 git_heads_body(\@headslist, $head);
4739         }
4740 }
4741
4742 sub git_blob_plain {
4743         my $type = shift;
4744         my $expires;
4745
4746         if (!defined $hash) {
4747                 if (defined $file_name) {
4748                         my $base = $hash_base || git_get_head_hash($project);
4749                         $hash = git_get_hash_by_path($base, $file_name, "blob")
4750                                 or die_error(404, "Cannot find file");
4751                 } else {
4752                         die_error(400, "No file name defined");
4753                 }
4754         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4755                 # blobs defined by non-textual hash id's can be cached
4756                 $expires = "+1d";
4757         }
4758
4759         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4760                 or die_error(500, "Open git-cat-file blob '$hash' failed");
4761
4762         # content-type (can include charset)
4763         $type = blob_contenttype($fd, $file_name, $type);
4764
4765         # "save as" filename, even when no $file_name is given
4766         my $save_as = "$hash";
4767         if (defined $file_name) {
4768                 $save_as = $file_name;
4769         } elsif ($type =~ m/^text\//) {
4770                 $save_as .= '.txt';
4771         }
4772
4773         # With XSS prevention on, blobs of all types except a few known safe
4774         # ones are served with "Content-Disposition: attachment" to make sure
4775         # they don't run in our security domain.  For certain image types,
4776         # blob view writes an <img> tag referring to blob_plain view, and we
4777         # want to be sure not to break that by serving the image as an
4778         # attachment (though Firefox 3 doesn't seem to care).
4779         my $sandbox = $prevent_xss &&
4780                 $type !~ m!^(?:text/plain|image/(?:gif|png|jpeg))$!;
4781
4782         print $cgi->header(
4783                 -type => $type,
4784                 -expires => $expires,
4785                 -content_disposition =>
4786                         ($sandbox ? 'attachment' : 'inline')
4787                         . '; filename="' . $save_as . '"');
4788         undef $/;
4789         binmode STDOUT, ':raw';
4790         print <$fd>;
4791         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
4792         $/ = "\n";
4793         close $fd;
4794 }
4795
4796 sub git_blob {
4797         my $expires;
4798
4799         if (!defined $hash) {
4800                 if (defined $file_name) {
4801                         my $base = $hash_base || git_get_head_hash($project);
4802                         $hash = git_get_hash_by_path($base, $file_name, "blob")
4803                                 or die_error(404, "Cannot find file");
4804                 } else {
4805                         die_error(400, "No file name defined");
4806                 }
4807         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4808                 # blobs defined by non-textual hash id's can be cached
4809                 $expires = "+1d";
4810         }
4811
4812         my $have_blame = gitweb_check_feature('blame');
4813         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4814                 or die_error(500, "Couldn't cat $file_name, $hash");
4815         my $mimetype = blob_mimetype($fd, $file_name);
4816         if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B $fd) {
4817                 close $fd;
4818                 return git_blob_plain($mimetype);
4819         }
4820         # we can have blame only for text/* mimetype
4821         $have_blame &&= ($mimetype =~ m!^text/!);
4822
4823         my $formats_nav = '';
4824         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
4825                 if (defined $file_name) {
4826                         if ($have_blame) {
4827                                 $formats_nav .=
4828                                         $cgi->a({-href => href(action=>"blame", hash => $hash, -replay=>1)},
4829                                                 "blame") .
4830                                         " | ";
4831                         }
4832                         $formats_nav .=
4833                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4834                                         "history") .
4835                                 " | " .
4836                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
4837                                         "raw") .
4838                                 " | " .
4839                                 $cgi->a({-href => href(action=>"blob",
4840                                                        hash_base=>"HEAD", file_name=>$file_name)},
4841                                         "HEAD");
4842                 } else {
4843                         $formats_nav .=
4844                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
4845                                         "raw");
4846                 }
4847                 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4848                 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
4849         } else {
4850                 print "<div class=\"page_nav\">\n" .
4851                       "<br/><br/></div>\n" .
4852                       "<div class=\"title\">$hash</div>\n";
4853         }
4854         git_print_page_path($file_name, "blob", $hash_base);
4855         print "<div class=\"page_body\">\n";
4856         if ($mimetype =~ m!^image/!) {
4857                 print qq!<img type="$mimetype"!;
4858                 if ($file_name) {
4859                         print qq! alt="$file_name" title="$file_name"!;
4860                 }
4861                 print qq! src="! .
4862                       href(action=>"blob_plain", hash=>$hash,
4863                            hash_base=>$hash_base, file_name=>$file_name) .
4864                       qq!" />\n!;
4865         } else {
4866                 my $nr;
4867                 while (my $line = <$fd>) {
4868                         chomp $line;
4869                         $nr++;
4870                         $line = untabify($line);
4871                         printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
4872                                $nr, $nr, $nr, esc_html($line, -nbsp=>1);
4873                 }
4874         }
4875         close $fd
4876                 or print "Reading blob failed.\n";
4877         print "</div>";
4878 }
4879
4880 sub git_tree {
4881         if (!defined $hash_base) {
4882                 $hash_base = "HEAD";
4883         }
4884         if (!defined $hash) {
4885                 if (defined $file_name) {
4886                         $hash = git_get_hash_by_path($hash_base, $file_name, "tree");
4887                 } else {
4888                         $hash = $hash_base;
4889                 }
4890         }
4891         die_error(404, "No such tree") unless defined($hash);
4892         $/ = "\0";
4893         open my $fd, "-|", git_cmd(), "ls-tree", '-z', $hash
4894                 or die_error(500, "Open git-ls-tree failed");
4895         my @entries = map { chomp; $_ } <$fd>;
4896         close $fd or die_error(404, "Reading tree failed");
4897         $/ = "\n";
4898
4899         my $refs = git_get_references();
4900         my $ref = format_ref_marker($refs, $hash_base);
4901         my $basedir = '';
4902         my $have_blame = gitweb_check_feature('blame');
4903         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
4904                 my @views_nav = ();
4905                 if (defined $file_name) {
4906                         push @views_nav,
4907                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4908                                         "history"),
4909                                 $cgi->a({-href => href(action=>"tree",
4910                                                        hash_base=>"HEAD", file_name=>$file_name)},
4911                                         "HEAD"),
4912                 }
4913                 my $snapshot_links = format_snapshot_links($hash);
4914                 if (defined $snapshot_links) {
4915                         # FIXME: Should be available when we have no hash base as well.
4916                         push @views_nav, $snapshot_links;
4917                 }
4918                 git_print_page_nav('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
4919                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash_base);
4920         } else {
4921                 undef $hash_base;
4922                 print "<div class=\"page_nav\">\n";
4923                 print "<br/><br/></div>\n";
4924                 print "<div class=\"title\">$hash</div>\n";
4925         }
4926         if (defined $file_name) {
4927                 $basedir = $file_name;
4928                 if ($basedir ne '' && substr($basedir, -1) ne '/') {
4929                         $basedir .= '/';
4930                 }
4931                 git_print_page_path($file_name, 'tree', $hash_base);
4932         }
4933         print "<div class=\"page_body\">\n";
4934         print "<table class=\"tree\">\n";
4935         my $alternate = 1;
4936         # '..' (top directory) link if possible
4937         if (defined $hash_base &&
4938             defined $file_name && $file_name =~ m![^/]+$!) {
4939                 if ($alternate) {
4940                         print "<tr class=\"dark\">\n";
4941                 } else {
4942                         print "<tr class=\"light\">\n";
4943                 }
4944                 $alternate ^= 1;
4945
4946                 my $up = $file_name;
4947                 $up =~ s!/?[^/]+$!!;
4948                 undef $up unless $up;
4949                 # based on git_print_tree_entry
4950                 print '<td class="mode">' . mode_str('040000') . "</td>\n";
4951                 print '<td class="list">';
4952                 print $cgi->a({-href => href(action=>"tree", hash_base=>$hash_base,
4953                                              file_name=>$up)},
4954                               "..");
4955                 print "</td>\n";
4956                 print "<td class=\"link\"></td>\n";
4957
4958                 print "</tr>\n";
4959         }
4960         foreach my $line (@entries) {
4961                 my %t = parse_ls_tree_line($line, -z => 1);
4962
4963                 if ($alternate) {
4964                         print "<tr class=\"dark\">\n";
4965                 } else {
4966                         print "<tr class=\"light\">\n";
4967                 }
4968                 $alternate ^= 1;
4969
4970                 git_print_tree_entry(\%t, $basedir, $hash_base, $have_blame);
4971
4972                 print "</tr>\n";
4973         }
4974         print "</table>\n" .
4975               "</div>";
4976 }
4977
4978 sub git_snapshot {
4979         my $format = $input_params{'snapshot_format'};
4980         if (!@snapshot_fmts) {
4981                 die_error(403, "Snapshots not allowed");
4982         }
4983         # default to first supported snapshot format
4984         $format ||= $snapshot_fmts[0];
4985         if ($format !~ m/^[a-z0-9]+$/) {
4986                 die_error(400, "Invalid snapshot format parameter");
4987         } elsif (!exists($known_snapshot_formats{$format})) {
4988                 die_error(400, "Unknown snapshot format");
4989         } elsif (!grep($_ eq $format, @snapshot_fmts)) {
4990                 die_error(403, "Unsupported snapshot format");
4991         }
4992
4993         if (!defined $hash) {
4994                 $hash = git_get_head_hash($project);
4995         }
4996
4997         my $name = $project;
4998         $name =~ s,([^/])/*\.git$,$1,;
4999         $name = basename($name);
5000         my $filename = to_utf8($name);
5001         $name =~ s/\047/\047\\\047\047/g;
5002         my $cmd;
5003         $filename .= "-$hash$known_snapshot_formats{$format}{'suffix'}";
5004         $cmd = quote_command(
5005                 git_cmd(), 'archive',
5006                 "--format=$known_snapshot_formats{$format}{'format'}",
5007                 "--prefix=$name/", $hash);
5008         if (exists $known_snapshot_formats{$format}{'compressor'}) {
5009                 $cmd .= ' | ' . quote_command(@{$known_snapshot_formats{$format}{'compressor'}});
5010         }
5011
5012         print $cgi->header(
5013                 -type => $known_snapshot_formats{$format}{'type'},
5014                 -content_disposition => 'inline; filename="' . "$filename" . '"',
5015                 -status => '200 OK');
5016
5017         open my $fd, "-|", $cmd
5018                 or die_error(500, "Execute git-archive failed");
5019         binmode STDOUT, ':raw';
5020         print <$fd>;
5021         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
5022         close $fd;
5023 }
5024
5025 sub git_log {
5026         my $head = git_get_head_hash($project);
5027         if (!defined $hash) {
5028                 $hash = $head;
5029         }
5030         if (!defined $page) {
5031                 $page = 0;
5032         }
5033         my $refs = git_get_references();
5034
5035         my @commitlist = parse_commits($hash, 101, (100 * $page));
5036
5037         my $paging_nav = format_paging_nav('log', $hash, $head, $page, $#commitlist >= 100);
5038
5039         my ($patch_max) = gitweb_get_feature('patches');
5040         if ($patch_max) {
5041                 if ($patch_max < 0 || @commitlist <= $patch_max) {
5042                         $paging_nav .= " &sdot; " .
5043                                 $cgi->a({-href => href(action=>"patches", -replay=>1)},
5044                                         "patches");
5045                 }
5046         }
5047
5048         git_print_page_nav('log','', $hash,undef,undef, $paging_nav);
5049
5050         if (!@commitlist) {
5051                 my %co = parse_commit($hash);
5052
5053                 git_print_header_div('summary', $project);
5054                 print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
5055         }
5056         my $to = ($#commitlist >= 99) ? (99) : ($#commitlist);
5057         for (my $i = 0; $i <= $to; $i++) {
5058                 my %co = %{$commitlist[$i]};
5059                 next if !%co;
5060                 my $commit = $co{'id'};
5061                 my $ref = format_ref_marker($refs, $commit);
5062                 my %ad = parse_date($co{'author_epoch'});
5063                 git_print_header_div('commit',
5064                                "<span class=\"age\">$co{'age_string'}</span>" .
5065                                esc_html($co{'title'}) . $ref,
5066                                $commit);
5067                 print "<div class=\"title_text\">\n" .
5068                       "<div class=\"log_link\">\n" .
5069                       $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") .
5070                       " | " .
5071                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") .
5072                       " | " .
5073                       $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree") .
5074                       "<br/>\n" .
5075                       "</div>\n" .
5076                       "<i>" . esc_html($co{'author_name'}) .  " [$ad{'rfc2822'}]</i><br/>\n" .
5077                       "</div>\n";
5078
5079                 print "<div class=\"log_body\">\n";
5080                 git_print_log($co{'comment'}, -final_empty_line=> 1);
5081                 print "</div>\n";
5082         }
5083         if ($#commitlist >= 100) {
5084                 print "<div class=\"page_nav\">\n";
5085                 print $cgi->a({-href => href(-replay=>1, page=>$page+1),
5086                                -accesskey => "n", -title => "Alt-n"}, "next");
5087                 print "</div>\n";
5088         }
5089 }
5090
5091 sub git_commit {
5092         $hash ||= $hash_base || "HEAD";
5093         my %co = parse_commit($hash)
5094             or die_error(404, "Unknown commit object");
5095         my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
5096         my %cd = parse_date($co{'committer_epoch'}, $co{'committer_tz'});
5097
5098         my $parent  = $co{'parent'};
5099         my $parents = $co{'parents'}; # listref
5100
5101         # we need to prepare $formats_nav before any parameter munging
5102         my $formats_nav;
5103         if (!defined $parent) {
5104                 # --root commitdiff
5105                 $formats_nav .= '(initial)';
5106         } elsif (@$parents == 1) {
5107                 # single parent commit
5108                 $formats_nav .=
5109                         '(parent: ' .
5110                         $cgi->a({-href => href(action=>"commit",
5111                                                hash=>$parent)},
5112                                 esc_html(substr($parent, 0, 7))) .
5113                         ')';
5114         } else {
5115                 # merge commit
5116                 $formats_nav .=
5117                         '(merge: ' .
5118                         join(' ', map {
5119                                 $cgi->a({-href => href(action=>"commit",
5120                                                        hash=>$_)},
5121                                         esc_html(substr($_, 0, 7)));
5122                         } @$parents ) .
5123                         ')';
5124         }
5125         if (gitweb_check_feature('patches')) {
5126                 $formats_nav .= " | " .
5127                         $cgi->a({-href => href(action=>"patch", -replay=>1)},
5128                                 "patch");
5129         }
5130
5131         if (!defined $parent) {
5132                 $parent = "--root";
5133         }
5134         my @difftree;
5135         open my $fd, "-|", git_cmd(), "diff-tree", '-r', "--no-commit-id",
5136                 @diff_opts,
5137                 (@$parents <= 1 ? $parent : '-c'),
5138                 $hash, "--"
5139                 or die_error(500, "Open git-diff-tree failed");
5140         @difftree = map { chomp; $_ } <$fd>;
5141         close $fd or die_error(404, "Reading git-diff-tree failed");
5142
5143         # non-textual hash id's can be cached
5144         my $expires;
5145         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5146                 $expires = "+1d";
5147         }
5148         my $refs = git_get_references();
5149         my $ref = format_ref_marker($refs, $co{'id'});
5150
5151         git_print_page_nav('commit', '',
5152                            $hash, $co{'tree'}, $hash,
5153                            $formats_nav);
5154
5155         if (defined $co{'parent'}) {
5156                 git_print_header_div('commitdiff', esc_html($co{'title'}) . $ref, $hash);
5157         } else {
5158                 git_print_header_div('tree', esc_html($co{'title'}) . $ref, $co{'tree'}, $hash);
5159         }
5160         print "<div class=\"title_text\">\n" .
5161               "<table class=\"object_header\">\n";
5162         print "<tr><td>author</td><td>" . esc_html($co{'author'}) . "</td></tr>\n".
5163               "<tr>" .
5164               "<td></td><td> $ad{'rfc2822'}";
5165         if ($ad{'hour_local'} < 6) {
5166                 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
5167                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
5168         } else {
5169                 printf(" (%02d:%02d %s)",
5170                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
5171         }
5172         print "</td>" .
5173               "</tr>\n";
5174         print "<tr><td>committer</td><td>" . esc_html($co{'committer'}) . "</td></tr>\n";
5175         print "<tr><td></td><td> $cd{'rfc2822'}" .
5176               sprintf(" (%02d:%02d %s)", $cd{'hour_local'}, $cd{'minute_local'}, $cd{'tz_local'}) .
5177               "</td></tr>\n";
5178         print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
5179         print "<tr>" .
5180               "<td>tree</td>" .
5181               "<td class=\"sha1\">" .
5182               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash),
5183                        class => "list"}, $co{'tree'}) .
5184               "</td>" .
5185               "<td class=\"link\">" .
5186               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash)},
5187                       "tree");
5188         my $snapshot_links = format_snapshot_links($hash);
5189         if (defined $snapshot_links) {
5190                 print " | " . $snapshot_links;
5191         }
5192         print "</td>" .
5193               "</tr>\n";
5194
5195         foreach my $par (@$parents) {
5196                 print "<tr>" .
5197                       "<td>parent</td>" .
5198                       "<td class=\"sha1\">" .
5199                       $cgi->a({-href => href(action=>"commit", hash=>$par),
5200                                class => "list"}, $par) .
5201                       "</td>" .
5202                       "<td class=\"link\">" .
5203                       $cgi->a({-href => href(action=>"commit", hash=>$par)}, "commit") .
5204                       " | " .
5205                       $cgi->a({-href => href(action=>"commitdiff", hash=>$hash, hash_parent=>$par)}, "diff") .
5206                       "</td>" .
5207                       "</tr>\n";
5208         }
5209         print "</table>".
5210               "</div>\n";
5211
5212         print "<div class=\"page_body\">\n";
5213         git_print_log($co{'comment'});
5214         print "</div>\n";
5215
5216         git_difftree_body(\@difftree, $hash, @$parents);
5217
5218 }
5219
5220 sub git_object {
5221         # object is defined by:
5222         # - hash or hash_base alone
5223         # - hash_base and file_name
5224         my $type;
5225
5226         # - hash or hash_base alone
5227         if ($hash || ($hash_base && !defined $file_name)) {
5228                 my $object_id = $hash || $hash_base;
5229
5230                 open my $fd, "-|", quote_command(
5231                         git_cmd(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
5232                         or die_error(404, "Object does not exist");
5233                 $type = <$fd>;
5234                 chomp $type;
5235                 close $fd
5236                         or die_error(404, "Object does not exist");
5237
5238         # - hash_base and file_name
5239         } elsif ($hash_base && defined $file_name) {
5240                 $file_name =~ s,/+$,,;
5241
5242                 system(git_cmd(), "cat-file", '-e', $hash_base) == 0
5243                         or die_error(404, "Base object does not exist");
5244
5245                 # here errors should not hapen
5246                 open my $fd, "-|", git_cmd(), "ls-tree", $hash_base, "--", $file_name
5247                         or die_error(500, "Open git-ls-tree failed");
5248                 my $line = <$fd>;
5249                 close $fd;
5250
5251                 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
5252                 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
5253                         die_error(404, "File or directory for given base does not exist");
5254                 }
5255                 $type = $2;
5256                 $hash = $3;
5257         } else {
5258                 die_error(400, "Not enough information to find object");
5259         }
5260
5261         print $cgi->redirect(-uri => href(action=>$type, -full=>1,
5262                                           hash=>$hash, hash_base=>$hash_base,
5263                                           file_name=>$file_name),
5264                              -status => '302 Found');
5265 }
5266
5267 sub git_blobdiff {
5268         my $format = shift || 'html';
5269
5270         my $fd;
5271         my @difftree;
5272         my %diffinfo;
5273         my $expires;
5274
5275         # preparing $fd and %diffinfo for git_patchset_body
5276         # new style URI
5277         if (defined $hash_base && defined $hash_parent_base) {
5278                 if (defined $file_name) {
5279                         # read raw output
5280                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5281                                 $hash_parent_base, $hash_base,
5282                                 "--", (defined $file_parent ? $file_parent : ()), $file_name
5283                                 or die_error(500, "Open git-diff-tree failed");
5284                         @difftree = map { chomp; $_ } <$fd>;
5285                         close $fd
5286                                 or die_error(404, "Reading git-diff-tree failed");
5287                         @difftree
5288                                 or die_error(404, "Blob diff not found");
5289
5290                 } elsif (defined $hash &&
5291                          $hash =~ /[0-9a-fA-F]{40}/) {
5292                         # try to find filename from $hash
5293
5294                         # read filtered raw output
5295                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5296                                 $hash_parent_base, $hash_base, "--"
5297                                 or die_error(500, "Open git-diff-tree failed");
5298                         @difftree =
5299                                 # ':100644 100644 03b21826... 3b93d5e7... M     ls-files.c'
5300                                 # $hash == to_id
5301                                 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
5302                                 map { chomp; $_ } <$fd>;
5303                         close $fd
5304                                 or die_error(404, "Reading git-diff-tree failed");
5305                         @difftree
5306                                 or die_error(404, "Blob diff not found");
5307
5308                 } else {
5309                         die_error(400, "Missing one of the blob diff parameters");
5310                 }
5311
5312                 if (@difftree > 1) {
5313                         die_error(400, "Ambiguous blob diff specification");
5314                 }
5315
5316                 %diffinfo = parse_difftree_raw_line($difftree[0]);
5317                 $file_parent ||= $diffinfo{'from_file'} || $file_name;
5318                 $file_name   ||= $diffinfo{'to_file'};
5319
5320                 $hash_parent ||= $diffinfo{'from_id'};
5321                 $hash        ||= $diffinfo{'to_id'};
5322
5323                 # non-textual hash id's can be cached
5324                 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
5325                     $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
5326                         $expires = '+1d';
5327                 }
5328
5329                 # open patch output
5330                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5331                         '-p', ($format eq 'html' ? "--full-index" : ()),
5332                         $hash_parent_base, $hash_base,
5333                         "--", (defined $file_parent ? $file_parent : ()), $file_name
5334                         or die_error(500, "Open git-diff-tree failed");
5335         }
5336
5337         # old/legacy style URI -- not generated anymore since 1.4.3.
5338         if (!%diffinfo) {
5339                 die_error('404 Not Found', "Missing one of the blob diff parameters")
5340         }
5341
5342         # header
5343         if ($format eq 'html') {
5344                 my $formats_nav =
5345                         $cgi->a({-href => href(action=>"blobdiff_plain", -replay=>1)},
5346                                 "raw");
5347                 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
5348                         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5349                         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
5350                 } else {
5351                         print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
5352                         print "<div class=\"title\">$hash vs $hash_parent</div>\n";
5353                 }
5354                 if (defined $file_name) {
5355                         git_print_page_path($file_name, "blob", $hash_base);
5356                 } else {
5357                         print "<div class=\"page_path\"></div>\n";
5358                 }
5359
5360         } elsif ($format eq 'plain') {
5361                 print $cgi->header(
5362                         -type => 'text/plain',
5363                         -charset => 'utf-8',
5364                         -expires => $expires,
5365                         -content_disposition => 'inline; filename="' . "$file_name" . '.patch"');
5366
5367                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5368
5369         } else {
5370                 die_error(400, "Unknown blobdiff format");
5371         }
5372
5373         # patch
5374         if ($format eq 'html') {
5375                 print "<div class=\"page_body\">\n";
5376
5377                 git_patchset_body($fd, [ \%diffinfo ], $hash_base, $hash_parent_base);
5378                 close $fd;
5379
5380                 print "</div>\n"; # class="page_body"
5381
5382         } else {
5383                 while (my $line = <$fd>) {
5384                         $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
5385                         $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
5386
5387                         print $line;
5388
5389                         last if $line =~ m!^\+\+\+!;
5390                 }
5391                 local $/ = undef;
5392                 print <$fd>;
5393                 close $fd;
5394         }
5395 }
5396
5397 sub git_blobdiff_plain {
5398         git_blobdiff('plain');
5399 }
5400
5401 sub git_commitdiff {
5402         my %params = @_;
5403         my $format = $params{-format} || 'html';
5404
5405         my ($patch_max) = gitweb_get_feature('patches');
5406         if ($format eq 'patch') {
5407                 die_error(403, "Patch view not allowed") unless $patch_max;
5408         }
5409
5410         $hash ||= $hash_base || "HEAD";
5411         my %co = parse_commit($hash)
5412             or die_error(404, "Unknown commit object");
5413
5414         # choose format for commitdiff for merge
5415         if (! defined $hash_parent && @{$co{'parents'}} > 1) {
5416                 $hash_parent = '--cc';
5417         }
5418         # we need to prepare $formats_nav before almost any parameter munging
5419         my $formats_nav;
5420         if ($format eq 'html') {
5421                 $formats_nav =
5422                         $cgi->a({-href => href(action=>"commitdiff_plain", -replay=>1)},
5423                                 "raw");
5424                 if ($patch_max) {
5425                         $formats_nav .= " | " .
5426                                 $cgi->a({-href => href(action=>"patch", -replay=>1)},
5427                                         "patch");
5428                 }
5429
5430                 if (defined $hash_parent &&
5431                     $hash_parent ne '-c' && $hash_parent ne '--cc') {
5432                         # commitdiff with two commits given
5433                         my $hash_parent_short = $hash_parent;
5434                         if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5435                                 $hash_parent_short = substr($hash_parent, 0, 7);
5436                         }
5437                         $formats_nav .=
5438                                 ' (from';
5439                         for (my $i = 0; $i < @{$co{'parents'}}; $i++) {
5440                                 if ($co{'parents'}[$i] eq $hash_parent) {
5441                                         $formats_nav .= ' parent ' . ($i+1);
5442                                         last;
5443                                 }
5444                         }
5445                         $formats_nav .= ': ' .
5446                                 $cgi->a({-href => href(action=>"commitdiff",
5447                                                        hash=>$hash_parent)},
5448                                         esc_html($hash_parent_short)) .
5449                                 ')';
5450                 } elsif (!$co{'parent'}) {
5451                         # --root commitdiff
5452                         $formats_nav .= ' (initial)';
5453                 } elsif (scalar @{$co{'parents'}} == 1) {
5454                         # single parent commit
5455                         $formats_nav .=
5456                                 ' (parent: ' .
5457                                 $cgi->a({-href => href(action=>"commitdiff",
5458                                                        hash=>$co{'parent'})},
5459                                         esc_html(substr($co{'parent'}, 0, 7))) .
5460                                 ')';
5461                 } else {
5462                         # merge commit
5463                         if ($hash_parent eq '--cc') {
5464                                 $formats_nav .= ' | ' .
5465                                         $cgi->a({-href => href(action=>"commitdiff",
5466                                                                hash=>$hash, hash_parent=>'-c')},
5467                                                 'combined');
5468                         } else { # $hash_parent eq '-c'
5469                                 $formats_nav .= ' | ' .
5470                                         $cgi->a({-href => href(action=>"commitdiff",
5471                                                                hash=>$hash, hash_parent=>'--cc')},
5472                                                 'compact');
5473                         }
5474                         $formats_nav .=
5475                                 ' (merge: ' .
5476                                 join(' ', map {
5477                                         $cgi->a({-href => href(action=>"commitdiff",
5478                                                                hash=>$_)},
5479                                                 esc_html(substr($_, 0, 7)));
5480                                 } @{$co{'parents'}} ) .
5481                                 ')';
5482                 }
5483         }
5484
5485         my $hash_parent_param = $hash_parent;
5486         if (!defined $hash_parent_param) {
5487                 # --cc for multiple parents, --root for parentless
5488                 $hash_parent_param =
5489                         @{$co{'parents'}} > 1 ? '--cc' : $co{'parent'} || '--root';
5490         }
5491
5492         # read commitdiff
5493         my $fd;
5494         my @difftree;
5495         if ($format eq 'html') {
5496                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5497                         "--no-commit-id", "--patch-with-raw", "--full-index",
5498                         $hash_parent_param, $hash, "--"
5499                         or die_error(500, "Open git-diff-tree failed");
5500
5501                 while (my $line = <$fd>) {
5502                         chomp $line;
5503                         # empty line ends raw part of diff-tree output
5504                         last unless $line;
5505                         push @difftree, scalar parse_difftree_raw_line($line);
5506                 }
5507
5508         } elsif ($format eq 'plain') {
5509                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5510                         '-p', $hash_parent_param, $hash, "--"
5511                         or die_error(500, "Open git-diff-tree failed");
5512         } elsif ($format eq 'patch') {
5513                 # For commit ranges, we limit the output to the number of
5514                 # patches specified in the 'patches' feature.
5515                 # For single commits, we limit the output to a single patch,
5516                 # diverging from the git-format-patch default.
5517                 my @commit_spec = ();
5518                 if ($hash_parent) {
5519                         if ($patch_max > 0) {
5520                                 push @commit_spec, "-$patch_max";
5521                         }
5522                         push @commit_spec, '-n', "$hash_parent..$hash";
5523                 } else {
5524                         if ($params{-single}) {
5525                                 push @commit_spec, '-1';
5526                         } else {
5527                                 if ($patch_max > 0) {
5528                                         push @commit_spec, "-$patch_max";
5529                                 }
5530                                 push @commit_spec, "-n";
5531                         }
5532                         push @commit_spec, '--root', $hash;
5533                 }
5534                 open $fd, "-|", git_cmd(), "format-patch", '--encoding=utf8',
5535                         '--stdout', @commit_spec
5536                         or die_error(500, "Open git-format-patch failed");
5537         } else {
5538                 die_error(400, "Unknown commitdiff format");
5539         }
5540
5541         # non-textual hash id's can be cached
5542         my $expires;
5543         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5544                 $expires = "+1d";
5545         }
5546
5547         # write commit message
5548         if ($format eq 'html') {
5549                 my $refs = git_get_references();
5550                 my $ref = format_ref_marker($refs, $co{'id'});
5551
5552                 git_print_page_nav('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
5553                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash);
5554                 git_print_authorship(\%co);
5555                 print "<div class=\"page_body\">\n";
5556                 if (@{$co{'comment'}} > 1) {
5557                         print "<div class=\"log\">\n";
5558                         git_print_log($co{'comment'}, -final_empty_line=> 1, -remove_title => 1);
5559                         print "</div>\n"; # class="log"
5560                 }
5561
5562         } elsif ($format eq 'plain') {
5563                 my $refs = git_get_references("tags");
5564                 my $tagname = git_get_rev_name_tags($hash);
5565                 my $filename = basename($project) . "-$hash.patch";
5566
5567                 print $cgi->header(
5568                         -type => 'text/plain',
5569                         -charset => 'utf-8',
5570                         -expires => $expires,
5571                         -content_disposition => 'inline; filename="' . "$filename" . '"');
5572                 my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
5573                 print "From: " . to_utf8($co{'author'}) . "\n";
5574                 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
5575                 print "Subject: " . to_utf8($co{'title'}) . "\n";
5576
5577                 print "X-Git-Tag: $tagname\n" if $tagname;
5578                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5579
5580                 foreach my $line (@{$co{'comment'}}) {
5581                         print to_utf8($line) . "\n";
5582                 }
5583                 print "---\n\n";
5584         } elsif ($format eq 'patch') {
5585                 my $filename = basename($project) . "-$hash.patch";
5586
5587                 print $cgi->header(
5588                         -type => 'text/plain',
5589                         -charset => 'utf-8',
5590                         -expires => $expires,
5591                         -content_disposition => 'inline; filename="' . "$filename" . '"');
5592         }
5593
5594         # write patch
5595         if ($format eq 'html') {
5596                 my $use_parents = !defined $hash_parent ||
5597                         $hash_parent eq '-c' || $hash_parent eq '--cc';
5598                 git_difftree_body(\@difftree, $hash,
5599                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
5600                 print "<br/>\n";
5601
5602                 git_patchset_body($fd, \@difftree, $hash,
5603                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
5604                 close $fd;
5605                 print "</div>\n"; # class="page_body"
5606
5607         } elsif ($format eq 'plain') {
5608                 local $/ = undef;
5609                 print <$fd>;
5610                 close $fd
5611                         or print "Reading git-diff-tree failed\n";
5612         } elsif ($format eq 'patch') {
5613                 local $/ = undef;
5614                 print <$fd>;
5615                 close $fd
5616                         or print "Reading git-format-patch failed\n";
5617         }
5618 }
5619
5620 sub git_commitdiff_plain {
5621         git_commitdiff(-format => 'plain');
5622 }
5623
5624 # format-patch-style patches
5625 sub git_patch {
5626         git_commitdiff(-format => 'patch', -single=> 1);
5627 }
5628
5629 sub git_patches {
5630         git_commitdiff(-format => 'patch');
5631 }
5632
5633 sub git_history {
5634         if (!defined $hash_base) {
5635                 $hash_base = git_get_head_hash($project);
5636         }
5637         if (!defined $page) {
5638                 $page = 0;
5639         }
5640         my $ftype;
5641         my %co = parse_commit($hash_base)
5642             or die_error(404, "Unknown commit object");
5643
5644         my $refs = git_get_references();
5645         my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
5646
5647         my @commitlist = parse_commits($hash_base, 101, (100 * $page),
5648                                        $file_name, "--full-history")
5649             or die_error(404, "No such file or directory on given branch");
5650
5651         if (!defined $hash && defined $file_name) {
5652                 # some commits could have deleted file in question,
5653                 # and not have it in tree, but one of them has to have it
5654                 for (my $i = 0; $i <= @commitlist; $i++) {
5655                         $hash = git_get_hash_by_path($commitlist[$i]{'id'}, $file_name);
5656                         last if defined $hash;
5657                 }
5658         }
5659         if (defined $hash) {
5660                 $ftype = git_get_type($hash);
5661         }
5662         if (!defined $ftype) {
5663                 die_error(500, "Unknown type of object");
5664         }
5665
5666         my $paging_nav = '';
5667         if ($page > 0) {
5668                 $paging_nav .=
5669                         $cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base,
5670                                                file_name=>$file_name)},
5671                                 "first");
5672                 $paging_nav .= " &sdot; " .
5673                         $cgi->a({-href => href(-replay=>1, page=>$page-1),
5674                                  -accesskey => "p", -title => "Alt-p"}, "prev");
5675         } else {
5676                 $paging_nav .= "first";
5677                 $paging_nav .= " &sdot; prev";
5678         }
5679         my $next_link = '';
5680         if ($#commitlist >= 100) {
5681                 $next_link =
5682                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
5683                                  -accesskey => "n", -title => "Alt-n"}, "next");
5684                 $paging_nav .= " &sdot; $next_link";
5685         } else {
5686                 $paging_nav .= " &sdot; next";
5687         }
5688
5689         git_print_page_nav('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
5690         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
5691         git_print_page_path($file_name, $ftype, $hash_base);
5692
5693         git_history_body(\@commitlist, 0, 99,
5694                          $refs, $hash_base, $ftype, $next_link);
5695
5696 }
5697
5698 sub git_search {
5699         gitweb_check_feature('search') or die_error(403, "Search is disabled");
5700         if (!defined $searchtext) {
5701                 die_error(400, "Text field is empty");
5702         }
5703         if (!defined $hash) {
5704                 $hash = git_get_head_hash($project);
5705         }
5706         my %co = parse_commit($hash);
5707         if (!%co) {
5708                 die_error(404, "Unknown commit object");
5709         }
5710         if (!defined $page) {
5711                 $page = 0;
5712         }
5713
5714         $searchtype ||= 'commit';
5715         if ($searchtype eq 'pickaxe') {
5716                 # pickaxe may take all resources of your box and run for several minutes
5717                 # with every query - so decide by yourself how public you make this feature
5718                 gitweb_check_feature('pickaxe')
5719                     or die_error(403, "Pickaxe is disabled");
5720         }
5721         if ($searchtype eq 'grep') {
5722                 gitweb_check_feature('grep')
5723                     or die_error(403, "Grep is disabled");
5724         }
5725
5726
5727         if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
5728                 my $greptype;
5729                 if ($searchtype eq 'commit') {
5730                         $greptype = "--grep=";
5731                 } elsif ($searchtype eq 'author') {
5732                         $greptype = "--author=";
5733                 } elsif ($searchtype eq 'committer') {
5734                         $greptype = "--committer=";
5735                 }
5736                 $greptype .= $searchtext;
5737                 my @commitlist = parse_commits($hash, 101, (100 * $page), undef,
5738                                                $greptype, '--regexp-ignore-case',
5739                                                $search_use_regexp ? '--extended-regexp' : '--fixed-strings');
5740
5741                 my $paging_nav = '';
5742                 if ($page > 0) {
5743                         $paging_nav .=
5744                                 $cgi->a({-href => href(action=>"search", hash=>$hash,
5745                                                        searchtext=>$searchtext,
5746                                                        searchtype=>$searchtype)},
5747                                         "first");
5748                         $paging_nav .= " &sdot; " .
5749                                 $cgi->a({-href => href(-replay=>1, page=>$page-1),
5750                                          -accesskey => "p", -title => "Alt-p"}, "prev");
5751                 } else {
5752                         $paging_nav .= "first";
5753                         $paging_nav .= " &sdot; prev";
5754                 }
5755                 my $next_link = '';
5756                 if ($#commitlist >= 100) {
5757                         $next_link =
5758                                 $cgi->a({-href => href(-replay=>1, page=>$page+1),
5759                                          -accesskey => "n", -title => "Alt-n"}, "next");
5760                         $paging_nav .= " &sdot; $next_link";
5761                 } else {
5762                         $paging_nav .= " &sdot; next";
5763                 }
5764
5765                 if ($#commitlist >= 100) {
5766                 }
5767
5768                 git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
5769                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5770                 git_search_grep_body(\@commitlist, 0, 99, $next_link);
5771         }
5772
5773         if ($searchtype eq 'pickaxe') {
5774                 git_print_page_nav('','', $hash,$co{'tree'},$hash);
5775                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5776
5777                 print "<table class=\"pickaxe search\">\n";
5778                 my $alternate = 1;
5779                 $/ = "\n";
5780                 open my $fd, '-|', git_cmd(), '--no-pager', 'log', @diff_opts,
5781                         '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5782                         ($search_use_regexp ? '--pickaxe-regex' : ());
5783                 undef %co;
5784                 my @files;
5785                 while (my $line = <$fd>) {
5786                         chomp $line;
5787                         next unless $line;
5788
5789                         my %set = parse_difftree_raw_line($line);
5790                         if (defined $set{'commit'}) {
5791                                 # finish previous commit
5792                                 if (%co) {
5793                                         print "</td>\n" .
5794                                               "<td class=\"link\">" .
5795                                               $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5796                                               " | " .
5797                                               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5798                                         print "</td>\n" .
5799                                               "</tr>\n";
5800                                 }
5801
5802                                 if ($alternate) {
5803                                         print "<tr class=\"dark\">\n";
5804                                 } else {
5805                                         print "<tr class=\"light\">\n";
5806                                 }
5807                                 $alternate ^= 1;
5808                                 %co = parse_commit($set{'commit'});
5809                                 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
5810                                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5811                                       "<td><i>$author</i></td>\n" .
5812                                       "<td>" .
5813                                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
5814                                               -class => "list subject"},
5815                                               chop_and_escape_str($co{'title'}, 50) . "<br/>");
5816                         } elsif (defined $set{'to_id'}) {
5817                                 next if ($set{'to_id'} =~ m/^0{40}$/);
5818
5819                                 print $cgi->a({-href => href(action=>"blob", hash_base=>$co{'id'},
5820                                                              hash=>$set{'to_id'}, file_name=>$set{'to_file'}),
5821                                               -class => "list"},
5822                                               "<span class=\"match\">" . esc_path($set{'file'}) . "</span>") .
5823                                       "<br/>\n";
5824                         }
5825                 }
5826                 close $fd;
5827
5828                 # finish last commit (warning: repetition!)
5829                 if (%co) {
5830                         print "</td>\n" .
5831                               "<td class=\"link\">" .
5832                               $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5833                               " | " .
5834                               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5835                         print "</td>\n" .
5836                               "</tr>\n";
5837                 }
5838
5839                 print "</table>\n";
5840         }
5841
5842         if ($searchtype eq 'grep') {
5843                 git_print_page_nav('','', $hash,$co{'tree'},$hash);
5844                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5845
5846                 print "<table class=\"grep_search\">\n";
5847                 my $alternate = 1;
5848                 my $matches = 0;
5849                 $/ = "\n";
5850                 open my $fd, "-|", git_cmd(), 'grep', '-n',
5851                         $search_use_regexp ? ('-E', '-i') : '-F',
5852                         $searchtext, $co{'tree'};
5853                 my $lastfile = '';
5854                 while (my $line = <$fd>) {
5855                         chomp $line;
5856                         my ($file, $lno, $ltext, $binary);
5857                         last if ($matches++ > 1000);
5858                         if ($line =~ /^Binary file (.+) matches$/) {
5859                                 $file = $1;
5860                                 $binary = 1;
5861                         } else {
5862                                 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5863                         }
5864                         if ($file ne $lastfile) {
5865                                 $lastfile and print "</td></tr>\n";
5866                                 if ($alternate++) {
5867                                         print "<tr class=\"dark\">\n";
5868                                 } else {
5869                                         print "<tr class=\"light\">\n";
5870                                 }
5871                                 print "<td class=\"list\">".
5872                                         $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5873                                                                file_name=>"$file"),
5874                                                 -class => "list"}, esc_path($file));
5875                                 print "</td><td>\n";
5876                                 $lastfile = $file;
5877                         }
5878                         if ($binary) {
5879                                 print "<div class=\"binary\">Binary file</div>\n";
5880                         } else {
5881                                 $ltext = untabify($ltext);
5882                                 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5883                                         $ltext = esc_html($1, -nbsp=>1);
5884                                         $ltext .= '<span class="match">';
5885                                         $ltext .= esc_html($2, -nbsp=>1);
5886                                         $ltext .= '</span>';
5887                                         $ltext .= esc_html($3, -nbsp=>1);
5888                                 } else {
5889                                         $ltext = esc_html($ltext, -nbsp=>1);
5890                                 }
5891                                 print "<div class=\"pre\">" .
5892                                         $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5893                                                                file_name=>"$file").'#l'.$lno,
5894                                                 -class => "linenr"}, sprintf('%4i', $lno))
5895                                         . ' ' .  $ltext . "</div>\n";
5896                         }
5897                 }
5898                 if ($lastfile) {
5899                         print "</td></tr>\n";
5900                         if ($matches > 1000) {
5901                                 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5902                         }
5903                 } else {
5904                         print "<div class=\"diff nodifferences\">No matches found</div>\n";
5905                 }
5906                 close $fd;
5907
5908                 print "</table>\n";
5909         }
5910 }
5911
5912 sub git_search_help {
5913         git_print_page_nav('','', $hash,$hash,$hash);
5914         print <<EOT;
5915 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
5916 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
5917 the pattern entered is recognized as the POSIX extended
5918 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
5919 insensitive).</p>
5920 <dl>
5921 <dt><b>commit</b></dt>
5922 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
5923 EOT
5924         my $have_grep = gitweb_check_feature('grep');
5925         if ($have_grep) {
5926                 print <<EOT;
5927 <dt><b>grep</b></dt>
5928 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
5929     a different one) are searched for the given pattern. On large trees, this search can take
5930 a while and put some strain on the server, so please use it with some consideration. Note that
5931 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
5932 case-sensitive.</dd>
5933 EOT
5934         }
5935         print <<EOT;
5936 <dt><b>author</b></dt>
5937 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
5938 <dt><b>committer</b></dt>
5939 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
5940 EOT
5941         my $have_pickaxe = gitweb_check_feature('pickaxe');
5942         if ($have_pickaxe) {
5943                 print <<EOT;
5944 <dt><b>pickaxe</b></dt>
5945 <dd>All commits that caused the string to appear or disappear from any file (changes that
5946 added, removed or "modified" the string) will be listed. This search can take a while and
5947 takes a lot of strain on the server, so please use it wisely. Note that since you may be
5948 interested even in changes just changing the case as well, this search is case sensitive.</dd>
5949 EOT
5950         }
5951         print "</dl>\n";
5952 }
5953
5954 sub git_shortlog {
5955         my $head = git_get_head_hash($project);
5956         if (!defined $hash) {
5957                 $hash = $head;
5958         }
5959         if (!defined $page) {
5960                 $page = 0;
5961         }
5962         my $refs = git_get_references();
5963
5964         my $commit_hash = $hash;
5965         if (defined $hash_parent) {
5966                 $commit_hash = "$hash_parent..$hash";
5967         }
5968         my @commitlist = parse_commits($commit_hash, 101, (100 * $page));
5969
5970         my $paging_nav = format_paging_nav('shortlog', $hash, $head, $page, $#commitlist >= 100);
5971         my $next_link = '';
5972         if ($#commitlist >= 100) {
5973                 $next_link =
5974                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
5975                                  -accesskey => "n", -title => "Alt-n"}, "next");
5976         }
5977         my $patch_max = gitweb_check_feature('patches');
5978         if ($patch_max) {
5979                 if ($patch_max < 0 || @commitlist <= $patch_max) {
5980                         $paging_nav .= " &sdot; " .
5981                                 $cgi->a({-href => href(action=>"patches", -replay=>1)},
5982                                         "patches");
5983                 }
5984         }
5985
5986         git_print_page_nav('shortlog','', $hash,$hash,$hash, $paging_nav);
5987         git_print_header_div('summary', $project);
5988
5989         git_shortlog_body(\@commitlist, 0, 99, $refs, $next_link);
5990
5991 }
5992
5993 ## ......................................................................
5994 ## feeds (RSS, Atom; OPML)
5995
5996 # XXX This does header stuff which may not play nice with Catalyst, so likely
5997 # broken in some/many ways.
5998 sub git_feed {
5999         my $format = shift || 'atom';
6000         my $have_blame = gitweb_check_feature('blame');
6001
6002         # Atom: http://www.atomenabled.org/developers/syndication/
6003         # RSS:  http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
6004         if ($format ne 'rss' && $format ne 'atom') {
6005                 die_error(400, "Unknown web feed format");
6006         }
6007
6008         # log/feed of current (HEAD) branch, log of given branch, history of file/directory
6009         my $head = $hash || 'HEAD';
6010         my @commitlist = parse_commits($head, 150, 0, $file_name);
6011
6012         my %latest_commit;
6013         my %latest_date;
6014         my $content_type = "application/$format+xml";
6015         if (defined $cgi->http('HTTP_ACCEPT') &&
6016                  $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
6017                 # browser (feed reader) prefers text/xml
6018                 $content_type = 'text/xml';
6019         }
6020         if (defined($commitlist[0])) {
6021                 %latest_commit = %{$commitlist[0]};
6022                 my $latest_epoch = $latest_commit{'committer_epoch'};
6023                 %latest_date   = parse_date($latest_epoch);
6024                 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
6025                 if (defined $if_modified) {
6026                         my $since;
6027                         if (eval { require HTTP::Date; 1; }) {
6028                                 $since = HTTP::Date::str2time($if_modified);
6029                         } elsif (eval { require Time::ParseDate; 1; }) {
6030                                 $since = Time::ParseDate::parsedate($if_modified, GMT => 1);
6031                         }
6032                         if (defined $since && $latest_epoch <= $since) {
6033                                 print $cgi->header(
6034                                         -type => $content_type,
6035                                         -charset => 'utf-8',
6036                                         -last_modified => $latest_date{'rfc2822'},
6037                                         -status => '304 Not Modified');
6038                                 return;
6039                         }
6040                 }
6041                 print $cgi->header(
6042                         -type => $content_type,
6043                         -charset => 'utf-8',
6044                         -last_modified => $latest_date{'rfc2822'});
6045         } else {
6046                 print $cgi->header(
6047                         -type => $content_type,
6048                         -charset => 'utf-8');
6049         }
6050
6051         # Optimization: skip generating the body if client asks only
6052         # for Last-Modified date.
6053         return if ($cgi->request_method() eq 'HEAD');
6054
6055         # header variables
6056         my $title = "$site_name - $project/$action";
6057         my $feed_type = 'log';
6058         if (defined $hash) {
6059                 $title .= " - '$hash'";
6060                 $feed_type = 'branch log';
6061                 if (defined $file_name) {
6062                         $title .= " :: $file_name";
6063                         $feed_type = 'history';
6064                 }
6065         } elsif (defined $file_name) {
6066                 $title .= " - $file_name";
6067                 $feed_type = 'history';
6068         }
6069         $title .= " $feed_type";
6070         my $descr = git_get_project_description($project);
6071         if (defined $descr) {
6072                 $descr = esc_html($descr);
6073         } else {
6074                 $descr = "$project " .
6075                          ($format eq 'rss' ? 'RSS' : 'Atom') .
6076                          " feed";
6077         }
6078         my $owner = git_get_project_owner($project);
6079         $owner = esc_html($owner);
6080
6081         #header
6082         my $alt_url;
6083         if (defined $file_name) {
6084                 $alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
6085         } elsif (defined $hash) {
6086                 $alt_url = href(-full=>1, action=>"log", hash=>$hash);
6087         } else {
6088                 $alt_url = href(-full=>1, action=>"summary");
6089         }
6090         print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
6091         if ($format eq 'rss') {
6092                 print <<XML;
6093 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
6094 <channel>
6095 XML
6096                 print "<title>$title</title>\n" .
6097                       "<link>$alt_url</link>\n" .
6098                       "<description>$descr</description>\n" .
6099                       "<language>en</language>\n" .
6100                       # project owner is responsible for 'editorial' content
6101                       "<managingEditor>$owner</managingEditor>\n";
6102                 if (defined $logo || defined $favicon) {
6103                         # prefer the logo to the favicon, since RSS
6104                         # doesn't allow both
6105                         my $img = esc_url($logo || $favicon);
6106                         print "<image>\n" .
6107                               "<url>$img</url>\n" .
6108                               "<title>$title</title>\n" .
6109                               "<link>$alt_url</link>\n" .
6110                               "</image>\n";
6111                 }
6112                 if (%latest_date) {
6113                         print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
6114                         print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
6115                 }
6116                 print "<generator>gitweb v.$version/$git_version</generator>\n";
6117         } elsif ($format eq 'atom') {
6118                 print <<XML;
6119 <feed xmlns="http://www.w3.org/2005/Atom">
6120 XML
6121                 print "<title>$title</title>\n" .
6122                       "<subtitle>$descr</subtitle>\n" .
6123                       '<link rel="alternate" type="text/html" href="' .
6124                       $alt_url . '" />' . "\n" .
6125                       '<link rel="self" type="' . $content_type . '" href="' .
6126                       $cgi->self_url() . '" />' . "\n" .
6127                       "<id>" . href(-full=>1) . "</id>\n" .
6128                       # use project owner for feed author
6129                       "<author><name>$owner</name></author>\n";
6130                 if (defined $favicon) {
6131                         print "<icon>" . esc_url($favicon) . "</icon>\n";
6132                 }
6133                 if (defined $logo_url) {
6134                         # not twice as wide as tall: 72 x 27 pixels
6135                         print "<logo>" . esc_url($logo) . "</logo>\n";
6136                 }
6137                 if (! %latest_date) {
6138                         # dummy date to keep the feed valid until commits trickle in:
6139                         print "<updated>1970-01-01T00:00:00Z</updated>\n";
6140                 } else {
6141                         print "<updated>$latest_date{'iso-8601'}</updated>\n";
6142                 }
6143                 print "<generator version='$version/$git_version'>gitweb</generator>\n";
6144         }
6145
6146         # contents
6147         for (my $i = 0; $i <= $#commitlist; $i++) {
6148                 my %co = %{$commitlist[$i]};
6149                 my $commit = $co{'id'};
6150                 # we read 150, we always show 30 and the ones more recent than 48 hours
6151                 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
6152                         last;
6153                 }
6154                 my %cd = parse_date($co{'author_epoch'});
6155
6156                 # get list of changed files
6157                 open my $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6158                         $co{'parent'} || "--root",
6159                         $co{'id'}, "--", (defined $file_name ? $file_name : ())
6160                         or next;
6161                 my @difftree = map { chomp; $_ } <$fd>;
6162                 close $fd
6163                         or next;
6164
6165                 # print element (entry, item)
6166                 my $co_url = href(-full=>1, action=>"commitdiff", hash=>$commit);
6167                 if ($format eq 'rss') {
6168                         print "<item>\n" .
6169                               "<title>" . esc_html($co{'title'}) . "</title>\n" .
6170                               "<author>" . esc_html($co{'author'}) . "</author>\n" .
6171                               "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
6172                               "<guid isPermaLink=\"true\">$co_url</guid>\n" .
6173                               "<link>$co_url</link>\n" .
6174                               "<description>" . esc_html($co{'title'}) . "</description>\n" .
6175                               "<content:encoded>" .
6176                               "<![CDATA[\n";
6177                 } elsif ($format eq 'atom') {
6178                         print "<entry>\n" .
6179                               "<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
6180                               "<updated>$cd{'iso-8601'}</updated>\n" .
6181                               "<author>\n" .
6182                               "  <name>" . esc_html($co{'author_name'}) . "</name>\n";
6183                         if ($co{'author_email'}) {
6184                                 print "  <email>" . esc_html($co{'author_email'}) . "</email>\n";
6185                         }
6186                         print "</author>\n" .
6187                               # use committer for contributor
6188                               "<contributor>\n" .
6189                               "  <name>" . esc_html($co{'committer_name'}) . "</name>\n";
6190                         if ($co{'committer_email'}) {
6191                                 print "  <email>" . esc_html($co{'committer_email'}) . "</email>\n";
6192                         }
6193                         print "</contributor>\n" .
6194                               "<published>$cd{'iso-8601'}</published>\n" .
6195                               "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
6196                               "<id>$co_url</id>\n" .
6197                               "<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
6198                               "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
6199                 }
6200                 my $comment = $co{'comment'};
6201                 print "<pre>\n";
6202                 foreach my $line (@$comment) {
6203                         $line = esc_html($line);
6204                         print "$line\n";
6205                 }
6206                 print "</pre><ul>\n";
6207                 foreach my $difftree_line (@difftree) {
6208                         my %difftree = parse_difftree_raw_line($difftree_line);
6209                         next if !$difftree{'from_id'};
6210
6211                         my $file = $difftree{'file'} || $difftree{'to_file'};
6212
6213                         print "<li>" .
6214                               "[" .
6215                               $cgi->a({-href => href(-full=>1, action=>"blobdiff",
6216                                                      hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
6217                                                      hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
6218                                                      file_name=>$file, file_parent=>$difftree{'from_file'}),
6219                                       -title => "diff"}, 'D');
6220                         if ($have_blame) {
6221                                 print $cgi->a({-href => href(-full=>1, action=>"blame",
6222                                                              file_name=>$file, hash_base=>$commit),
6223                                               -title => "blame"}, 'B');
6224                         }
6225                         # if this is not a feed of a file history
6226                         if (!defined $file_name || $file_name ne $file) {
6227                                 print $cgi->a({-href => href(-full=>1, action=>"history",
6228                                                              file_name=>$file, hash=>$commit),
6229                                               -title => "history"}, 'H');
6230                         }
6231                         $file = esc_path($file);
6232                         print "] ".
6233                               "$file</li>\n";
6234                 }
6235                 if ($format eq 'rss') {
6236                         print "</ul>]]>\n" .
6237                               "</content:encoded>\n" .
6238                               "</item>\n";
6239                 } elsif ($format eq 'atom') {
6240                         print "</ul>\n</div>\n" .
6241                               "</content>\n" .
6242                               "</entry>\n";
6243                 }
6244         }
6245
6246         # end of feed
6247         if ($format eq 'rss') {
6248                 print "</channel>\n</rss>\n";
6249         }       elsif ($format eq 'atom') {
6250                 print "</feed>\n";
6251         }
6252 }
6253
6254 sub git_rss {
6255         git_feed('rss');
6256 }
6257
6258 sub git_atom {
6259         git_feed('atom');
6260 }
6261
6262 sub git_opml {
6263         my @list = git_get_projects_list();
6264
6265         print $cgi->header(
6266                 -type => 'text/xml',
6267                 -charset => 'utf-8',
6268                 -content_disposition => 'inline; filename="opml.xml"');
6269
6270         print <<XML;
6271 <?xml version="1.0" encoding="utf-8"?>
6272 <opml version="1.0">
6273 <head>
6274   <title>$site_name OPML Export</title>
6275 </head>
6276 <body>
6277 <outline text="git RSS feeds">
6278 XML
6279
6280         foreach my $pr (@list) {
6281                 my %proj = %$pr;
6282                 my $head = git_get_head_hash($proj{'path'});
6283                 if (!defined $head) {
6284                         next;
6285                 }
6286                 $git_dir = "$projectroot/$proj{'path'}";
6287                 my %co = parse_commit($head);
6288                 if (!%co) {
6289                         next;
6290                 }
6291
6292                 my $path = esc_html(chop_str($proj{'path'}, 25, 5));
6293                 my $rss  = href('project' => $proj{'path'}, 'action' => 'rss', -full => 1);
6294                 my $html = href('project' => $proj{'path'}, 'action' => 'summary', -full => 1);
6295                 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";
6296         }
6297         print <<XML;
6298 </outline>
6299 </body>
6300 </opml>
6301 XML
6302 }
6303
6304 1;