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