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