gitweb/gitweb.perl

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