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