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