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