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