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