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