Lady’s Gitweb - Gitweb/blob - gitweb.perl

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