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