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_header_html();
5549
5550         git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
5551         git_print_header_div('commit', esc_html($co{'title'}), $hash);
5552         if ($page == 0 && !@commitlist) {
5553                 print "<p>No match.</p>\n";
5554         } else {
5555                 git_search_grep_body(\@commitlist, 0, 99, $next_link);
5556         }
5557
5558         git_footer_html();
5559 }
5560
5561 sub git_search_changes {
5562         my %co = @_;
5563
5564         local $/ = "\n";
5565         open my $fd, '-|', git_cmd(), '--no-pager', 'log', @diff_opts,
5566                 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5567                 ($search_use_regexp ? '--pickaxe-regex' : ())
5568                         or die_error(500, "Open git-log failed");
5569
5570         git_header_html();
5571
5572         git_print_page_nav('','', $hash,$co{'tree'},$hash);
5573         git_print_header_div('commit', esc_html($co{'title'}), $hash);
5574
5575         print "<table class=\"pickaxe search\">\n";
5576         my $alternate = 1;
5577         undef %co;
5578         my @files;
5579         while (my $line = <$fd>) {
5580                 chomp $line;
5581                 next unless $line;
5582
5583                 my %set = parse_difftree_raw_line($line);
5584                 if (defined $set{'commit'}) {
5585                         # finish previous commit
5586                         if (%co) {
5587                                 print "</td>\n" .
5588                                       "<td class=\"link\">" .
5589                                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})},
5590                                               "commit") .
5591                                       " | " .
5592                                       $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'},
5593                                                              hash_base=>$co{'id'})},
5594                                               "tree") .
5595                                       "</td>\n" .
5596                                       "</tr>\n";
5597                         }
5598
5599                         if ($alternate) {
5600                                 print "<tr class=\"dark\">\n";
5601                         } else {
5602                                 print "<tr class=\"light\">\n";
5603                         }
5604                         $alternate ^= 1;
5605                         %co = parse_commit($set{'commit'});
5606                         my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
5607                         print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5608                               "<td><i>$author</i></td>\n" .
5609                               "<td>" .
5610                               $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
5611                                       -class => "list subject"},
5612                                       chop_and_escape_str($co{'title'}, 50) . "<br/>");
5613                 } elsif (defined $set{'to_id'}) {
5614                         next if ($set{'to_id'} =~ m/^0{40}$/);
5615
5616                         print $cgi->a({-href => href(action=>"blob", hash_base=>$co{'id'},
5617                                                      hash=>$set{'to_id'}, file_name=>$set{'to_file'}),
5618                                       -class => "list"},
5619                                       "<span class=\"match\">" . esc_path($set{'file'}) . "</span>") .
5620                               "<br/>\n";
5621                 }
5622         }
5623         close $fd;
5624
5625         # finish last commit (warning: repetition!)
5626         if (%co) {
5627                 print "</td>\n" .
5628                       "<td class=\"link\">" .
5629                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})},
5630                               "commit") .
5631                       " | " .
5632                       $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'},
5633                                              hash_base=>$co{'id'})},
5634                               "tree") .
5635                       "</td>\n" .
5636                       "</tr>\n";
5637         }
5638
5639         print "</table>\n";
5640
5641         git_footer_html();
5642 }
5643
5644 sub git_search_files {
5645         my %co = @_;
5646
5647         local $/ = "\n";
5648         open my $fd, "-|", git_cmd(), 'grep', '-n',
5649                 $search_use_regexp ? ('-E', '-i') : '-F',
5650                 $searchtext, $co{'tree'}
5651                         or die_error(500, "Open git-grep failed");
5652
5653         git_header_html();
5654
5655         git_print_page_nav('','', $hash,$co{'tree'},$hash);
5656         git_print_header_div('commit', esc_html($co{'title'}), $hash);
5657
5658         print "<table class=\"grep_search\">\n";
5659         my $alternate = 1;
5660         my $matches = 0;
5661         my $lastfile = '';
5662         while (my $line = <$fd>) {
5663                 chomp $line;
5664                 my ($file, $lno, $ltext, $binary);
5665                 last if ($matches++ > 1000);
5666                 if ($line =~ /^Binary file (.+) matches$/) {
5667                         $file = $1;
5668                         $binary = 1;
5669                 } else {
5670                         (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5671                 }
5672                 if ($file ne $lastfile) {
5673                         $lastfile and print "</td></tr>\n";
5674                         if ($alternate++) {
5675                                 print "<tr class=\"dark\">\n";
5676                         } else {
5677                                 print "<tr class=\"light\">\n";
5678                         }
5679                         print "<td class=\"list\">".
5680                                 $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5681                                                        file_name=>"$file"),
5682                                         -class => "list"}, esc_path($file));
5683                         print "</td><td>\n";
5684                         $lastfile = $file;
5685                 }
5686                 if ($binary) {
5687                         print "<div class=\"binary\">Binary file</div>\n";
5688                 } else {
5689                         $ltext = untabify($ltext);
5690                         if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5691                                 $ltext = esc_html($1, -nbsp=>1);
5692                                 $ltext .= '<span class="match">';
5693                                 $ltext .= esc_html($2, -nbsp=>1);
5694                                 $ltext .= '</span>';
5695                                 $ltext .= esc_html($3, -nbsp=>1);
5696                         } else {
5697                                 $ltext = esc_html($ltext, -nbsp=>1);
5698                         }
5699                         print "<div class=\"pre\">" .
5700                                 $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5701                                                        file_name=>"$file").'#l'.$lno,
5702                                         -class => "linenr"}, sprintf('%4i', $lno))
5703                                 . ' ' .  $ltext . "</div>\n";
5704                 }
5705         }
5706         if ($lastfile) {
5707                 print "</td></tr>\n";
5708                 if ($matches > 1000) {
5709                         print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5710                 }
5711         } else {
5712                 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5713         }
5714         close $fd;
5715
5716         print "</table>\n";
5717
5718         git_footer_html();
5719 }
5720
5721 sub git_search_grep_body {
5722         my ($commitlist, $from, $to, $extra) = @_;
5723         $from = 0 unless defined $from;
5724         $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5725
5726         print "<table class=\"commit_search\">\n";
5727         my $alternate = 1;
5728         for (my $i = $from; $i <= $to; $i++) {
5729                 my %co = %{$commitlist->[$i]};
5730                 if (!%co) {
5731                         next;
5732                 }
5733                 my $commit = $co{'id'};
5734                 if ($alternate) {
5735                         print "<tr class=\"dark\">\n";
5736                 } else {
5737                         print "<tr class=\"light\">\n";
5738                 }
5739                 $alternate ^= 1;
5740                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5741                       format_author_html('td', \%co, 15, 5) .
5742                       "<td>" .
5743                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
5744                                -class => "list subject"},
5745                               chop_and_escape_str($co{'title'}, 50) . "<br/>");
5746                 my $comment = $co{'comment'};
5747                 foreach my $line (@$comment) {
5748                         if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5749                                 my ($lead, $match, $trail) = ($1, $2, $3);
5750                                 $match = chop_str($match, 70, 5, 'center');
5751                                 my $contextlen = int((80 - length($match))/2);
5752                                 $contextlen = 30 if ($contextlen > 30);
5753                                 $lead  = chop_str($lead,  $contextlen, 10, 'left');
5754                                 $trail = chop_str($trail, $contextlen, 10, 'right');
5755
5756                                 $lead  = esc_html($lead);
5757                                 $match = esc_html($match);
5758                                 $trail = esc_html($trail);
5759
5760                                 print "$lead<span class=\"match\">$match</span>$trail<br />";
5761                         }
5762                 }
5763                 print "</td>\n" .
5764                       "<td class=\"link\">" .
5765                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5766                       " | " .
5767                       $cgi->a({-href => href(action=>"commitdiff", hash=>$co{'id'})}, "commitdiff") .
5768                       " | " .
5769                       $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5770                 print "</td>\n" .
5771                       "</tr>\n";
5772         }
5773         if (defined $extra) {
5774                 print "<tr>\n" .
5775                       "<td colspan=\"3\">$extra</td>\n" .
5776                       "</tr>\n";
5777         }
5778         print "</table>\n";
5779 }
5780
5781 ## ======================================================================
5782 ## ======================================================================
5783 ## actions
5784
5785 sub git_project_list {
5786         my $order = $input_params{'order'};
5787         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5788                 die_error(400, "Unknown order parameter");
5789         }
5790
5791         my @list = git_get_projects_list();
5792         if (!@list) {
5793                 die_error(404, "No projects found");
5794         }
5795
5796         git_header_html();
5797         if (defined $home_text && -f $home_text) {
5798                 print "<div class=\"index_include\">\n";
5799                 insert_file($home_text);
5800                 print "</div>\n";
5801         }
5802         print $cgi->startform(-method => "get") .
5803               "<p class=\"projsearch\">Search:\n" .
5804               $cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
5805               "</p>" .
5806               $cgi->end_form() . "\n";
5807         git_project_list_body(\@list, $order);
5808         git_footer_html();
5809 }
5810
5811 sub git_forks {
5812         my $order = $input_params{'order'};
5813         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5814                 die_error(400, "Unknown order parameter");
5815         }
5816
5817         my @list = git_get_projects_list($project);
5818         if (!@list) {
5819                 die_error(404, "No forks found");
5820         }
5821
5822         git_header_html();
5823         git_print_page_nav('','');
5824         git_print_header_div('summary', "$project forks");
5825         git_project_list_body(\@list, $order);
5826         git_footer_html();
5827 }
5828
5829 sub git_project_index {
5830         my @projects = git_get_projects_list();
5831         if (!@projects) {
5832                 die_error(404, "No projects found");
5833         }
5834
5835         print $cgi->header(
5836                 -type => 'text/plain',
5837                 -charset => 'utf-8',
5838                 -content_disposition => 'inline; filename="index.aux"');
5839
5840         foreach my $pr (@projects) {
5841                 if (!exists $pr->{'owner'}) {
5842                         $pr->{'owner'} = git_get_project_owner("$pr->{'path'}");
5843                 }
5844
5845                 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
5846                 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
5847                 $path  =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
5848                 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
5849                 $path  =~ s/ /\+/g;
5850                 $owner =~ s/ /\+/g;
5851
5852                 print "$path $owner\n";
5853         }
5854 }
5855
5856 sub git_summary {
5857         my $descr = git_get_project_description($project) || "none";
5858         my %co = parse_commit("HEAD");
5859         my %cd = %co ? parse_date($co{'committer_epoch'}, $co{'committer_tz'}) : ();
5860         my $head = $co{'id'};
5861         my $remote_heads = gitweb_check_feature('remote_heads');
5862
5863         my $owner = git_get_project_owner($project);
5864
5865         my $refs = git_get_references();
5866         # These get_*_list functions return one more to allow us to see if
5867         # there are more ...
5868         my @taglist  = git_get_tags_list(16);
5869         my @headlist = git_get_heads_list(16);
5870         my %remotedata = $remote_heads ? git_get_remotes_list() : ();
5871         my @forklist;
5872         my $check_forks = gitweb_check_feature('forks');
5873
5874         if ($check_forks) {
5875                 # find forks of a project
5876                 @forklist = git_get_projects_list($project);
5877                 # filter out forks of forks
5878                 @forklist = filter_forks_from_projects_list(\@forklist)
5879                         if (@forklist);
5880         }
5881
5882         git_header_html();
5883         git_print_page_nav('summary','', $head);
5884
5885         print "<div class=\"title\">&nbsp;</div>\n";
5886         print "<table class=\"projects_list\">\n" .
5887               "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html($descr) . "</td></tr>\n" .
5888               "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html($owner) . "</td></tr>\n";
5889         if (defined $cd{'rfc2822'}) {
5890                 print "<tr id=\"metadata_lchange\"><td>last change</td>" .
5891                       "<td>".format_timestamp_html(\%cd)."</td></tr>\n";
5892         }
5893
5894         # use per project git URL list in $projectroot/$project/cloneurl
5895         # or make project git URL from git base URL and project name
5896         my $url_tag = "URL";
5897         my @url_list = git_get_project_url_list($project);
5898         @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
5899         foreach my $git_url (@url_list) {
5900                 next unless $git_url;
5901                 print format_repo_url($url_tag, $git_url);
5902                 $url_tag = "";
5903         }
5904
5905         # Tag cloud
5906         my $show_ctags = gitweb_check_feature('ctags');
5907         if ($show_ctags) {
5908                 my $ctags = git_get_project_ctags($project);
5909                 if (%$ctags) {
5910                         # without ability to add tags, don't show if there are none
5911                         my $cloud = git_populate_project_tagcloud($ctags);
5912                         print "<tr id=\"metadata_ctags\">" .
5913                               "<td>content tags</td>" .
5914                               "<td>".git_show_project_tagcloud($cloud, 48)."</td>" .
5915                               "</tr>\n";
5916                 }
5917         }
5918
5919         print "</table>\n";
5920
5921         # If XSS prevention is on, we don't include README.html.
5922         # TODO: Allow a readme in some safe format.
5923         if (!$prevent_xss && -s "$projectroot/$project/README.html") {
5924                 print "<div class=\"title\">readme</div>\n" .
5925                       "<div class=\"readme\">\n";
5926                 insert_file("$projectroot/$project/README.html");
5927                 print "\n</div>\n"; # class="readme"
5928         }
5929
5930         # we need to request one more than 16 (0..15) to check if
5931         # those 16 are all
5932         my @commitlist = $head ? parse_commits($head, 17) : ();
5933         if (@commitlist) {
5934                 git_print_header_div('shortlog');
5935                 git_shortlog_body(\@commitlist, 0, 15, $refs,
5936                                   $#commitlist <=  15 ? undef :
5937                                   $cgi->a({-href => href(action=>"shortlog")}, "..."));
5938         }
5939
5940         if (@taglist) {
5941                 git_print_header_div('tags');
5942                 git_tags_body(\@taglist, 0, 15,
5943                               $#taglist <=  15 ? undef :
5944                               $cgi->a({-href => href(action=>"tags")}, "..."));
5945         }
5946
5947         if (@headlist) {
5948                 git_print_header_div('heads');
5949                 git_heads_body(\@headlist, $head, 0, 15,
5950                                $#headlist <= 15 ? undef :
5951                                $cgi->a({-href => href(action=>"heads")}, "..."));
5952         }
5953
5954         if (%remotedata) {
5955                 git_print_header_div('remotes');
5956                 git_remotes_body(\%remotedata, 15, $head);
5957         }
5958
5959         if (@forklist) {
5960                 git_print_header_div('forks');
5961                 git_project_list_body(\@forklist, 'age', 0, 15,
5962                                       $#forklist <= 15 ? undef :
5963                                       $cgi->a({-href => href(action=>"forks")}, "..."),
5964                                       'no_header');
5965         }
5966
5967         git_footer_html();
5968 }
5969
5970 sub git_tag {
5971         my %tag = parse_tag($hash);
5972
5973         if (! %tag) {
5974                 die_error(404, "Unknown tag object");
5975         }
5976
5977         my $head = git_get_head_hash($project);
5978         git_header_html();
5979         git_print_page_nav('','', $head,undef,$head);
5980         git_print_header_div('commit', esc_html($tag{'name'}), $hash);
5981         print "<div class=\"title_text\">\n" .
5982               "<table class=\"object_header\">\n" .
5983               "<tr>\n" .
5984               "<td>object</td>\n" .
5985               "<td>" . $cgi->a({-class => "list", -href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
5986                                $tag{'object'}) . "</td>\n" .
5987               "<td class=\"link\">" . $cgi->a({-href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
5988                                               $tag{'type'}) . "</td>\n" .
5989               "</tr>\n";
5990         if (defined($tag{'author'})) {
5991                 git_print_authorship_rows(\%tag, 'author');
5992         }
5993         print "</table>\n\n" .
5994               "</div>\n";
5995         print "<div class=\"page_body\">";
5996         my $comment = $tag{'comment'};
5997         foreach my $line (@$comment) {
5998                 chomp $line;
5999                 print esc_html($line, -nbsp=>1) . "<br/>\n";
6000         }
6001         print "</div>\n";
6002         git_footer_html();
6003 }
6004
6005 sub git_blame_common {
6006         my $format = shift || 'porcelain';
6007         if ($format eq 'porcelain' && $cgi->param('js')) {
6008                 $format = 'incremental';
6009                 $action = 'blame_incremental'; # for page title etc
6010         }
6011
6012         # permissions
6013         gitweb_check_feature('blame')
6014                 or die_error(403, "Blame view not allowed");
6015
6016         # error checking
6017         die_error(400, "No file name given") unless $file_name;
6018         $hash_base ||= git_get_head_hash($project);
6019         die_error(404, "Couldn't find base commit") unless $hash_base;
6020         my %co = parse_commit($hash_base)
6021                 or die_error(404, "Commit not found");
6022         my $ftype = "blob";
6023         if (!defined $hash) {
6024                 $hash = git_get_hash_by_path($hash_base, $file_name, "blob")
6025                         or die_error(404, "Error looking up file");
6026         } else {
6027                 $ftype = git_get_type($hash);
6028                 if ($ftype !~ "blob") {
6029                         die_error(400, "Object is not a blob");
6030                 }
6031         }
6032
6033         my $fd;
6034         if ($format eq 'incremental') {
6035                 # get file contents (as base)
6036                 open $fd, "-|", git_cmd(), 'cat-file', 'blob', $hash
6037                         or die_error(500, "Open git-cat-file failed");
6038         } elsif ($format eq 'data') {
6039                 # run git-blame --incremental
6040                 open $fd, "-|", git_cmd(), "blame", "--incremental",
6041                         $hash_base, "--", $file_name
6042                         or die_error(500, "Open git-blame --incremental failed");
6043         } else {
6044                 # run git-blame --porcelain
6045                 open $fd, "-|", git_cmd(), "blame", '-p',
6046                         $hash_base, '--', $file_name
6047                         or die_error(500, "Open git-blame --porcelain failed");
6048         }
6049
6050         # incremental blame data returns early
6051         if ($format eq 'data') {
6052                 print $cgi->header(
6053                         -type=>"text/plain", -charset => "utf-8",
6054                         -status=> "200 OK");
6055                 local $| = 1; # output autoflush
6056                 print while <$fd>;
6057                 close $fd
6058                         or print "ERROR $!\n";
6059
6060                 print 'END';
6061                 if (defined $t0 && gitweb_check_feature('timed')) {
6062                         print ' '.
6063                               tv_interval($t0, [ gettimeofday() ]).
6064                               ' '.$number_of_git_cmds;
6065                 }
6066                 print "\n";
6067
6068                 return;
6069         }
6070
6071         # page header
6072         git_header_html();
6073         my $formats_nav =
6074                 $cgi->a({-href => href(action=>"blob", -replay=>1)},
6075                         "blob") .
6076                 " | ";
6077         if ($format eq 'incremental') {
6078                 $formats_nav .=
6079                         $cgi->a({-href => href(action=>"blame", javascript=>0, -replay=>1)},
6080                                 "blame") . " (non-incremental)";
6081         } else {
6082                 $formats_nav .=
6083                         $cgi->a({-href => href(action=>"blame_incremental", -replay=>1)},
6084                                 "blame") . " (incremental)";
6085         }
6086         $formats_nav .=
6087                 " | " .
6088                 $cgi->a({-href => href(action=>"history", -replay=>1)},
6089                         "history") .
6090                 " | " .
6091                 $cgi->a({-href => href(action=>$action, file_name=>$file_name)},
6092                         "HEAD");
6093         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6094         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
6095         git_print_page_path($file_name, $ftype, $hash_base);
6096
6097         # page body
6098         if ($format eq 'incremental') {
6099                 print "<noscript>\n<div class=\"error\"><center><b>\n".
6100                       "This page requires JavaScript to run.\n Use ".
6101                       $cgi->a({-href => href(action=>'blame',javascript=>0,-replay=>1)},
6102                               'this page').
6103                       " instead.\n".
6104                       "</b></center></div>\n</noscript>\n";
6105
6106                 print qq!<div id="progress_bar" style="width: 100%; background-color: yellow"></div>\n!;
6107         }
6108
6109         print qq!<div class="page_body">\n!;
6110         print qq!<div id="progress_info">... / ...</div>\n!
6111                 if ($format eq 'incremental');
6112         print qq!<table id="blame_table" class="blame" width="100%">\n!.
6113               #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
6114               qq!<thead>\n!.
6115               qq!<tr><th>Commit</th><th>Line</th><th>Data</th></tr>\n!.
6116               qq!</thead>\n!.
6117               qq!<tbody>\n!;
6118
6119         my @rev_color = qw(light dark);
6120         my $num_colors = scalar(@rev_color);
6121         my $current_color = 0;
6122
6123         if ($format eq 'incremental') {
6124                 my $color_class = $rev_color[$current_color];
6125
6126                 #contents of a file
6127                 my $linenr = 0;
6128         LINE:
6129                 while (my $line = <$fd>) {
6130                         chomp $line;
6131                         $linenr++;
6132
6133                         print qq!<tr id="l$linenr" class="$color_class">!.
6134                               qq!<td class="sha1"><a href=""> </a></td>!.
6135                               qq!<td class="linenr">!.
6136                               qq!<a class="linenr" href="">$linenr</a></td>!;
6137                         print qq!<td class="pre">! . esc_html($line) . "</td>\n";
6138                         print qq!</tr>\n!;
6139                 }
6140
6141         } else { # porcelain, i.e. ordinary blame
6142                 my %metainfo = (); # saves information about commits
6143
6144                 # blame data
6145         LINE:
6146                 while (my $line = <$fd>) {
6147                         chomp $line;
6148                         # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
6149                         # no <lines in group> for subsequent lines in group of lines
6150                         my ($full_rev, $orig_lineno, $lineno, $group_size) =
6151                            ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
6152                         if (!exists $metainfo{$full_rev}) {
6153                                 $metainfo{$full_rev} = { 'nprevious' => 0 };
6154                         }
6155                         my $meta = $metainfo{$full_rev};
6156                         my $data;
6157                         while ($data = <$fd>) {
6158                                 chomp $data;
6159                                 last if ($data =~ s/^\t//); # contents of line
6160                                 if ($data =~ /^(\S+)(?: (.*))?$/) {
6161                                         $meta->{$1} = $2 unless exists $meta->{$1};
6162                                 }
6163                                 if ($data =~ /^previous /) {
6164                                         $meta->{'nprevious'}++;
6165                                 }
6166                         }
6167                         my $short_rev = substr($full_rev, 0, 8);
6168                         my $author = $meta->{'author'};
6169                         my %date =
6170                                 parse_date($meta->{'author-time'}, $meta->{'author-tz'});
6171                         my $date = $date{'iso-tz'};
6172                         if ($group_size) {
6173                                 $current_color = ($current_color + 1) % $num_colors;
6174                         }
6175                         my $tr_class = $rev_color[$current_color];
6176                         $tr_class .= ' boundary' if (exists $meta->{'boundary'});
6177                         $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
6178                         $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
6179                         print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
6180                         if ($group_size) {
6181                                 print "<td class=\"sha1\"";
6182                                 print " title=\"". esc_html($author) . ", $date\"";
6183                                 print " rowspan=\"$group_size\"" if ($group_size > 1);
6184                                 print ">";
6185                                 print $cgi->a({-href => href(action=>"commit",
6186                                                              hash=>$full_rev,
6187                                                              file_name=>$file_name)},
6188                                               esc_html($short_rev));
6189                                 if ($group_size >= 2) {
6190                                         my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
6191                                         if (@author_initials) {
6192                                                 print "<br />" .
6193                                                       esc_html(join('', @author_initials));
6194                                                 #           or join('.', ...)
6195                                         }
6196                                 }
6197                                 print "</td>\n";
6198                         }
6199                         # 'previous' <sha1 of parent commit> <filename at commit>
6200                         if (exists $meta->{'previous'} &&
6201                             $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
6202                                 $meta->{'parent'} = $1;
6203                                 $meta->{'file_parent'} = unquote($2);
6204                         }
6205                         my $linenr_commit =
6206                                 exists($meta->{'parent'}) ?
6207                                 $meta->{'parent'} : $full_rev;
6208                         my $linenr_filename =
6209                                 exists($meta->{'file_parent'}) ?
6210                                 $meta->{'file_parent'} : unquote($meta->{'filename'});
6211                         my $blamed = href(action => 'blame',
6212                                           file_name => $linenr_filename,
6213                                           hash_base => $linenr_commit);
6214                         print "<td class=\"linenr\">";
6215                         print $cgi->a({ -href => "$blamed#l$orig_lineno",
6216                                         -class => "linenr" },
6217                                       esc_html($lineno));
6218                         print "</td>";
6219                         print "<td class=\"pre\">" . esc_html($data) . "</td>\n";
6220                         print "</tr>\n";
6221                 } # end while
6222
6223         }
6224
6225         # footer
6226         print "</tbody>\n".
6227               "</table>\n"; # class="blame"
6228         print "</div>\n";   # class="blame_body"
6229         close $fd
6230                 or print "Reading blob failed\n";
6231
6232         git_footer_html();
6233 }
6234
6235 sub git_blame {
6236         git_blame_common();
6237 }
6238
6239 sub git_blame_incremental {
6240         git_blame_common('incremental');
6241 }
6242
6243 sub git_blame_data {
6244         git_blame_common('data');
6245 }
6246
6247 sub git_tags {
6248         my $head = git_get_head_hash($project);
6249         git_header_html();
6250         git_print_page_nav('','', $head,undef,$head,format_ref_views('tags'));
6251         git_print_header_div('summary', $project);
6252
6253         my @tagslist = git_get_tags_list();
6254         if (@tagslist) {
6255                 git_tags_body(\@tagslist);
6256         }
6257         git_footer_html();
6258 }
6259
6260 sub git_heads {
6261         my $head = git_get_head_hash($project);
6262         git_header_html();
6263         git_print_page_nav('','', $head,undef,$head,format_ref_views('heads'));
6264         git_print_header_div('summary', $project);
6265
6266         my @headslist = git_get_heads_list();
6267         if (@headslist) {
6268                 git_heads_body(\@headslist, $head);
6269         }
6270         git_footer_html();
6271 }
6272
6273 # used both for single remote view and for list of all the remotes
6274 sub git_remotes {
6275         gitweb_check_feature('remote_heads')
6276                 or die_error(403, "Remote heads view is disabled");
6277
6278         my $head = git_get_head_hash($project);
6279         my $remote = $input_params{'hash'};
6280
6281         my $remotedata = git_get_remotes_list($remote);
6282         die_error(500, "Unable to get remote information") unless defined $remotedata;
6283
6284         unless (%$remotedata) {
6285                 die_error(404, defined $remote ?
6286                         "Remote $remote not found" :
6287                         "No remotes found");
6288         }
6289
6290         git_header_html(undef, undef, -action_extra => $remote);
6291         git_print_page_nav('', '',  $head, undef, $head,
6292                 format_ref_views($remote ? '' : 'remotes'));
6293
6294         fill_remote_heads($remotedata);
6295         if (defined $remote) {
6296                 git_print_header_div('remotes', "$remote remote for $project");
6297                 git_remote_block($remote, $remotedata->{$remote}, undef, $head);
6298         } else {
6299                 git_print_header_div('summary', "$project remotes");
6300                 git_remotes_body($remotedata, undef, $head);
6301         }
6302
6303         git_footer_html();
6304 }
6305
6306 sub git_blob_plain {
6307         my $type = shift;
6308         my $expires;
6309
6310         if (!defined $hash) {
6311                 if (defined $file_name) {
6312                         my $base = $hash_base || git_get_head_hash($project);
6313                         $hash = git_get_hash_by_path($base, $file_name, "blob")
6314                                 or die_error(404, "Cannot find file");
6315                 } else {
6316                         die_error(400, "No file name defined");
6317                 }
6318         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6319                 # blobs defined by non-textual hash id's can be cached
6320                 $expires = "+1d";
6321         }
6322
6323         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
6324                 or die_error(500, "Open git-cat-file blob '$hash' failed");
6325
6326         # content-type (can include charset)
6327         $type = blob_contenttype($fd, $file_name, $type);
6328
6329         # "save as" filename, even when no $file_name is given
6330         my $save_as = "$hash";
6331         if (defined $file_name) {
6332                 $save_as = $file_name;
6333         } elsif ($type =~ m/^text\//) {
6334                 $save_as .= '.txt';
6335         }
6336
6337         # With XSS prevention on, blobs of all types except a few known safe
6338         # ones are served with "Content-Disposition: attachment" to make sure
6339         # they don't run in our security domain.  For certain image types,
6340         # blob view writes an <img> tag referring to blob_plain view, and we
6341         # want to be sure not to break that by serving the image as an
6342         # attachment (though Firefox 3 doesn't seem to care).
6343         my $sandbox = $prevent_xss &&
6344                 $type !~ m!^(?:text/plain|image/(?:gif|png|jpeg))(?:[ ;]|$)!;
6345
6346         print $cgi->header(
6347                 -type => $type,
6348                 -expires => $expires,
6349                 -content_disposition =>
6350                         ($sandbox ? 'attachment' : 'inline')
6351                         . '; filename="' . $save_as . '"');
6352         local $/ = undef;
6353         binmode STDOUT, ':raw';
6354         print <$fd>;
6355         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
6356         close $fd;
6357 }
6358
6359 sub git_blob {
6360         my $expires;
6361
6362         if (!defined $hash) {
6363                 if (defined $file_name) {
6364                         my $base = $hash_base || git_get_head_hash($project);
6365                         $hash = git_get_hash_by_path($base, $file_name, "blob")
6366                                 or die_error(404, "Cannot find file");
6367                 } else {
6368                         die_error(400, "No file name defined");
6369                 }
6370         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6371                 # blobs defined by non-textual hash id's can be cached
6372                 $expires = "+1d";
6373         }
6374
6375         my $have_blame = gitweb_check_feature('blame');
6376         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
6377                 or die_error(500, "Couldn't cat $file_name, $hash");
6378         my $mimetype = blob_mimetype($fd, $file_name);
6379         # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
6380         if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B $fd) {
6381                 close $fd;
6382                 return git_blob_plain($mimetype);
6383         }
6384         # we can have blame only for text/* mimetype
6385         $have_blame &&= ($mimetype =~ m!^text/!);
6386
6387         my $highlight = gitweb_check_feature('highlight');
6388         my $syntax = guess_file_syntax($highlight, $mimetype, $file_name);
6389         $fd = run_highlighter($fd, $highlight, $syntax)
6390                 if $syntax;
6391
6392         git_header_html(undef, $expires);
6393         my $formats_nav = '';
6394         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
6395                 if (defined $file_name) {
6396                         if ($have_blame) {
6397                                 $formats_nav .=
6398                                         $cgi->a({-href => href(action=>"blame", -replay=>1)},
6399                                                 "blame") .
6400                                         " | ";
6401                         }
6402                         $formats_nav .=
6403                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
6404                                         "history") .
6405                                 " | " .
6406                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
6407                                         "raw") .
6408                                 " | " .
6409                                 $cgi->a({-href => href(action=>"blob",
6410                                                        hash_base=>"HEAD", file_name=>$file_name)},
6411                                         "HEAD");
6412                 } else {
6413                         $formats_nav .=
6414                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
6415                                         "raw");
6416                 }
6417                 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6418                 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
6419         } else {
6420                 print "<div class=\"page_nav\">\n" .
6421                       "<br/><br/></div>\n" .
6422                       "<div class=\"title\">".esc_html($hash)."</div>\n";
6423         }
6424         git_print_page_path($file_name, "blob", $hash_base);
6425         print "<div class=\"page_body\">\n";
6426         if ($mimetype =~ m!^image/!) {
6427                 print qq!<img type="!.esc_attr($mimetype).qq!"!;
6428                 if ($file_name) {
6429                         print qq! alt="!.esc_attr($file_name).qq!" title="!.esc_attr($file_name).qq!"!;
6430                 }
6431                 print qq! src="! .
6432                       href(action=>"blob_plain", hash=>$hash,
6433                            hash_base=>$hash_base, file_name=>$file_name) .
6434                       qq!" />\n!;
6435         } else {
6436                 my $nr;
6437                 while (my $line = <$fd>) {
6438                         chomp $line;
6439                         $nr++;
6440                         $line = untabify($line);
6441                         printf qq!<div class="pre"><a id="l%i" href="%s#l%i" class="linenr">%4i</a> %s</div>\n!,
6442                                $nr, href(-replay => 1), $nr, $nr, $syntax ? $line : esc_html($line, -nbsp=>1);
6443                 }
6444         }
6445         close $fd
6446                 or print "Reading blob failed.\n";
6447         print "</div>";
6448         git_footer_html();
6449 }
6450
6451 sub git_tree {
6452         if (!defined $hash_base) {
6453                 $hash_base = "HEAD";
6454         }
6455         if (!defined $hash) {
6456                 if (defined $file_name) {
6457                         $hash = git_get_hash_by_path($hash_base, $file_name, "tree");
6458                 } else {
6459                         $hash = $hash_base;
6460                 }
6461         }
6462         die_error(404, "No such tree") unless defined($hash);
6463
6464         my $show_sizes = gitweb_check_feature('show-sizes');
6465         my $have_blame = gitweb_check_feature('blame');
6466
6467         my @entries = ();
6468         {
6469                 local $/ = "\0";
6470                 open my $fd, "-|", git_cmd(), "ls-tree", '-z',
6471                         ($show_sizes ? '-l' : ()), @extra_options, $hash
6472                         or die_error(500, "Open git-ls-tree failed");
6473                 @entries = map { chomp; $_ } <$fd>;
6474                 close $fd
6475                         or die_error(404, "Reading tree failed");
6476         }
6477
6478         my $refs = git_get_references();
6479         my $ref = format_ref_marker($refs, $hash_base);
6480         git_header_html();
6481         my $basedir = '';
6482         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
6483                 my @views_nav = ();
6484                 if (defined $file_name) {
6485                         push @views_nav,
6486                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
6487                                         "history"),
6488                                 $cgi->a({-href => href(action=>"tree",
6489                                                        hash_base=>"HEAD", file_name=>$file_name)},
6490                                         "HEAD"),
6491                 }
6492                 my $snapshot_links = format_snapshot_links($hash);
6493                 if (defined $snapshot_links) {
6494                         # FIXME: Should be available when we have no hash base as well.
6495                         push @views_nav, $snapshot_links;
6496                 }
6497                 git_print_page_nav('tree','', $hash_base, undef, undef,
6498                                    join(' | ', @views_nav));
6499                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash_base);
6500         } else {
6501                 undef $hash_base;
6502                 print "<div class=\"page_nav\">\n";
6503                 print "<br/><br/></div>\n";
6504                 print "<div class=\"title\">".esc_html($hash)."</div>\n";
6505         }
6506         if (defined $file_name) {
6507                 $basedir = $file_name;
6508                 if ($basedir ne '' && substr($basedir, -1) ne '/') {
6509                         $basedir .= '/';
6510                 }
6511                 git_print_page_path($file_name, 'tree', $hash_base);
6512         }
6513         print "<div class=\"page_body\">\n";
6514         print "<table class=\"tree\">\n";
6515         my $alternate = 1;
6516         # '..' (top directory) link if possible
6517         if (defined $hash_base &&
6518             defined $file_name && $file_name =~ m![^/]+$!) {
6519                 if ($alternate) {
6520                         print "<tr class=\"dark\">\n";
6521                 } else {
6522                         print "<tr class=\"light\">\n";
6523                 }
6524                 $alternate ^= 1;
6525
6526                 my $up = $file_name;
6527                 $up =~ s!/?[^/]+$!!;
6528                 undef $up unless $up;
6529                 # based on git_print_tree_entry
6530                 print '<td class="mode">' . mode_str('040000') . "</td>\n";
6531                 print '<td class="size">&nbsp;</td>'."\n" if $show_sizes;
6532                 print '<td class="list">';
6533                 print $cgi->a({-href => href(action=>"tree",
6534                                              hash_base=>$hash_base,
6535                                              file_name=>$up)},
6536                               "..");
6537                 print "</td>\n";
6538                 print "<td class=\"link\"></td>\n";
6539
6540                 print "</tr>\n";
6541         }
6542         foreach my $line (@entries) {
6543                 my %t = parse_ls_tree_line($line, -z => 1, -l => $show_sizes);
6544
6545                 if ($alternate) {
6546                         print "<tr class=\"dark\">\n";
6547                 } else {
6548                         print "<tr class=\"light\">\n";
6549                 }
6550                 $alternate ^= 1;
6551
6552                 git_print_tree_entry(\%t, $basedir, $hash_base, $have_blame);
6553
6554                 print "</tr>\n";
6555         }
6556         print "</table>\n" .
6557               "</div>";
6558         git_footer_html();
6559 }
6560
6561 sub snapshot_name {
6562         my ($project, $hash) = @_;
6563
6564         # path/to/project.git  -> project
6565         # path/to/project/.git -> project
6566         my $name = to_utf8($project);
6567         $name =~ s,([^/])/*\.git$,$1,;
6568         $name = basename($name);
6569         # sanitize name
6570         $name =~ s/[[:cntrl:]]/?/g;
6571
6572         my $ver = $hash;
6573         if ($hash =~ /^[0-9a-fA-F]+$/) {
6574                 # shorten SHA-1 hash
6575                 my $full_hash = git_get_full_hash($project, $hash);
6576                 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
6577                         $ver = git_get_short_hash($project, $hash);
6578                 }
6579         } elsif ($hash =~ m!^refs/tags/(.*)$!) {
6580                 # tags don't need shortened SHA-1 hash
6581                 $ver = $1;
6582         } else {
6583                 # branches and other need shortened SHA-1 hash
6584                 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
6585                         $ver = $1;
6586                 }
6587                 $ver .= '-' . git_get_short_hash($project, $hash);
6588         }
6589         # in case of hierarchical branch names
6590         $ver =~ s!/!.!g;
6591
6592         # name = project-version_string
6593         $name = "$name-$ver";
6594
6595         return wantarray ? ($name, $name) : $name;
6596 }
6597
6598 sub git_snapshot {
6599         my $format = $input_params{'snapshot_format'};
6600         if (!@snapshot_fmts) {
6601                 die_error(403, "Snapshots not allowed");
6602         }
6603         # default to first supported snapshot format
6604         $format ||= $snapshot_fmts[0];
6605         if ($format !~ m/^[a-z0-9]+$/) {
6606                 die_error(400, "Invalid snapshot format parameter");
6607         } elsif (!exists($known_snapshot_formats{$format})) {
6608                 die_error(400, "Unknown snapshot format");
6609         } elsif ($known_snapshot_formats{$format}{'disabled'}) {
6610                 die_error(403, "Snapshot format not allowed");
6611         } elsif (!grep($_ eq $format, @snapshot_fmts)) {
6612                 die_error(403, "Unsupported snapshot format");
6613         }
6614
6615         my $type = git_get_type("$hash^{}");
6616         if (!$type) {
6617                 die_error(404, 'Object does not exist');
6618         }  elsif ($type eq 'blob') {
6619                 die_error(400, 'Object is not a tree-ish');
6620         }
6621
6622         my ($name, $prefix) = snapshot_name($project, $hash);
6623         my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
6624         my $cmd = quote_command(
6625                 git_cmd(), 'archive',
6626                 "--format=$known_snapshot_formats{$format}{'format'}",
6627                 "--prefix=$prefix/", $hash);
6628         if (exists $known_snapshot_formats{$format}{'compressor'}) {
6629                 $cmd .= ' | ' . quote_command(@{$known_snapshot_formats{$format}{'compressor'}});
6630         }
6631
6632         $filename =~ s/(["\\])/\\$1/g;
6633         print $cgi->header(
6634                 -type => $known_snapshot_formats{$format}{'type'},
6635                 -content_disposition => 'inline; filename="' . $filename . '"',
6636                 -status => '200 OK');
6637
6638         open my $fd, "-|", $cmd
6639                 or die_error(500, "Execute git-archive failed");
6640         binmode STDOUT, ':raw';
6641         print <$fd>;
6642         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
6643         close $fd;
6644 }
6645
6646 sub git_log_generic {
6647         my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
6648
6649         my $head = git_get_head_hash($project);
6650         if (!defined $base) {
6651                 $base = $head;
6652         }
6653         if (!defined $page) {
6654                 $page = 0;
6655         }
6656         my $refs = git_get_references();
6657
6658         my $commit_hash = $base;
6659         if (defined $parent) {
6660                 $commit_hash = "$parent..$base";
6661         }
6662         my @commitlist =
6663                 parse_commits($commit_hash, 101, (100 * $page),
6664                               defined $file_name ? ($file_name, "--full-history") : ());
6665
6666         my $ftype;
6667         if (!defined $file_hash && defined $file_name) {
6668                 # some commits could have deleted file in question,
6669                 # and not have it in tree, but one of them has to have it
6670                 for (my $i = 0; $i < @commitlist; $i++) {
6671                         $file_hash = git_get_hash_by_path($commitlist[$i]{'id'}, $file_name);
6672                         last if defined $file_hash;
6673                 }
6674         }
6675         if (defined $file_hash) {
6676                 $ftype = git_get_type($file_hash);
6677         }
6678         if (defined $file_name && !defined $ftype) {
6679                 die_error(500, "Unknown type of object");
6680         }
6681         my %co;
6682         if (defined $file_name) {
6683                 %co = parse_commit($base)
6684                         or die_error(404, "Unknown commit object");
6685         }
6686
6687
6688         my $paging_nav = format_paging_nav($fmt_name, $page, $#commitlist >= 100);
6689         my $next_link = '';
6690         if ($#commitlist >= 100) {
6691                 $next_link =
6692                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
6693                                  -accesskey => "n", -title => "Alt-n"}, "next");
6694         }
6695         my $patch_max = gitweb_get_feature('patches');
6696         if ($patch_max && !defined $file_name) {
6697                 if ($patch_max < 0 || @commitlist <= $patch_max) {
6698                         $paging_nav .= " &sdot; " .
6699                                 $cgi->a({-href => href(action=>"patches", -replay=>1)},
6700                                         "patches");
6701                 }
6702         }
6703
6704         git_header_html();
6705         git_print_page_nav($fmt_name,'', $hash,$hash,$hash, $paging_nav);
6706         if (defined $file_name) {
6707                 git_print_header_div('commit', esc_html($co{'title'}), $base);
6708         } else {
6709                 git_print_header_div('summary', $project)
6710         }
6711         git_print_page_path($file_name, $ftype, $hash_base)
6712                 if (defined $file_name);
6713
6714         $body_subr->(\@commitlist, 0, 99, $refs, $next_link,
6715                      $file_name, $file_hash, $ftype);
6716
6717         git_footer_html();
6718 }
6719
6720 sub git_log {
6721         git_log_generic('log', \&git_log_body,
6722                         $hash, $hash_parent);
6723 }
6724
6725 sub git_commit {
6726         $hash ||= $hash_base || "HEAD";
6727         my %co = parse_commit($hash)
6728             or die_error(404, "Unknown commit object");
6729
6730         my $parent  = $co{'parent'};
6731         my $parents = $co{'parents'}; # listref
6732
6733         # we need to prepare $formats_nav before any parameter munging
6734         my $formats_nav;
6735         if (!defined $parent) {
6736                 # --root commitdiff
6737                 $formats_nav .= '(initial)';
6738         } elsif (@$parents == 1) {
6739                 # single parent commit
6740                 $formats_nav .=
6741                         '(parent: ' .
6742                         $cgi->a({-href => href(action=>"commit",
6743                                                hash=>$parent)},
6744                                 esc_html(substr($parent, 0, 7))) .
6745                         ')';
6746         } else {
6747                 # merge commit
6748                 $formats_nav .=
6749                         '(merge: ' .
6750                         join(' ', map {
6751                                 $cgi->a({-href => href(action=>"commit",
6752                                                        hash=>$_)},
6753                                         esc_html(substr($_, 0, 7)));
6754                         } @$parents ) .
6755                         ')';
6756         }
6757         if (gitweb_check_feature('patches') && @$parents <= 1) {
6758                 $formats_nav .= " | " .
6759                         $cgi->a({-href => href(action=>"patch", -replay=>1)},
6760                                 "patch");
6761         }
6762
6763         if (!defined $parent) {
6764                 $parent = "--root";
6765         }
6766         my @difftree;
6767         open my $fd, "-|", git_cmd(), "diff-tree", '-r', "--no-commit-id",
6768                 @diff_opts,
6769                 (@$parents <= 1 ? $parent : '-c'),
6770                 $hash, "--"
6771                 or die_error(500, "Open git-diff-tree failed");
6772         @difftree = map { chomp; $_ } <$fd>;
6773         close $fd or die_error(404, "Reading git-diff-tree failed");
6774
6775         # non-textual hash id's can be cached
6776         my $expires;
6777         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6778                 $expires = "+1d";
6779         }
6780         my $refs = git_get_references();
6781         my $ref = format_ref_marker($refs, $co{'id'});
6782
6783         git_header_html(undef, $expires);
6784         git_print_page_nav('commit', '',
6785                            $hash, $co{'tree'}, $hash,
6786                            $formats_nav);
6787
6788         if (defined $co{'parent'}) {
6789                 git_print_header_div('commitdiff', esc_html($co{'title'}) . $ref, $hash);
6790         } else {
6791                 git_print_header_div('tree', esc_html($co{'title'}) . $ref, $co{'tree'}, $hash);
6792         }
6793         print "<div class=\"title_text\">\n" .
6794               "<table class=\"object_header\">\n";
6795         git_print_authorship_rows(\%co);
6796         print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
6797         print "<tr>" .
6798               "<td>tree</td>" .
6799               "<td class=\"sha1\">" .
6800               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash),
6801                        class => "list"}, $co{'tree'}) .
6802               "</td>" .
6803               "<td class=\"link\">" .
6804               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash)},
6805                       "tree");
6806         my $snapshot_links = format_snapshot_links($hash);
6807         if (defined $snapshot_links) {
6808                 print " | " . $snapshot_links;
6809         }
6810         print "</td>" .
6811               "</tr>\n";
6812
6813         foreach my $par (@$parents) {
6814                 print "<tr>" .
6815                       "<td>parent</td>" .
6816                       "<td class=\"sha1\">" .
6817                       $cgi->a({-href => href(action=>"commit", hash=>$par),
6818                                class => "list"}, $par) .
6819                       "</td>" .
6820                       "<td class=\"link\">" .
6821                       $cgi->a({-href => href(action=>"commit", hash=>$par)}, "commit") .
6822                       " | " .
6823                       $cgi->a({-href => href(action=>"commitdiff", hash=>$hash, hash_parent=>$par)}, "diff") .
6824                       "</td>" .
6825                       "</tr>\n";
6826         }
6827         print "</table>".
6828               "</div>\n";
6829
6830         print "<div class=\"page_body\">\n";
6831         git_print_log($co{'comment'});
6832         print "</div>\n";
6833
6834         git_difftree_body(\@difftree, $hash, @$parents);
6835
6836         git_footer_html();
6837 }
6838
6839 sub git_object {
6840         # object is defined by:
6841         # - hash or hash_base alone
6842         # - hash_base and file_name
6843         my $type;
6844
6845         # - hash or hash_base alone
6846         if ($hash || ($hash_base && !defined $file_name)) {
6847                 my $object_id = $hash || $hash_base;
6848
6849                 open my $fd, "-|", quote_command(
6850                         git_cmd(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
6851                         or die_error(404, "Object does not exist");
6852                 $type = <$fd>;
6853                 chomp $type;
6854                 close $fd
6855                         or die_error(404, "Object does not exist");
6856
6857         # - hash_base and file_name
6858         } elsif ($hash_base && defined $file_name) {
6859                 $file_name =~ s,/+$,,;
6860
6861                 system(git_cmd(), "cat-file", '-e', $hash_base) == 0
6862                         or die_error(404, "Base object does not exist");
6863
6864                 # here errors should not hapen
6865                 open my $fd, "-|", git_cmd(), "ls-tree", $hash_base, "--", $file_name
6866                         or die_error(500, "Open git-ls-tree failed");
6867                 my $line = <$fd>;
6868                 close $fd;
6869
6870                 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
6871                 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
6872                         die_error(404, "File or directory for given base does not exist");
6873                 }
6874                 $type = $2;
6875                 $hash = $3;
6876         } else {
6877                 die_error(400, "Not enough information to find object");
6878         }
6879
6880         print $cgi->redirect(-uri => href(action=>$type, -full=>1,
6881                                           hash=>$hash, hash_base=>$hash_base,
6882                                           file_name=>$file_name),
6883                              -status => '302 Found');
6884 }
6885
6886 sub git_blobdiff {
6887         my $format = shift || 'html';
6888
6889         my $fd;
6890         my @difftree;
6891         my %diffinfo;
6892         my $expires;
6893
6894         # preparing $fd and %diffinfo for git_patchset_body
6895         # new style URI
6896         if (defined $hash_base && defined $hash_parent_base) {
6897                 if (defined $file_name) {
6898                         # read raw output
6899                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6900                                 $hash_parent_base, $hash_base,
6901                                 "--", (defined $file_parent ? $file_parent : ()), $file_name
6902                                 or die_error(500, "Open git-diff-tree failed");
6903                         @difftree = map { chomp; $_ } <$fd>;
6904                         close $fd
6905                                 or die_error(404, "Reading git-diff-tree failed");
6906                         @difftree
6907                                 or die_error(404, "Blob diff not found");
6908
6909                 } elsif (defined $hash &&
6910                          $hash =~ /[0-9a-fA-F]{40}/) {
6911                         # try to find filename from $hash
6912
6913                         # read filtered raw output
6914                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6915                                 $hash_parent_base, $hash_base, "--"
6916                                 or die_error(500, "Open git-diff-tree failed");
6917                         @difftree =
6918                                 # ':100644 100644 03b21826... 3b93d5e7... M     ls-files.c'
6919                                 # $hash == to_id
6920                                 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
6921                                 map { chomp; $_ } <$fd>;
6922                         close $fd
6923                                 or die_error(404, "Reading git-diff-tree failed");
6924                         @difftree
6925                                 or die_error(404, "Blob diff not found");
6926
6927                 } else {
6928                         die_error(400, "Missing one of the blob diff parameters");
6929                 }
6930
6931                 if (@difftree > 1) {
6932                         die_error(400, "Ambiguous blob diff specification");
6933                 }
6934
6935                 %diffinfo = parse_difftree_raw_line($difftree[0]);
6936                 $file_parent ||= $diffinfo{'from_file'} || $file_name;
6937                 $file_name   ||= $diffinfo{'to_file'};
6938
6939                 $hash_parent ||= $diffinfo{'from_id'};
6940                 $hash        ||= $diffinfo{'to_id'};
6941
6942                 # non-textual hash id's can be cached
6943                 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
6944                     $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
6945                         $expires = '+1d';
6946                 }
6947
6948                 # open patch output
6949                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6950                         '-p', ($format eq 'html' ? "--full-index" : ()),
6951                         $hash_parent_base, $hash_base,
6952                         "--", (defined $file_parent ? $file_parent : ()), $file_name
6953                         or die_error(500, "Open git-diff-tree failed");
6954         }
6955
6956         # old/legacy style URI -- not generated anymore since 1.4.3.
6957         if (!%diffinfo) {
6958                 die_error('404 Not Found', "Missing one of the blob diff parameters")
6959         }
6960
6961         # header
6962         if ($format eq 'html') {
6963                 my $formats_nav =
6964                         $cgi->a({-href => href(action=>"blobdiff_plain", -replay=>1)},
6965                                 "raw");
6966                 git_header_html(undef, $expires);
6967                 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
6968                         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6969                         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
6970                 } else {
6971                         print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
6972                         print "<div class=\"title\">".esc_html("$hash vs $hash_parent")."</div>\n";
6973                 }
6974                 if (defined $file_name) {
6975                         git_print_page_path($file_name, "blob", $hash_base);
6976                 } else {
6977                         print "<div class=\"page_path\"></div>\n";
6978                 }
6979
6980         } elsif ($format eq 'plain') {
6981                 print $cgi->header(
6982                         -type => 'text/plain',
6983                         -charset => 'utf-8',
6984                         -expires => $expires,
6985                         -content_disposition => 'inline; filename="' . "$file_name" . '.patch"');
6986
6987                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6988
6989         } else {
6990                 die_error(400, "Unknown blobdiff format");
6991         }
6992
6993         # patch
6994         if ($format eq 'html') {
6995                 print "<div class=\"page_body\">\n";
6996
6997                 git_patchset_body($fd, [ \%diffinfo ], $hash_base, $hash_parent_base);
6998                 close $fd;
6999
7000                 print "</div>\n"; # class="page_body"
7001                 git_footer_html();
7002
7003         } else {
7004                 while (my $line = <$fd>) {
7005                         $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
7006                         $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
7007
7008                         print $line;
7009
7010                         last if $line =~ m!^\+\+\+!;
7011                 }
7012                 local $/ = undef;
7013                 print <$fd>;
7014                 close $fd;
7015         }
7016 }
7017
7018 sub git_blobdiff_plain {
7019         git_blobdiff('plain');
7020 }
7021
7022 sub git_commitdiff {
7023         my %params = @_;
7024         my $format = $params{-format} || 'html';
7025
7026         my ($patch_max) = gitweb_get_feature('patches');
7027         if ($format eq 'patch') {
7028                 die_error(403, "Patch view not allowed") unless $patch_max;
7029         }
7030
7031         $hash ||= $hash_base || "HEAD";
7032         my %co = parse_commit($hash)
7033             or die_error(404, "Unknown commit object");
7034
7035         # choose format for commitdiff for merge
7036         if (! defined $hash_parent && @{$co{'parents'}} > 1) {
7037                 $hash_parent = '--cc';
7038         }
7039         # we need to prepare $formats_nav before almost any parameter munging
7040         my $formats_nav;
7041         if ($format eq 'html') {
7042                 $formats_nav =
7043                         $cgi->a({-href => href(action=>"commitdiff_plain", -replay=>1)},
7044                                 "raw");
7045                 if ($patch_max && @{$co{'parents'}} <= 1) {
7046                         $formats_nav .= " | " .
7047                                 $cgi->a({-href => href(action=>"patch", -replay=>1)},
7048                                         "patch");
7049                 }
7050
7051                 if (defined $hash_parent &&
7052                     $hash_parent ne '-c' && $hash_parent ne '--cc') {
7053                         # commitdiff with two commits given
7054                         my $hash_parent_short = $hash_parent;
7055                         if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
7056                                 $hash_parent_short = substr($hash_parent, 0, 7);
7057                         }
7058                         $formats_nav .=
7059                                 ' (from';
7060                         for (my $i = 0; $i < @{$co{'parents'}}; $i++) {
7061                                 if ($co{'parents'}[$i] eq $hash_parent) {
7062                                         $formats_nav .= ' parent ' . ($i+1);
7063                                         last;
7064                                 }
7065                         }
7066                         $formats_nav .= ': ' .
7067                                 $cgi->a({-href => href(action=>"commitdiff",
7068                                                        hash=>$hash_parent)},
7069                                         esc_html($hash_parent_short)) .
7070                                 ')';
7071                 } elsif (!$co{'parent'}) {
7072                         # --root commitdiff
7073                         $formats_nav .= ' (initial)';
7074                 } elsif (scalar @{$co{'parents'}} == 1) {
7075                         # single parent commit
7076                         $formats_nav .=
7077                                 ' (parent: ' .
7078                                 $cgi->a({-href => href(action=>"commitdiff",
7079                                                        hash=>$co{'parent'})},
7080                                         esc_html(substr($co{'parent'}, 0, 7))) .
7081                                 ')';
7082                 } else {
7083                         # merge commit
7084                         if ($hash_parent eq '--cc') {
7085                                 $formats_nav .= ' | ' .
7086                                         $cgi->a({-href => href(action=>"commitdiff",
7087                                                                hash=>$hash, hash_parent=>'-c')},
7088                                                 'combined');
7089                         } else { # $hash_parent eq '-c'
7090                                 $formats_nav .= ' | ' .
7091                                         $cgi->a({-href => href(action=>"commitdiff",
7092                                                                hash=>$hash, hash_parent=>'--cc')},
7093                                                 'compact');
7094                         }
7095                         $formats_nav .=
7096                                 ' (merge: ' .
7097                                 join(' ', map {
7098                                         $cgi->a({-href => href(action=>"commitdiff",
7099                                                                hash=>$_)},
7100                                                 esc_html(substr($_, 0, 7)));
7101                                 } @{$co{'parents'}} ) .
7102                                 ')';
7103                 }
7104         }
7105
7106         my $hash_parent_param = $hash_parent;
7107         if (!defined $hash_parent_param) {
7108                 # --cc for multiple parents, --root for parentless
7109                 $hash_parent_param =
7110                         @{$co{'parents'}} > 1 ? '--cc' : $co{'parent'} || '--root';
7111         }
7112
7113         # read commitdiff
7114         my $fd;
7115         my @difftree;
7116         if ($format eq 'html') {
7117                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
7118                         "--no-commit-id", "--patch-with-raw", "--full-index",
7119                         $hash_parent_param, $hash, "--"
7120                         or die_error(500, "Open git-diff-tree failed");
7121
7122                 while (my $line = <$fd>) {
7123                         chomp $line;
7124                         # empty line ends raw part of diff-tree output
7125                         last unless $line;
7126                         push @difftree, scalar parse_difftree_raw_line($line);
7127                 }
7128
7129         } elsif ($format eq 'plain') {
7130                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
7131                         '-p', $hash_parent_param, $hash, "--"
7132                         or die_error(500, "Open git-diff-tree failed");
7133         } elsif ($format eq 'patch') {
7134                 # For commit ranges, we limit the output to the number of
7135                 # patches specified in the 'patches' feature.
7136                 # For single commits, we limit the output to a single patch,
7137                 # diverging from the git-format-patch default.
7138                 my @commit_spec = ();
7139                 if ($hash_parent) {
7140                         if ($patch_max > 0) {
7141                                 push @commit_spec, "-$patch_max";
7142                         }
7143                         push @commit_spec, '-n', "$hash_parent..$hash";
7144                 } else {
7145                         if ($params{-single}) {
7146                                 push @commit_spec, '-1';
7147                         } else {
7148                                 if ($patch_max > 0) {
7149                                         push @commit_spec, "-$patch_max";
7150                                 }
7151                                 push @commit_spec, "-n";
7152                         }
7153                         push @commit_spec, '--root', $hash;
7154                 }
7155                 open $fd, "-|", git_cmd(), "format-patch", @diff_opts,
7156                         '--encoding=utf8', '--stdout', @commit_spec
7157                         or die_error(500, "Open git-format-patch failed");
7158         } else {
7159                 die_error(400, "Unknown commitdiff format");
7160         }
7161
7162         # non-textual hash id's can be cached
7163         my $expires;
7164         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
7165                 $expires = "+1d";
7166         }
7167
7168         # write commit message
7169         if ($format eq 'html') {
7170                 my $refs = git_get_references();
7171                 my $ref = format_ref_marker($refs, $co{'id'});
7172
7173                 git_header_html(undef, $expires);
7174                 git_print_page_nav('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
7175                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash);
7176                 print "<div class=\"title_text\">\n" .
7177                       "<table class=\"object_header\">\n";
7178                 git_print_authorship_rows(\%co);
7179                 print "</table>".
7180                       "</div>\n";
7181                 print "<div class=\"page_body\">\n";
7182                 if (@{$co{'comment'}} > 1) {
7183                         print "<div class=\"log\">\n";
7184                         git_print_log($co{'comment'}, -final_empty_line=> 1, -remove_title => 1);
7185                         print "</div>\n"; # class="log"
7186                 }
7187
7188         } elsif ($format eq 'plain') {
7189                 my $refs = git_get_references("tags");
7190                 my $tagname = git_get_rev_name_tags($hash);
7191                 my $filename = basename($project) . "-$hash.patch";
7192
7193                 print $cgi->header(
7194                         -type => 'text/plain',
7195                         -charset => 'utf-8',
7196                         -expires => $expires,
7197                         -content_disposition => 'inline; filename="' . "$filename" . '"');
7198                 my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
7199                 print "From: " . to_utf8($co{'author'}) . "\n";
7200                 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
7201                 print "Subject: " . to_utf8($co{'title'}) . "\n";
7202
7203                 print "X-Git-Tag: $tagname\n" if $tagname;
7204                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7205
7206                 foreach my $line (@{$co{'comment'}}) {
7207                         print to_utf8($line) . "\n";
7208                 }
7209                 print "---\n\n";
7210         } elsif ($format eq 'patch') {
7211                 my $filename = basename($project) . "-$hash.patch";
7212
7213                 print $cgi->header(
7214                         -type => 'text/plain',
7215                         -charset => 'utf-8',
7216                         -expires => $expires,
7217                         -content_disposition => 'inline; filename="' . "$filename" . '"');
7218         }
7219
7220         # write patch
7221         if ($format eq 'html') {
7222                 my $use_parents = !defined $hash_parent ||
7223                         $hash_parent eq '-c' || $hash_parent eq '--cc';
7224                 git_difftree_body(\@difftree, $hash,
7225                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
7226                 print "<br/>\n";
7227
7228                 git_patchset_body($fd, \@difftree, $hash,
7229                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
7230                 close $fd;
7231                 print "</div>\n"; # class="page_body"
7232                 git_footer_html();
7233
7234         } elsif ($format eq 'plain') {
7235                 local $/ = undef;
7236                 print <$fd>;
7237                 close $fd
7238                         or print "Reading git-diff-tree failed\n";
7239         } elsif ($format eq 'patch') {
7240                 local $/ = undef;
7241                 print <$fd>;
7242                 close $fd
7243                         or print "Reading git-format-patch failed\n";
7244         }
7245 }
7246
7247 sub git_commitdiff_plain {
7248         git_commitdiff(-format => 'plain');
7249 }
7250
7251 # format-patch-style patches
7252 sub git_patch {
7253         git_commitdiff(-format => 'patch', -single => 1);
7254 }
7255
7256 sub git_patches {
7257         git_commitdiff(-format => 'patch');
7258 }
7259
7260 sub git_history {
7261         git_log_generic('history', \&git_history_body,
7262                         $hash_base, $hash_parent_base,
7263                         $file_name, $hash);
7264 }
7265
7266 sub git_search {
7267         $searchtype ||= 'commit';
7268
7269         # check if appropriate features are enabled
7270         gitweb_check_feature('search')
7271                 or die_error(403, "Search is disabled");
7272         if ($searchtype eq 'pickaxe') {
7273                 # pickaxe may take all resources of your box and run for several minutes
7274                 # with every query - so decide by yourself how public you make this feature
7275                 gitweb_check_feature('pickaxe')
7276                         or die_error(403, "Pickaxe search is disabled");
7277         }
7278         if ($searchtype eq 'grep') {
7279                 # grep search might be potentially CPU-intensive, too
7280                 gitweb_check_feature('grep')
7281                         or die_error(403, "Grep search is disabled");
7282         }
7283
7284         if (!defined $searchtext) {
7285                 die_error(400, "Text field is empty");
7286         }
7287         if (!defined $hash) {
7288                 $hash = git_get_head_hash($project);
7289         }
7290         my %co = parse_commit($hash);
7291         if (!%co) {
7292                 die_error(404, "Unknown commit object");
7293         }
7294         if (!defined $page) {
7295                 $page = 0;
7296         }
7297
7298         if ($searchtype eq 'commit' ||
7299             $searchtype eq 'author' ||
7300             $searchtype eq 'committer') {
7301                 git_search_message(%co);
7302         } elsif ($searchtype eq 'pickaxe') {
7303                 git_search_changes(%co);
7304         } elsif ($searchtype eq 'grep') {
7305                 git_search_files(%co);
7306         } else {
7307                 die_error(400, "Unknown search type");
7308         }
7309 }
7310
7311 sub git_search_help {
7312         git_header_html();
7313         git_print_page_nav('','', $hash,$hash,$hash);
7314         print <<EOT;
7315 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
7316 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
7317 the pattern entered is recognized as the POSIX extended
7318 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
7319 insensitive).</p>
7320 <dl>
7321 <dt><b>commit</b></dt>
7322 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
7323 EOT
7324         my $have_grep = gitweb_check_feature('grep');
7325         if ($have_grep) {
7326                 print <<EOT;
7327 <dt><b>grep</b></dt>
7328 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
7329     a different one) are searched for the given pattern. On large trees, this search can take
7330 a while and put some strain on the server, so please use it with some consideration. Note that
7331 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
7332 case-sensitive.</dd>
7333 EOT
7334         }
7335         print <<EOT;
7336 <dt><b>author</b></dt>
7337 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
7338 <dt><b>committer</b></dt>
7339 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
7340 EOT
7341         my $have_pickaxe = gitweb_check_feature('pickaxe');
7342         if ($have_pickaxe) {
7343                 print <<EOT;
7344 <dt><b>pickaxe</b></dt>
7345 <dd>All commits that caused the string to appear or disappear from any file (changes that
7346 added, removed or "modified" the string) will be listed. This search can take a while and
7347 takes a lot of strain on the server, so please use it wisely. Note that since you may be
7348 interested even in changes just changing the case as well, this search is case sensitive.</dd>
7349 EOT
7350         }
7351         print "</dl>\n";
7352         git_footer_html();
7353 }
7354
7355 sub git_shortlog {
7356         git_log_generic('shortlog', \&git_shortlog_body,
7357                         $hash, $hash_parent);
7358 }
7359
7360 ## ......................................................................
7361 ## feeds (RSS, Atom; OPML)
7362
7363 sub git_feed {
7364         my $format = shift || 'atom';
7365         my $have_blame = gitweb_check_feature('blame');
7366
7367         # Atom: http://www.atomenabled.org/developers/syndication/
7368         # RSS:  http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
7369         if ($format ne 'rss' && $format ne 'atom') {
7370                 die_error(400, "Unknown web feed format");
7371         }
7372
7373         # log/feed of current (HEAD) branch, log of given branch, history of file/directory
7374         my $head = $hash || 'HEAD';
7375         my @commitlist = parse_commits($head, 150, 0, $file_name);
7376
7377         my %latest_commit;
7378         my %latest_date;
7379         my $content_type = "application/$format+xml";
7380         if (defined $cgi->http('HTTP_ACCEPT') &&
7381                  $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
7382                 # browser (feed reader) prefers text/xml
7383                 $content_type = 'text/xml';
7384         }
7385         if (defined($commitlist[0])) {
7386                 %latest_commit = %{$commitlist[0]};
7387                 my $latest_epoch = $latest_commit{'committer_epoch'};
7388                 %latest_date   = parse_date($latest_epoch, $latest_commit{'comitter_tz'});
7389                 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
7390                 if (defined $if_modified) {
7391                         my $since;
7392                         if (eval { require HTTP::Date; 1; }) {
7393                                 $since = HTTP::Date::str2time($if_modified);
7394                         } elsif (eval { require Time::ParseDate; 1; }) {
7395                                 $since = Time::ParseDate::parsedate($if_modified, GMT => 1);
7396                         }
7397                         if (defined $since && $latest_epoch <= $since) {
7398                                 print $cgi->header(
7399                                         -type => $content_type,
7400                                         -charset => 'utf-8',
7401                                         -last_modified => $latest_date{'rfc2822'},
7402                                         -status => '304 Not Modified');
7403                                 return;
7404                         }
7405                 }
7406                 print $cgi->header(
7407                         -type => $content_type,
7408                         -charset => 'utf-8',
7409                         -last_modified => $latest_date{'rfc2822'});
7410         } else {
7411                 print $cgi->header(
7412                         -type => $content_type,
7413                         -charset => 'utf-8');
7414         }
7415
7416         # Optimization: skip generating the body if client asks only
7417         # for Last-Modified date.
7418         return if ($cgi->request_method() eq 'HEAD');
7419
7420         # header variables
7421         my $title = "$site_name - $project/$action";
7422         my $feed_type = 'log';
7423         if (defined $hash) {
7424                 $title .= " - '$hash'";
7425                 $feed_type = 'branch log';
7426                 if (defined $file_name) {
7427                         $title .= " :: $file_name";
7428                         $feed_type = 'history';
7429                 }
7430         } elsif (defined $file_name) {
7431                 $title .= " - $file_name";
7432                 $feed_type = 'history';
7433         }
7434         $title .= " $feed_type";
7435         my $descr = git_get_project_description($project);
7436         if (defined $descr) {
7437                 $descr = esc_html($descr);
7438         } else {
7439                 $descr = "$project " .
7440                          ($format eq 'rss' ? 'RSS' : 'Atom') .
7441                          " feed";
7442         }
7443         my $owner = git_get_project_owner($project);
7444         $owner = esc_html($owner);
7445
7446         #header
7447         my $alt_url;
7448         if (defined $file_name) {
7449                 $alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
7450         } elsif (defined $hash) {
7451                 $alt_url = href(-full=>1, action=>"log", hash=>$hash);
7452         } else {
7453                 $alt_url = href(-full=>1, action=>"summary");
7454         }
7455         print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
7456         if ($format eq 'rss') {
7457                 print <<XML;
7458 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
7459 <channel>
7460 XML
7461                 print "<title>$title</title>\n" .
7462                       "<link>$alt_url</link>\n" .
7463                       "<description>$descr</description>\n" .
7464                       "<language>en</language>\n" .
7465                       # project owner is responsible for 'editorial' content
7466                       "<managingEditor>$owner</managingEditor>\n";
7467                 if (defined $logo || defined $favicon) {
7468                         # prefer the logo to the favicon, since RSS
7469                         # doesn't allow both
7470                         my $img = esc_url($logo || $favicon);
7471                         print "<image>\n" .
7472                               "<url>$img</url>\n" .
7473                               "<title>$title</title>\n" .
7474                               "<link>$alt_url</link>\n" .
7475                               "</image>\n";
7476                 }
7477                 if (%latest_date) {
7478                         print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
7479                         print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
7480                 }
7481                 print "<generator>gitweb v.$version/$git_version</generator>\n";
7482         } elsif ($format eq 'atom') {
7483                 print <<XML;
7484 <feed xmlns="http://www.w3.org/2005/Atom">
7485 XML
7486                 print "<title>$title</title>\n" .
7487                       "<subtitle>$descr</subtitle>\n" .
7488                       '<link rel="alternate" type="text/html" href="' .
7489                       $alt_url . '" />' . "\n" .
7490                       '<link rel="self" type="' . $content_type . '" href="' .
7491                       $cgi->self_url() . '" />' . "\n" .
7492                       "<id>" . href(-full=>1) . "</id>\n" .
7493                       # use project owner for feed author
7494                       "<author><name>$owner</name></author>\n";
7495                 if (defined $favicon) {
7496                         print "<icon>" . esc_url($favicon) . "</icon>\n";
7497                 }
7498                 if (defined $logo) {
7499                         # not twice as wide as tall: 72 x 27 pixels
7500                         print "<logo>" . esc_url($logo) . "</logo>\n";
7501                 }
7502                 if (! %latest_date) {
7503                         # dummy date to keep the feed valid until commits trickle in:
7504                         print "<updated>1970-01-01T00:00:00Z</updated>\n";
7505                 } else {
7506                         print "<updated>$latest_date{'iso-8601'}</updated>\n";
7507                 }
7508                 print "<generator version='$version/$git_version'>gitweb</generator>\n";
7509         }
7510
7511         # contents
7512         for (my $i = 0; $i <= $#commitlist; $i++) {
7513                 my %co = %{$commitlist[$i]};
7514                 my $commit = $co{'id'};
7515                 # we read 150, we always show 30 and the ones more recent than 48 hours
7516                 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
7517                         last;
7518                 }
7519                 my %cd = parse_date($co{'author_epoch'}, $co{'author_tz'});
7520
7521                 # get list of changed files
7522                 open my $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
7523                         $co{'parent'} || "--root",
7524                         $co{'id'}, "--", (defined $file_name ? $file_name : ())
7525                         or next;
7526                 my @difftree = map { chomp; $_ } <$fd>;
7527                 close $fd
7528                         or next;
7529
7530                 # print element (entry, item)
7531                 my $co_url = href(-full=>1, action=>"commitdiff", hash=>$commit);
7532                 if ($format eq 'rss') {
7533                         print "<item>\n" .
7534                               "<title>" . esc_html($co{'title'}) . "</title>\n" .
7535                               "<author>" . esc_html($co{'author'}) . "</author>\n" .
7536                               "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
7537                               "<guid isPermaLink=\"true\">$co_url</guid>\n" .
7538                               "<link>$co_url</link>\n" .
7539                               "<description>" . esc_html($co{'title'}) . "</description>\n" .
7540                               "<content:encoded>" .
7541                               "<![CDATA[\n";
7542                 } elsif ($format eq 'atom') {
7543                         print "<entry>\n" .
7544                               "<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
7545                               "<updated>$cd{'iso-8601'}</updated>\n" .
7546                               "<author>\n" .
7547                               "  <name>" . esc_html($co{'author_name'}) . "</name>\n";
7548                         if ($co{'author_email'}) {
7549                                 print "  <email>" . esc_html($co{'author_email'}) . "</email>\n";
7550                         }
7551                         print "</author>\n" .
7552                               # use committer for contributor
7553                               "<contributor>\n" .
7554                               "  <name>" . esc_html($co{'committer_name'}) . "</name>\n";
7555                         if ($co{'committer_email'}) {
7556                                 print "  <email>" . esc_html($co{'committer_email'}) . "</email>\n";
7557                         }
7558                         print "</contributor>\n" .
7559                               "<published>$cd{'iso-8601'}</published>\n" .
7560                               "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
7561                               "<id>$co_url</id>\n" .
7562                               "<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
7563                               "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
7564                 }
7565                 my $comment = $co{'comment'};
7566                 print "<pre>\n";
7567                 foreach my $line (@$comment) {
7568                         $line = esc_html($line);
7569                         print "$line\n";
7570                 }
7571                 print "</pre><ul>\n";
7572                 foreach my $difftree_line (@difftree) {
7573                         my %difftree = parse_difftree_raw_line($difftree_line);
7574                         next if !$difftree{'from_id'};
7575
7576                         my $file = $difftree{'file'} || $difftree{'to_file'};
7577
7578                         print "<li>" .
7579                               "[" .
7580                               $cgi->a({-href => href(-full=>1, action=>"blobdiff",
7581                                                      hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
7582                                                      hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
7583                                                      file_name=>$file, file_parent=>$difftree{'from_file'}),
7584                                       -title => "diff"}, 'D');
7585                         if ($have_blame) {
7586                                 print $cgi->a({-href => href(-full=>1, action=>"blame",
7587                                                              file_name=>$file, hash_base=>$commit),
7588                                               -title => "blame"}, 'B');
7589                         }
7590                         # if this is not a feed of a file history
7591                         if (!defined $file_name || $file_name ne $file) {
7592                                 print $cgi->a({-href => href(-full=>1, action=>"history",
7593                                                              file_name=>$file, hash=>$commit),
7594                                               -title => "history"}, 'H');
7595                         }
7596                         $file = esc_path($file);
7597                         print "] ".
7598                               "$file</li>\n";
7599                 }
7600                 if ($format eq 'rss') {
7601                         print "</ul>]]>\n" .
7602                               "</content:encoded>\n" .
7603                               "</item>\n";
7604                 } elsif ($format eq 'atom') {
7605                         print "</ul>\n</div>\n" .
7606                               "</content>\n" .
7607                               "</entry>\n";
7608                 }
7609         }
7610
7611         # end of feed
7612         if ($format eq 'rss') {
7613                 print "</channel>\n</rss>\n";
7614         } elsif ($format eq 'atom') {
7615                 print "</feed>\n";
7616         }
7617 }
7618
7619 sub git_rss {
7620         git_feed('rss');
7621 }
7622
7623 sub git_atom {
7624         git_feed('atom');
7625 }
7626
7627 sub git_opml {
7628         my @list = git_get_projects_list();
7629         if (!@list) {
7630                 die_error(404, "No projects found");
7631         }
7632
7633         print $cgi->header(
7634                 -type => 'text/xml',
7635                 -charset => 'utf-8',
7636                 -content_disposition => 'inline; filename="opml.xml"');
7637
7638         print <<XML;
7639 <?xml version="1.0" encoding="utf-8"?>
7640 <opml version="1.0">
7641 <head>
7642   <title>$site_name OPML Export</title>
7643 </head>
7644 <body>
7645 <outline text="git RSS feeds">
7646 XML
7647
7648         foreach my $pr (@list) {
7649                 my %proj = %$pr;
7650                 my $head = git_get_head_hash($proj{'path'});
7651                 if (!defined $head) {
7652                         next;
7653                 }
7654                 $git_dir = "$projectroot/$proj{'path'}";
7655                 my %co = parse_commit($head);
7656                 if (!%co) {
7657                         next;
7658                 }
7659
7660                 my $path = esc_html(chop_str($proj{'path'}, 25, 5));
7661                 my $rss  = href('project' => $proj{'path'}, 'action' => 'rss', -full => 1);
7662                 my $html = href('project' => $proj{'path'}, 'action' => 'summary', -full => 1);
7663                 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";
7664         }
7665         print <<XML;
7666 </outline>
7667 </body>
7668 </opml>
7669 XML
7670 }