gitweb/gitweb.perl

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