gitweb/gitweb.perl

   1 #!/usr/bin/perl
   2
   3 # gitweb - simple web interface to track changes in git repositories
   4 #
   5 # (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
   6 # (C) 2005, Christian Gierke
   7 #
   8 # This program is licensed under the GPLv2
   9
  10 use strict;
  11 use warnings;
  12 use CGI qw(:standard :escapeHTML -nosticky);
  13 use CGI::Util qw(unescape);
  14 use CGI::Carp qw(fatalsToBrowser);
  15 use Encode;
  16 use Fcntl ':mode';
  17 use File::Find qw();
  18 use File::Basename qw(basename);
  19 binmode STDOUT, ':utf8';
  20
  21 BEGIN {
  22         CGI->compile() if $ENV{'MOD_PERL'};
  23 }
  24
  25 our $cgi = new CGI;
  26 our $version = "++GIT_VERSION++";
  27 our $my_url = $cgi->url();
  28 our $my_uri = $cgi->url(-absolute => 1);
  29
  30 # if we're called with PATH_INFO, we have to strip that
  31 # from the URL to find our real URL
  32 if (my $path_info = $ENV{"PATH_INFO"}) {
  33         $my_url =~ s,\Q$path_info\E$,,;
  34         $my_uri =~ s,\Q$path_info\E$,,;
  35 }
  36
  37 # core git executable to use
  38 # this can just be "git" if your webserver has a sensible PATH
  39 our $GIT = "++GIT_BINDIR++/git";
  40
  41 # absolute fs-path which will be prepended to the project path
  42 #our $projectroot = "/pub/scm";
  43 our $projectroot = "++GITWEB_PROJECTROOT++";
  44
  45 # fs traversing limit for getting project list
  46 # the number is relative to the projectroot
  47 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
  48
  49 # target of the home link on top of all pages
  50 our $home_link = $my_uri || "/";
  51
  52 # string of the home link on top of all pages
  53 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
  54
  55 # name of your site or organization to appear in page titles
  56 # replace this with something more descriptive for clearer bookmarks
  57 our $site_name = "++GITWEB_SITENAME++"
  58                  || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
  59
  60 # filename of html text to include at top of each page
  61 our $site_header = "++GITWEB_SITE_HEADER++";
  62 # html text to include at home page
  63 our $home_text = "++GITWEB_HOMETEXT++";
  64 # filename of html text to include at bottom of each page
  65 our $site_footer = "++GITWEB_SITE_FOOTER++";
  66
  67 # URI of stylesheets
  68 our @stylesheets = ("++GITWEB_CSS++");
  69 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
  70 our $stylesheet = undef;
  71 # URI of GIT logo (72x27 size)
  72 our $logo = "++GITWEB_LOGO++";
  73 # URI of GIT favicon, assumed to be image/png type
  74 our $favicon = "++GITWEB_FAVICON++";
  75
  76 # URI and label (title) of GIT logo link
  77 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
  78 #our $logo_label = "git documentation";
  79 our $logo_url = "http://git.or.cz/";
  80 our $logo_label = "git homepage";
  81
  82 # source of projects list
  83 our $projects_list = "++GITWEB_LIST++";
  84
  85 # the width (in characters) of the projects list "Description" column
  86 our $projects_list_description_width = 25;
  87
  88 # default order of projects list
  89 # valid values are none, project, descr, owner, and age
  90 our $default_projects_order = "project";
  91
  92 # show repository only if this file exists
  93 # (only effective if this variable evaluates to true)
  94 our $export_ok = "++GITWEB_EXPORT_OK++";
  95
  96 # only allow viewing of repositories also shown on the overview page
  97 our $strict_export = "++GITWEB_STRICT_EXPORT++";
  98
  99 # list of git base URLs used for URL to where fetch project from,
 100 # i.e. full URL is "$git_base_url/$project"
 101 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
 102
 103 # default blob_plain mimetype and default charset for text/plain blob
 104 our $default_blob_plain_mimetype = 'text/plain';
 105 our $default_text_plain_charset  = undef;
 106
 107 # file to use for guessing MIME types before trying /etc/mime.types
 108 # (relative to the current git repository)
 109 our $mimetypes_file = undef;
 110
 111 # assume this charset if line contains non-UTF-8 characters;
 112 # it should be valid encoding (see Encoding::Supported(3pm) for list),
 113 # for which encoding all byte sequences are valid, for example
 114 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
 115 # could be even 'utf-8' for the old behavior)
 116 our $fallback_encoding = 'latin1';
 117
 118 # rename detection options for git-diff and git-diff-tree
 119 # - default is '-M', with the cost proportional to
 120 #   (number of removed files) * (number of new files).
 121 # - more costly is '-C' (which implies '-M'), with the cost proportional to
 122 #   (number of changed files + number of removed files) * (number of new files)
 123 # - even more costly is '-C', '--find-copies-harder' with cost
 124 #   (number of files in the original tree) * (number of new files)
 125 # - one might want to include '-B' option, e.g. '-B', '-M'
 126 our @diff_opts = ('-M'); # taken from git_commit
 127
 128 # information about snapshot formats that gitweb is capable of serving
 129 our %known_snapshot_formats = (
 130         # name => {
 131         #       'display' => display name,
 132         #       'type' => mime type,
 133         #       'suffix' => filename suffix,
 134         #       'format' => --format for git-archive,
 135         #       'compressor' => [compressor command and arguments]
 136         #                       (array reference, optional)}
 137         #
 138         'tgz' => {
 139                 'display' => 'tar.gz',
 140                 'type' => 'application/x-gzip',
 141                 'suffix' => '.tar.gz',
 142                 'format' => 'tar',
 143                 'compressor' => ['gzip']},
 144
 145         'tbz2' => {
 146                 'display' => 'tar.bz2',
 147                 'type' => 'application/x-bzip2',
 148                 'suffix' => '.tar.bz2',
 149                 'format' => 'tar',
 150                 'compressor' => ['bzip2']},
 151
 152         'zip' => {
 153                 'display' => 'zip',
 154                 'type' => 'application/x-zip',
 155                 'suffix' => '.zip',
 156                 'format' => 'zip'},
 157 );
 158
 159 # Aliases so we understand old gitweb.snapshot values in repository
 160 # configuration.
 161 our %known_snapshot_format_aliases = (
 162         'gzip'  => 'tgz',
 163         'bzip2' => 'tbz2',
 164
 165         # backward compatibility: legacy gitweb config support
 166         'x-gzip' => undef, 'gz' => undef,
 167         'x-bzip2' => undef, 'bz2' => undef,
 168         'x-zip' => undef, '' => undef,
 169 );
 170
 171 # You define site-wide feature defaults here; override them with
 172 # $GITWEB_CONFIG as necessary.
 173 our %feature = (
 174         # feature => {
 175         #       'sub' => feature-sub (subroutine),
 176         #       'override' => allow-override (boolean),
 177         #       'default' => [ default options...] (array reference)}
 178         #
 179         # if feature is overridable (it means that allow-override has true value),
 180         # then feature-sub will be called with default options as parameters;
 181         # return value of feature-sub indicates if to enable specified feature
 182         #
 183         # if there is no 'sub' key (no feature-sub), then feature cannot be
 184         # overriden
 185         #
 186         # use gitweb_check_feature(<feature>) to check if <feature> is enabled
 187
 188         # Enable the 'blame' blob view, showing the last commit that modified
 189         # each line in the file. This can be very CPU-intensive.
 190
 191         # To enable system wide have in $GITWEB_CONFIG
 192         # $feature{'blame'}{'default'} = [1];
 193         # To have project specific config enable override in $GITWEB_CONFIG
 194         # $feature{'blame'}{'override'} = 1;
 195         # and in project config gitweb.blame = 0|1;
 196         'blame' => {
 197                 'sub' => \&feature_blame,
 198                 'override' => 0,
 199                 'default' => [0]},
 200
 201         # Enable the 'snapshot' link, providing a compressed archive of any
 202         # tree. This can potentially generate high traffic if you have large
 203         # project.
 204
 205         # Value is a list of formats defined in %known_snapshot_formats that
 206         # you wish to offer.
 207         # To disable system wide have in $GITWEB_CONFIG
 208         # $feature{'snapshot'}{'default'} = [];
 209         # To have project specific config enable override in $GITWEB_CONFIG
 210         # $feature{'snapshot'}{'override'} = 1;
 211         # and in project config, a comma-separated list of formats or "none"
 212         # to disable.  Example: gitweb.snapshot = tbz2,zip;
 213         'snapshot' => {
 214                 'sub' => \&feature_snapshot,
 215                 'override' => 0,
 216                 'default' => ['tgz']},
 217
 218         # Enable text search, which will list the commits which match author,
 219         # committer or commit text to a given string.  Enabled by default.
 220         # Project specific override is not supported.
 221         'search' => {
 222                 'override' => 0,
 223                 'default' => [1]},
 224
 225         # Enable grep search, which will list the files in currently selected
 226         # tree containing the given string. Enabled by default. This can be
 227         # potentially CPU-intensive, of course.
 228
 229         # To enable system wide have in $GITWEB_CONFIG
 230         # $feature{'grep'}{'default'} = [1];
 231         # To have project specific config enable override in $GITWEB_CONFIG
 232         # $feature{'grep'}{'override'} = 1;
 233         # and in project config gitweb.grep = 0|1;
 234         'grep' => {
 235                 'override' => 0,
 236                 'default' => [1]},
 237
 238         # Enable the pickaxe search, which will list the commits that modified
 239         # a given string in a file. This can be practical and quite faster
 240         # alternative to 'blame', but still potentially CPU-intensive.
 241
 242         # To enable system wide have in $GITWEB_CONFIG
 243         # $feature{'pickaxe'}{'default'} = [1];
 244         # To have project specific config enable override in $GITWEB_CONFIG
 245         # $feature{'pickaxe'}{'override'} = 1;
 246         # and in project config gitweb.pickaxe = 0|1;
 247         'pickaxe' => {
 248                 'sub' => \&feature_pickaxe,
 249                 'override' => 0,
 250                 'default' => [1]},
 251
 252         # Make gitweb use an alternative format of the URLs which can be
 253         # more readable and natural-looking: project name is embedded
 254         # directly in the path and the query string contains other
 255         # auxiliary information. All gitweb installations recognize
 256         # URL in either format; this configures in which formats gitweb
 257         # generates links.
 258
 259         # To enable system wide have in $GITWEB_CONFIG
 260         # $feature{'pathinfo'}{'default'} = [1];
 261         # Project specific override is not supported.
 262
 263         # Note that you will need to change the default location of CSS,
 264         # favicon, logo and possibly other files to an absolute URL. Also,
 265         # if gitweb.cgi serves as your indexfile, you will need to force
 266         # $my_uri to contain the script name in your $GITWEB_CONFIG.
 267         'pathinfo' => {
 268                 'override' => 0,
 269                 'default' => [0]},
 270
 271         # Make gitweb consider projects in project root subdirectories
 272         # to be forks of existing projects. Given project $projname.git,
 273         # projects matching $projname/*.git will not be shown in the main
 274         # projects list, instead a '+' mark will be added to $projname
 275         # there and a 'forks' view will be enabled for the project, listing
 276         # all the forks. If project list is taken from a file, forks have
 277         # to be listed after the main project.
 278
 279         # To enable system wide have in $GITWEB_CONFIG
 280         # $feature{'forks'}{'default'} = [1];
 281         # Project specific override is not supported.
 282         'forks' => {
 283                 'override' => 0,
 284                 'default' => [0]},
 285
 286         # Insert custom links to the action bar of all project pages.
 287         # This enables you mainly to link to third-party scripts integrating
 288         # into gitweb; e.g. git-browser for graphical history representation
 289         # or custom web-based repository administration interface.
 290
 291         # The 'default' value consists of a list of triplets in the form
 292         # (label, link, position) where position is the label after which
 293         # to inster the link and link is a format string where %n expands
 294         # to the project name, %f to the project path within the filesystem,
 295         # %h to the current hash (h gitweb parameter) and %b to the current
 296         # hash base (hb gitweb parameter).
 297
 298         # To enable system wide have in $GITWEB_CONFIG e.g.
 299         # $feature{'actions'}{'default'} = [('graphiclog',
 300         #       '/git-browser/by-commit.html?r=%n', 'summary')];
 301         # Project specific override is not supported.
 302         'actions' => {
 303                 'override' => 0,
 304                 'default' => []},
 305
 306         # Allow gitweb scan project content tags described in ctags/
 307         # of project repository, and display the popular Web 2.0-ish
 308         # "tag cloud" near the project list. Note that this is something
 309         # COMPLETELY different from the normal Git tags.
 310
 311         # gitweb by itself can show existing tags, but it does not handle
 312         # tagging itself; you need an external application for that.
 313         # For an example script, check Girocco's cgi/tagproj.cgi.
 314         # You may want to install the HTML::TagCloud Perl module to get
 315         # a pretty tag cloud instead of just a list of tags.
 316
 317         # To enable system wide have in $GITWEB_CONFIG
 318         # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
 319         # Project specific override is not supported.
 320         'ctags' => {
 321                 'override' => 0,
 322                 'default' => [0]},
 323 );
 324
 325 sub gitweb_check_feature {
 326         my ($name) = @_;
 327         return unless exists $feature{$name};
 328         my ($sub, $override, @defaults) = (
 329                 $feature{$name}{'sub'},
 330                 $feature{$name}{'override'},
 331                 @{$feature{$name}{'default'}});
 332         if (!$override) { return @defaults; }
 333         if (!defined $sub) {
 334                 warn "feature $name is not overrideable";
 335                 return @defaults;
 336         }
 337         return $sub->(@defaults);
 338 }
 339
 340 sub feature_blame {
 341         my ($val) = git_get_project_config('blame', '--bool');
 342
 343         if ($val eq 'true') {
 344                 return 1;
 345         } elsif ($val eq 'false') {
 346                 return 0;
 347         }
 348
 349         return $_[0];
 350 }
 351
 352 sub feature_snapshot {
 353         my (@fmts) = @_;
 354
 355         my ($val) = git_get_project_config('snapshot');
 356
 357         if ($val) {
 358                 @fmts = ($val eq 'none' ? () : split /\s*[,\s]\s*/, $val);
 359         }
 360
 361         return @fmts;
 362 }
 363
 364 sub feature_grep {
 365         my ($val) = git_get_project_config('grep', '--bool');
 366
 367         if ($val eq 'true') {
 368                 return (1);
 369         } elsif ($val eq 'false') {
 370                 return (0);
 371         }
 372
 373         return ($_[0]);
 374 }
 375
 376 sub feature_pickaxe {
 377         my ($val) = git_get_project_config('pickaxe', '--bool');
 378
 379         if ($val eq 'true') {
 380                 return (1);
 381         } elsif ($val eq 'false') {
 382                 return (0);
 383         }
 384
 385         return ($_[0]);
 386 }
 387
 388 # checking HEAD file with -e is fragile if the repository was
 389 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
 390 # and then pruned.
 391 sub check_head_link {
 392         my ($dir) = @_;
 393         my $headfile = "$dir/HEAD";
 394         return ((-e $headfile) ||
 395                 (-l $headfile && readlink($headfile) =~ /^refs\/heads\//));
 396 }
 397
 398 sub check_export_ok {
 399         my ($dir) = @_;
 400         return (check_head_link($dir) &&
 401                 (!$export_ok || -e "$dir/$export_ok"));
 402 }
 403
 404 # process alternate names for backward compatibility
 405 # filter out unsupported (unknown) snapshot formats
 406 sub filter_snapshot_fmts {
 407         my @fmts = @_;
 408
 409         @fmts = map {
 410                 exists $known_snapshot_format_aliases{$_} ?
 411                        $known_snapshot_format_aliases{$_} : $_} @fmts;
 412         @fmts = grep(exists $known_snapshot_formats{$_}, @fmts);
 413
 414 }
 415
 416 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
 417 if (-e $GITWEB_CONFIG) {
 418         do $GITWEB_CONFIG;
 419 } else {
 420         our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
 421         do $GITWEB_CONFIG_SYSTEM if -e $GITWEB_CONFIG_SYSTEM;
 422 }
 423
 424 # version of the core git binary
 425 our $git_version = qx("$GIT" --version) =~ m/git version (.*)$/ ? $1 : "unknown";
 426
 427 $projects_list ||= $projectroot;
 428
 429 # ======================================================================
 430 # input validation and dispatch
 431 our $action = $cgi->param('a');
 432 if (defined $action) {
 433         if ($action =~ m/[^0-9a-zA-Z\.\-_]/) {
 434                 die_error(400, "Invalid action parameter");
 435         }
 436 }
 437
 438 # parameters which are pathnames
 439 our $project = $cgi->param('p');
 440 if (defined $project) {
 441         if (!validate_pathname($project) ||
 442             !(-d "$projectroot/$project") ||
 443             !check_head_link("$projectroot/$project") ||
 444             ($export_ok && !(-e "$projectroot/$project/$export_ok")) ||
 445             ($strict_export && !project_in_list($project))) {
 446                 undef $project;
 447                 die_error(404, "No such project");
 448         }
 449 }
 450
 451 our $file_name = $cgi->param('f');
 452 if (defined $file_name) {
 453         if (!validate_pathname($file_name)) {
 454                 die_error(400, "Invalid file parameter");
 455         }
 456 }
 457
 458 our $file_parent = $cgi->param('fp');
 459 if (defined $file_parent) {
 460         if (!validate_pathname($file_parent)) {
 461                 die_error(400, "Invalid file parent parameter");
 462         }
 463 }
 464
 465 # parameters which are refnames
 466 our $hash = $cgi->param('h');
 467 if (defined $hash) {
 468         if (!validate_refname($hash)) {
 469                 die_error(400, "Invalid hash parameter");
 470         }
 471 }
 472
 473 our $hash_parent = $cgi->param('hp');
 474 if (defined $hash_parent) {
 475         if (!validate_refname($hash_parent)) {
 476                 die_error(400, "Invalid hash parent parameter");
 477         }
 478 }
 479
 480 our $hash_base = $cgi->param('hb');
 481 if (defined $hash_base) {
 482         if (!validate_refname($hash_base)) {
 483                 die_error(400, "Invalid hash base parameter");
 484         }
 485 }
 486
 487 my %allowed_options = (
 488         "--no-merges" => [ qw(rss atom log shortlog history) ],
 489 );
 490
 491 our @extra_options = $cgi->param('opt');
 492 if (defined @extra_options) {
 493         foreach my $opt (@extra_options) {
 494                 if (not exists $allowed_options{$opt}) {
 495                         die_error(400, "Invalid option parameter");
 496                 }
 497                 if (not grep(/^$action$/, @{$allowed_options{$opt}})) {
 498                         die_error(400, "Invalid option parameter for this action");
 499                 }
 500         }
 501 }
 502
 503 our $hash_parent_base = $cgi->param('hpb');
 504 if (defined $hash_parent_base) {
 505         if (!validate_refname($hash_parent_base)) {
 506                 die_error(400, "Invalid hash parent base parameter");
 507         }
 508 }
 509
 510 # other parameters
 511 our $page = $cgi->param('pg');
 512 if (defined $page) {
 513         if ($page =~ m/[^0-9]/) {
 514                 die_error(400, "Invalid page parameter");
 515         }
 516 }
 517
 518 our $searchtype = $cgi->param('st');
 519 if (defined $searchtype) {
 520         if ($searchtype =~ m/[^a-z]/) {
 521                 die_error(400, "Invalid searchtype parameter");
 522         }
 523 }
 524
 525 our $search_use_regexp = $cgi->param('sr');
 526
 527 our $searchtext = $cgi->param('s');
 528 our $search_regexp;
 529 if (defined $searchtext) {
 530         if (length($searchtext) < 2) {
 531                 die_error(403, "At least two characters are required for search parameter");
 532         }
 533         $search_regexp = $search_use_regexp ? $searchtext : quotemeta $searchtext;
 534 }
 535
 536 # now read PATH_INFO and use it as alternative to parameters
 537 sub evaluate_path_info {
 538         return if defined $project;
 539         my $path_info = $ENV{"PATH_INFO"};
 540         return if !$path_info;
 541         $path_info =~ s,^/+,,;
 542         return if !$path_info;
 543         # find which part of PATH_INFO is project
 544         $project = $path_info;
 545         $project =~ s,/+$,,;
 546         while ($project && !check_head_link("$projectroot/$project")) {
 547                 $project =~ s,/*[^/]*$,,;
 548         }
 549         # validate project
 550         $project = validate_pathname($project);
 551         if (!$project ||
 552             ($export_ok && !-e "$projectroot/$project/$export_ok") ||
 553             ($strict_export && !project_in_list($project))) {
 554                 undef $project;
 555                 return;
 556         }
 557         # do not change any parameters if an action is given using the query string
 558         return if $action;
 559         $path_info =~ s,^\Q$project\E/*,,;
 560         my ($refname, $pathname) = split(/:/, $path_info, 2);
 561         if (defined $pathname) {
 562                 # we got "project.git/branch:filename" or "project.git/branch:dir/"
 563                 # we could use git_get_type(branch:pathname), but it needs $git_dir
 564                 $pathname =~ s,^/+,,;
 565                 if (!$pathname || substr($pathname, -1) eq "/") {
 566                         $action  ||= "tree";
 567                         $pathname =~ s,/$,,;
 568                 } else {
 569                         $action  ||= "blob_plain";
 570                 }
 571                 $hash_base ||= validate_refname($refname);
 572                 $file_name ||= validate_pathname($pathname);
 573         } elsif (defined $refname) {
 574                 # we got "project.git/branch"
 575                 $action ||= "shortlog";
 576                 $hash   ||= validate_refname($refname);
 577         }
 578 }
 579 evaluate_path_info();
 580
 581 # path to the current git repository
 582 our $git_dir;
 583 $git_dir = "$projectroot/$project" if $project;
 584
 585 # dispatch
 586 my %actions = (
 587         "blame" => \&git_blame,
 588         "blobdiff" => \&git_blobdiff,
 589         "blobdiff_plain" => \&git_blobdiff_plain,
 590         "blob" => \&git_blob,
 591         "blob_plain" => \&git_blob_plain,
 592         "commitdiff" => \&git_commitdiff,
 593         "commitdiff_plain" => \&git_commitdiff_plain,
 594         "commit" => \&git_commit,
 595         "forks" => \&git_forks,
 596         "heads" => \&git_heads,
 597         "history" => \&git_history,
 598         "log" => \&git_log,
 599         "rss" => \&git_rss,
 600         "atom" => \&git_atom,
 601         "search" => \&git_search,
 602         "search_help" => \&git_search_help,
 603         "shortlog" => \&git_shortlog,
 604         "summary" => \&git_summary,
 605         "tag" => \&git_tag,
 606         "tags" => \&git_tags,
 607         "tree" => \&git_tree,
 608         "snapshot" => \&git_snapshot,
 609         "object" => \&git_object,
 610         # those below don't need $project
 611         "opml" => \&git_opml,
 612         "project_list" => \&git_project_list,
 613         "project_index" => \&git_project_index,
 614 );
 615
 616 if (!defined $action) {
 617         if (defined $hash) {
 618                 $action = git_get_type($hash);
 619         } elsif (defined $hash_base && defined $file_name) {
 620                 $action = git_get_type("$hash_base:$file_name");
 621         } elsif (defined $project) {
 622                 $action = 'summary';
 623         } else {
 624                 $action = 'project_list';
 625         }
 626 }
 627 if (!defined($actions{$action})) {
 628         die_error(400, "Unknown action");
 629 }
 630 if ($action !~ m/^(opml|project_list|project_index)$/ &&
 631     !$project) {
 632         die_error(400, "Project needed");
 633 }
 634 $actions{$action}->();
 635 exit;
 636
 637 ## ======================================================================
 638 ## action links
 639
 640 sub href (%) {
 641         my %params = @_;
 642         # default is to use -absolute url() i.e. $my_uri
 643         my $href = $params{-full} ? $my_url : $my_uri;
 644
 645         # XXX: Warning: If you touch this, check the search form for updating,
 646         # too.
 647
 648         my @mapping = (
 649                 project => "p",
 650                 action => "a",
 651                 file_name => "f",
 652                 file_parent => "fp",
 653                 hash => "h",
 654                 hash_parent => "hp",
 655                 hash_base => "hb",
 656                 hash_parent_base => "hpb",
 657                 page => "pg",
 658                 order => "o",
 659                 searchtext => "s",
 660                 searchtype => "st",
 661                 snapshot_format => "sf",
 662                 extra_options => "opt",
 663                 search_use_regexp => "sr",
 664         );
 665         my %mapping = @mapping;
 666
 667         $params{'project'} = $project unless exists $params{'project'};
 668
 669         if ($params{-replay}) {
 670                 while (my ($name, $symbol) = each %mapping) {
 671                         if (!exists $params{$name}) {
 672                                 # to allow for multivalued params we use arrayref form
 673                                 $params{$name} = [ $cgi->param($symbol) ];
 674                         }
 675                 }
 676         }
 677
 678         my ($use_pathinfo) = gitweb_check_feature('pathinfo');
 679         if ($use_pathinfo) {
 680                 # use PATH_INFO for project name
 681                 $href .= "/".esc_url($params{'project'}) if defined $params{'project'};
 682                 delete $params{'project'};
 683
 684                 # Summary just uses the project path URL
 685                 if (defined $params{'action'} && $params{'action'} eq 'summary') {
 686                         delete $params{'action'};
 687                 }
 688         }
 689
 690         # now encode the parameters explicitly
 691         my @result = ();
 692         for (my $i = 0; $i < @mapping; $i += 2) {
 693                 my ($name, $symbol) = ($mapping[$i], $mapping[$i+1]);
 694                 if (defined $params{$name}) {
 695                         if (ref($params{$name}) eq "ARRAY") {
 696                                 foreach my $par (@{$params{$name}}) {
 697                                         push @result, $symbol . "=" . esc_param($par);
 698                                 }
 699                         } else {
 700                                 push @result, $symbol . "=" . esc_param($params{$name});
 701                         }
 702                 }
 703         }
 704         $href .= "?" . join(';', @result) if scalar @result;
 705
 706         return $href;
 707 }
 708
 709
 710 ## ======================================================================
 711 ## validation, quoting/unquoting and escaping
 712
 713 sub validate_pathname {
 714         my $input = shift || return undef;
 715
 716         # no '.' or '..' as elements of path, i.e. no '.' nor '..'
 717         # at the beginning, at the end, and between slashes.
 718         # also this catches doubled slashes
 719         if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
 720                 return undef;
 721         }
 722         # no null characters
 723         if ($input =~ m!\0!) {
 724                 return undef;
 725         }
 726         return $input;
 727 }
 728
 729 sub validate_refname {
 730         my $input = shift || return undef;
 731
 732         # textual hashes are O.K.
 733         if ($input =~ m/^[0-9a-fA-F]{40}$/) {
 734                 return $input;
 735         }
 736         # it must be correct pathname
 737         $input = validate_pathname($input)
 738                 or return undef;
 739         # restrictions on ref name according to git-check-ref-format
 740         if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
 741                 return undef;
 742         }
 743         return $input;
 744 }
 745
 746 # decode sequences of octets in utf8 into Perl's internal form,
 747 # which is utf-8 with utf8 flag set if needed.  gitweb writes out
 748 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
 749 sub to_utf8 {
 750         my $str = shift;
 751         if (utf8::valid($str)) {
 752                 utf8::decode($str);
 753                 return $str;
 754         } else {
 755                 return decode($fallback_encoding, $str, Encode::FB_DEFAULT);
 756         }
 757 }
 758
 759 # quote unsafe chars, but keep the slash, even when it's not
 760 # correct, but quoted slashes look too horrible in bookmarks
 761 sub esc_param {
 762         my $str = shift;
 763         $str =~ s/([^A-Za-z0-9\-_.~()\/:@])/sprintf("%%%02X", ord($1))/eg;
 764         $str =~ s/\+/%2B/g;
 765         $str =~ s/ /\+/g;
 766         return $str;
 767 }
 768
 769 # quote unsafe chars in whole URL, so some charactrs cannot be quoted
 770 sub esc_url {
 771         my $str = shift;
 772         $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&=])/sprintf("%%%02X", ord($1))/eg;
 773         $str =~ s/\+/%2B/g;
 774         $str =~ s/ /\+/g;
 775         return $str;
 776 }
 777
 778 # replace invalid utf8 character with SUBSTITUTION sequence
 779 sub esc_html ($;%) {
 780         my $str = shift;
 781         my %opts = @_;
 782
 783         $str = to_utf8($str);
 784         $str = $cgi->escapeHTML($str);
 785         if ($opts{'-nbsp'}) {
 786                 $str =~ s/ /&nbsp;/g;
 787         }
 788         $str =~ s|([[:cntrl:]])|(($1 ne "\t") ? quot_cec($1) : $1)|eg;
 789         return $str;
 790 }
 791
 792 # quote control characters and escape filename to HTML
 793 sub esc_path {
 794         my $str = shift;
 795         my %opts = @_;
 796
 797         $str = to_utf8($str);
 798         $str = $cgi->escapeHTML($str);
 799         if ($opts{'-nbsp'}) {
 800                 $str =~ s/ /&nbsp;/g;
 801         }
 802         $str =~ s|([[:cntrl:]])|quot_cec($1)|eg;
 803         return $str;
 804 }
 805
 806 # Make control characters "printable", using character escape codes (CEC)
 807 sub quot_cec {
 808         my $cntrl = shift;
 809         my %opts = @_;
 810         my %es = ( # character escape codes, aka escape sequences
 811                 "\t" => '\t',   # tab            (HT)
 812                 "\n" => '\n',   # line feed      (LF)
 813                 "\r" => '\r',   # carrige return (CR)
 814                 "\f" => '\f',   # form feed      (FF)
 815                 "\b" => '\b',   # backspace      (BS)
 816                 "\a" => '\a',   # alarm (bell)   (BEL)
 817                 "\e" => '\e',   # escape         (ESC)
 818                 "\013" => '\v', # vertical tab   (VT)
 819                 "\000" => '\0', # nul character  (NUL)
 820         );
 821         my $chr = ( (exists $es{$cntrl})
 822                     ? $es{$cntrl}
 823                     : sprintf('\%2x', ord($cntrl)) );
 824         if ($opts{-nohtml}) {
 825                 return $chr;
 826         } else {
 827                 return "<span class=\"cntrl\">$chr</span>";
 828         }
 829 }
 830
 831 # Alternatively use unicode control pictures codepoints,
 832 # Unicode "printable representation" (PR)
 833 sub quot_upr {
 834         my $cntrl = shift;
 835         my %opts = @_;
 836
 837         my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
 838         if ($opts{-nohtml}) {
 839                 return $chr;
 840         } else {
 841                 return "<span class=\"cntrl\">$chr</span>";
 842         }
 843 }
 844
 845 # git may return quoted and escaped filenames
 846 sub unquote {
 847         my $str = shift;
 848
 849         sub unq {
 850                 my $seq = shift;
 851                 my %es = ( # character escape codes, aka escape sequences
 852                         't' => "\t",   # tab            (HT, TAB)
 853                         'n' => "\n",   # newline        (NL)
 854                         'r' => "\r",   # return         (CR)
 855                         'f' => "\f",   # form feed      (FF)
 856                         'b' => "\b",   # backspace      (BS)
 857                         'a' => "\a",   # alarm (bell)   (BEL)
 858                         'e' => "\e",   # escape         (ESC)
 859                         'v' => "\013", # vertical tab   (VT)
 860                 );
 861
 862                 if ($seq =~ m/^[0-7]{1,3}$/) {
 863                         # octal char sequence
 864                         return chr(oct($seq));
 865                 } elsif (exists $es{$seq}) {
 866                         # C escape sequence, aka character escape code
 867                         return $es{$seq};
 868                 }
 869                 # quoted ordinary character
 870                 return $seq;
 871         }
 872
 873         if ($str =~ m/^"(.*)"$/) {
 874                 # needs unquoting
 875                 $str = $1;
 876                 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
 877         }
 878         return $str;
 879 }
 880
 881 # escape tabs (convert tabs to spaces)
 882 sub untabify {
 883         my $line = shift;
 884
 885         while ((my $pos = index($line, "\t")) != -1) {
 886                 if (my $count = (8 - ($pos % 8))) {
 887                         my $spaces = ' ' x $count;
 888                         $line =~ s/\t/$spaces/;
 889                 }
 890         }
 891
 892         return $line;
 893 }
 894
 895 sub project_in_list {
 896         my $project = shift;
 897         my @list = git_get_projects_list();
 898         return @list && scalar(grep { $_->{'path'} eq $project } @list);
 899 }
 900
 901 ## ----------------------------------------------------------------------
 902 ## HTML aware string manipulation
 903
 904 # Try to chop given string on a word boundary between position
 905 # $len and $len+$add_len. If there is no word boundary there,
 906 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
 907 # (marking chopped part) would be longer than given string.
 908 sub chop_str {
 909         my $str = shift;
 910         my $len = shift;
 911         my $add_len = shift || 10;
 912         my $where = shift || 'right'; # 'left' | 'center' | 'right'
 913
 914         # Make sure perl knows it is utf8 encoded so we don't
 915         # cut in the middle of a utf8 multibyte char.
 916         $str = to_utf8($str);
 917
 918         # allow only $len chars, but don't cut a word if it would fit in $add_len
 919         # if it doesn't fit, cut it if it's still longer than the dots we would add
 920         # remove chopped character entities entirely
 921
 922         # when chopping in the middle, distribute $len into left and right part
 923         # return early if chopping wouldn't make string shorter
 924         if ($where eq 'center') {
 925                 return $str if ($len + 5 >= length($str)); # filler is length 5
 926                 $len = int($len/2);
 927         } else {
 928                 return $str if ($len + 4 >= length($str)); # filler is length 4
 929         }
 930
 931         # regexps: ending and beginning with word part up to $add_len
 932         my $endre = qr/.{$len}\w{0,$add_len}/;
 933         my $begre = qr/\w{0,$add_len}.{$len}/;
 934
 935         if ($where eq 'left') {
 936                 $str =~ m/^(.*?)($begre)$/;
 937                 my ($lead, $body) = ($1, $2);
 938                 if (length($lead) > 4) {
 939                         $body =~ s/^[^;]*;// if ($lead =~ m/&[^;]*$/);
 940                         $lead = " ...";
 941                 }
 942                 return "$lead$body";
 943
 944         } elsif ($where eq 'center') {
 945                 $str =~ m/^($endre)(.*)$/;
 946                 my ($left, $str)  = ($1, $2);
 947                 $str =~ m/^(.*?)($begre)$/;
 948                 my ($mid, $right) = ($1, $2);
 949                 if (length($mid) > 5) {
 950                         $left  =~ s/&[^;]*$//;
 951                         $right =~ s/^[^;]*;// if ($mid =~ m/&[^;]*$/);
 952                         $mid = " ... ";
 953                 }
 954                 return "$left$mid$right";
 955
 956         } else {
 957                 $str =~ m/^($endre)(.*)$/;
 958                 my $body = $1;
 959                 my $tail = $2;
 960                 if (length($tail) > 4) {
 961                         $body =~ s/&[^;]*$//;
 962                         $tail = "... ";
 963                 }
 964                 return "$body$tail";
 965         }
 966 }
 967
 968 # takes the same arguments as chop_str, but also wraps a <span> around the
 969 # result with a title attribute if it does get chopped. Additionally, the
 970 # string is HTML-escaped.
 971 sub chop_and_escape_str {
 972         my ($str) = @_;
 973
 974         my $chopped = chop_str(@_);
 975         if ($chopped eq $str) {
 976                 return esc_html($chopped);
 977         } else {
 978                 $str =~ s/([[:cntrl:]])/?/g;
 979                 return $cgi->span({-title=>$str}, esc_html($chopped));
 980         }
 981 }
 982
 983 ## ----------------------------------------------------------------------
 984 ## functions returning short strings
 985
 986 # CSS class for given age value (in seconds)
 987 sub age_class {
 988         my $age = shift;
 989
 990         if (!defined $age) {
 991                 return "noage";
 992         } elsif ($age < 60*60*2) {
 993                 return "age0";
 994         } elsif ($age < 60*60*24*2) {
 995                 return "age1";
 996         } else {
 997                 return "age2";
 998         }
 999 }
1000
1001 # convert age in seconds to "nn units ago" string
1002 sub age_string {
1003         my $age = shift;
1004         my $age_str;
1005
1006         if ($age > 60*60*24*365*2) {
1007                 $age_str = (int $age/60/60/24/365);
1008                 $age_str .= " years ago";
1009         } elsif ($age > 60*60*24*(365/12)*2) {
1010                 $age_str = int $age/60/60/24/(365/12);
1011                 $age_str .= " months ago";
1012         } elsif ($age > 60*60*24*7*2) {
1013                 $age_str = int $age/60/60/24/7;
1014                 $age_str .= " weeks ago";
1015         } elsif ($age > 60*60*24*2) {
1016                 $age_str = int $age/60/60/24;
1017                 $age_str .= " days ago";
1018         } elsif ($age > 60*60*2) {
1019                 $age_str = int $age/60/60;
1020                 $age_str .= " hours ago";
1021         } elsif ($age > 60*2) {
1022                 $age_str = int $age/60;
1023                 $age_str .= " min ago";
1024         } elsif ($age > 2) {
1025                 $age_str = int $age;
1026                 $age_str .= " sec ago";
1027         } else {
1028                 $age_str .= " right now";
1029         }
1030         return $age_str;
1031 }
1032
1033 use constant {
1034         S_IFINVALID => 0030000,
1035         S_IFGITLINK => 0160000,
1036 };
1037
1038 # submodule/subproject, a commit object reference
1039 sub S_ISGITLINK($) {
1040         my $mode = shift;
1041
1042         return (($mode & S_IFMT) == S_IFGITLINK)
1043 }
1044
1045 # convert file mode in octal to symbolic file mode string
1046 sub mode_str {
1047         my $mode = oct shift;
1048
1049         if (S_ISGITLINK($mode)) {
1050                 return 'm---------';
1051         } elsif (S_ISDIR($mode & S_IFMT)) {
1052                 return 'drwxr-xr-x';
1053         } elsif (S_ISLNK($mode)) {
1054                 return 'lrwxrwxrwx';
1055         } elsif (S_ISREG($mode)) {
1056                 # git cares only about the executable bit
1057                 if ($mode & S_IXUSR) {
1058                         return '-rwxr-xr-x';
1059                 } else {
1060                         return '-rw-r--r--';
1061                 };
1062         } else {
1063                 return '----------';
1064         }
1065 }
1066
1067 # convert file mode in octal to file type string
1068 sub file_type {
1069         my $mode = shift;
1070
1071         if ($mode !~ m/^[0-7]+$/) {
1072                 return $mode;
1073         } else {
1074                 $mode = oct $mode;
1075         }
1076
1077         if (S_ISGITLINK($mode)) {
1078                 return "submodule";
1079         } elsif (S_ISDIR($mode & S_IFMT)) {
1080                 return "directory";
1081         } elsif (S_ISLNK($mode)) {
1082                 return "symlink";
1083         } elsif (S_ISREG($mode)) {
1084                 return "file";
1085         } else {
1086                 return "unknown";
1087         }
1088 }
1089
1090 # convert file mode in octal to file type description string
1091 sub file_type_long {
1092         my $mode = shift;
1093
1094         if ($mode !~ m/^[0-7]+$/) {
1095                 return $mode;
1096         } else {
1097                 $mode = oct $mode;
1098         }
1099
1100         if (S_ISGITLINK($mode)) {
1101                 return "submodule";
1102         } elsif (S_ISDIR($mode & S_IFMT)) {
1103                 return "directory";
1104         } elsif (S_ISLNK($mode)) {
1105                 return "symlink";
1106         } elsif (S_ISREG($mode)) {
1107                 if ($mode & S_IXUSR) {
1108                         return "executable";
1109                 } else {
1110                         return "file";
1111                 };
1112         } else {
1113                 return "unknown";
1114         }
1115 }
1116
1117
1118 ## ----------------------------------------------------------------------
1119 ## functions returning short HTML fragments, or transforming HTML fragments
1120 ## which don't belong to other sections
1121
1122 # format line of commit message.
1123 sub format_log_line_html {
1124         my $line = shift;
1125
1126         $line = esc_html($line, -nbsp=>1);
1127         if ($line =~ m/([0-9a-fA-F]{8,40})/) {
1128                 my $hash_text = $1;
1129                 my $link =
1130                         $cgi->a({-href => href(action=>"object", hash=>$hash_text),
1131                                 -class => "text"}, $hash_text);
1132                 $line =~ s/$hash_text/$link/;
1133         }
1134         return $line;
1135 }
1136
1137 # format marker of refs pointing to given object
1138
1139 # the destination action is chosen based on object type and current context:
1140 # - for annotated tags, we choose the tag view unless it's the current view
1141 #   already, in which case we go to shortlog view
1142 # - for other refs, we keep the current view if we're in history, shortlog or
1143 #   log view, and select shortlog otherwise
1144 sub format_ref_marker {
1145         my ($refs, $id) = @_;
1146         my $markers = '';
1147
1148         if (defined $refs->{$id}) {
1149                 foreach my $ref (@{$refs->{$id}}) {
1150                         # this code exploits the fact that non-lightweight tags are the
1151                         # only indirect objects, and that they are the only objects for which
1152                         # we want to use tag instead of shortlog as action
1153                         my ($type, $name) = qw();
1154                         my $indirect = ($ref =~ s/\^\{\}$//);
1155                         # e.g. tags/v2.6.11 or heads/next
1156                         if ($ref =~ m!^(.*?)s?/(.*)$!) {
1157                                 $type = $1;
1158                                 $name = $2;
1159                         } else {
1160                                 $type = "ref";
1161                                 $name = $ref;
1162                         }
1163
1164                         my $class = $type;
1165                         $class .= " indirect" if $indirect;
1166
1167                         my $dest_action = "shortlog";
1168
1169                         if ($indirect) {
1170                                 $dest_action = "tag" unless $action eq "tag";
1171                         } elsif ($action =~ /^(history|(short)?log)$/) {
1172                                 $dest_action = $action;
1173                         }
1174
1175                         my $dest = "";
1176                         $dest .= "refs/" unless $ref =~ m!^refs/!;
1177                         $dest .= $ref;
1178
1179                         my $link = $cgi->a({
1180                                 -href => href(
1181                                         action=>$dest_action,
1182                                         hash=>$dest
1183                                 )}, $name);
1184
1185                         $markers .= " <span class=\"$class\" title=\"$ref\">" .
1186                                 $link . "</span>";
1187                 }
1188         }
1189
1190         if ($markers) {
1191                 return ' <span class="refs">'. $markers . '</span>';
1192         } else {
1193                 return "";
1194         }
1195 }
1196
1197 # format, perhaps shortened and with markers, title line
1198 sub format_subject_html {
1199         my ($long, $short, $href, $extra) = @_;
1200         $extra = '' unless defined($extra);
1201
1202         if (length($short) < length($long)) {
1203                 return $cgi->a({-href => $href, -class => "list subject",
1204                                 -title => to_utf8($long)},
1205                        esc_html($short) . $extra);
1206         } else {
1207                 return $cgi->a({-href => $href, -class => "list subject"},
1208                        esc_html($long)  . $extra);
1209         }
1210 }
1211
1212 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1213 sub format_git_diff_header_line {
1214         my $line = shift;
1215         my $diffinfo = shift;
1216         my ($from, $to) = @_;
1217
1218         if ($diffinfo->{'nparents'}) {
1219                 # combined diff
1220                 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1221                 if ($to->{'href'}) {
1222                         $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
1223                                          esc_path($to->{'file'}));
1224                 } else { # file was deleted (no href)
1225                         $line .= esc_path($to->{'file'});
1226                 }
1227         } else {
1228                 # "ordinary" diff
1229                 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1230                 if ($from->{'href'}) {
1231                         $line .= $cgi->a({-href => $from->{'href'}, -class => "path"},
1232                                          'a/' . esc_path($from->{'file'}));
1233                 } else { # file was added (no href)
1234                         $line .= 'a/' . esc_path($from->{'file'});
1235                 }
1236                 $line .= ' ';
1237                 if ($to->{'href'}) {
1238                         $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
1239                                          'b/' . esc_path($to->{'file'}));
1240                 } else { # file was deleted
1241                         $line .= 'b/' . esc_path($to->{'file'});
1242                 }
1243         }
1244
1245         return "<div class=\"diff header\">$line</div>\n";
1246 }
1247
1248 # format extended diff header line, before patch itself
1249 sub format_extended_diff_header_line {
1250         my $line = shift;
1251         my $diffinfo = shift;
1252         my ($from, $to) = @_;
1253
1254         # match <path>
1255         if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1256                 $line .= $cgi->a({-href=>$from->{'href'}, -class=>"path"},
1257                                        esc_path($from->{'file'}));
1258         }
1259         if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1260                 $line .= $cgi->a({-href=>$to->{'href'}, -class=>"path"},
1261                                  esc_path($to->{'file'}));
1262         }
1263         # match single <mode>
1264         if ($line =~ m/\s(\d{6})$/) {
1265                 $line .= '<span class="info"> (' .
1266                          file_type_long($1) .
1267                          ')</span>';
1268         }
1269         # match <hash>
1270         if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1271                 # can match only for combined diff
1272                 $line = 'index ';
1273                 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1274                         if ($from->{'href'}[$i]) {
1275                                 $line .= $cgi->a({-href=>$from->{'href'}[$i],
1276                                                   -class=>"hash"},
1277                                                  substr($diffinfo->{'from_id'}[$i],0,7));
1278                         } else {
1279                                 $line .= '0' x 7;
1280                         }
1281                         # separator
1282                         $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1283                 }
1284                 $line .= '..';
1285                 if ($to->{'href'}) {
1286                         $line .= $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
1287                                          substr($diffinfo->{'to_id'},0,7));
1288                 } else {
1289                         $line .= '0' x 7;
1290                 }
1291
1292         } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
1293                 # can match only for ordinary diff
1294                 my ($from_link, $to_link);
1295                 if ($from->{'href'}) {
1296                         $from_link = $cgi->a({-href=>$from->{'href'}, -class=>"hash"},
1297                                              substr($diffinfo->{'from_id'},0,7));
1298                 } else {
1299                         $from_link = '0' x 7;
1300                 }
1301                 if ($to->{'href'}) {
1302                         $to_link = $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
1303                                            substr($diffinfo->{'to_id'},0,7));
1304                 } else {
1305                         $to_link = '0' x 7;
1306                 }
1307                 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
1308                 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
1309         }
1310
1311         return $line . "<br/>\n";
1312 }
1313
1314 # format from-file/to-file diff header
1315 sub format_diff_from_to_header {
1316         my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
1317         my $line;
1318         my $result = '';
1319
1320         $line = $from_line;
1321         #assert($line =~ m/^---/) if DEBUG;
1322         # no extra formatting for "^--- /dev/null"
1323         if (! $diffinfo->{'nparents'}) {
1324                 # ordinary (single parent) diff
1325                 if ($line =~ m!^--- "?a/!) {
1326                         if ($from->{'href'}) {
1327                                 $line = '--- a/' .
1328                                         $cgi->a({-href=>$from->{'href'}, -class=>"path"},
1329                                                 esc_path($from->{'file'}));
1330                         } else {
1331                                 $line = '--- a/' .
1332                                         esc_path($from->{'file'});
1333                         }
1334                 }
1335                 $result .= qq!<div class="diff from_file">$line</div>\n!;
1336
1337         } else {
1338                 # combined diff (merge commit)
1339                 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1340                         if ($from->{'href'}[$i]) {
1341                                 $line = '--- ' .
1342                                         $cgi->a({-href=>href(action=>"blobdiff",
1343                                                              hash_parent=>$diffinfo->{'from_id'}[$i],
1344                                                              hash_parent_base=>$parents[$i],
1345                                                              file_parent=>$from->{'file'}[$i],
1346                                                              hash=>$diffinfo->{'to_id'},
1347                                                              hash_base=>$hash,
1348                                                              file_name=>$to->{'file'}),
1349                                                  -class=>"path",
1350                                                  -title=>"diff" . ($i+1)},
1351                                                 $i+1) .
1352                                         '/' .
1353                                         $cgi->a({-href=>$from->{'href'}[$i], -class=>"path"},
1354                                                 esc_path($from->{'file'}[$i]));
1355                         } else {
1356                                 $line = '--- /dev/null';
1357                         }
1358                         $result .= qq!<div class="diff from_file">$line</div>\n!;
1359                 }
1360         }
1361
1362         $line = $to_line;
1363         #assert($line =~ m/^\+\+\+/) if DEBUG;
1364         # no extra formatting for "^+++ /dev/null"
1365         if ($line =~ m!^\+\+\+ "?b/!) {
1366                 if ($to->{'href'}) {
1367                         $line = '+++ b/' .
1368                                 $cgi->a({-href=>$to->{'href'}, -class=>"path"},
1369                                         esc_path($to->{'file'}));
1370                 } else {
1371                         $line = '+++ b/' .
1372                                 esc_path($to->{'file'});
1373                 }
1374         }
1375         $result .= qq!<div class="diff to_file">$line</div>\n!;
1376
1377         return $result;
1378 }
1379
1380 # create note for patch simplified by combined diff
1381 sub format_diff_cc_simplified {
1382         my ($diffinfo, @parents) = @_;
1383         my $result = '';
1384
1385         $result .= "<div class=\"diff header\">" .
1386                    "diff --cc ";
1387         if (!is_deleted($diffinfo)) {
1388                 $result .= $cgi->a({-href => href(action=>"blob",
1389                                                   hash_base=>$hash,
1390                                                   hash=>$diffinfo->{'to_id'},
1391                                                   file_name=>$diffinfo->{'to_file'}),
1392                                     -class => "path"},
1393                                    esc_path($diffinfo->{'to_file'}));
1394         } else {
1395                 $result .= esc_path($diffinfo->{'to_file'});
1396         }
1397         $result .= "</div>\n" . # class="diff header"
1398                    "<div class=\"diff nodifferences\">" .
1399                    "Simple merge" .
1400                    "</div>\n"; # class="diff nodifferences"
1401
1402         return $result;
1403 }
1404
1405 # format patch (diff) line (not to be used for diff headers)
1406 sub format_diff_line {
1407         my $line = shift;
1408         my ($from, $to) = @_;
1409         my $diff_class = "";
1410
1411         chomp $line;
1412
1413         if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
1414                 # combined diff
1415                 my $prefix = substr($line, 0, scalar @{$from->{'href'}});
1416                 if ($line =~ m/^\@{3}/) {
1417                         $diff_class = " chunk_header";
1418                 } elsif ($line =~ m/^\\/) {
1419                         $diff_class = " incomplete";
1420                 } elsif ($prefix =~ tr/+/+/) {
1421                         $diff_class = " add";
1422                 } elsif ($prefix =~ tr/-/-/) {
1423                         $diff_class = " rem";
1424                 }
1425         } else {
1426                 # assume ordinary diff
1427                 my $char = substr($line, 0, 1);
1428                 if ($char eq '+') {
1429                         $diff_class = " add";
1430                 } elsif ($char eq '-') {
1431                         $diff_class = " rem";
1432                 } elsif ($char eq '@') {
1433                         $diff_class = " chunk_header";
1434                 } elsif ($char eq "\\") {
1435                         $diff_class = " incomplete";
1436                 }
1437         }
1438         $line = untabify($line);
1439         if ($from && $to && $line =~ m/^\@{2} /) {
1440                 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
1441                         $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
1442
1443                 $from_lines = 0 unless defined $from_lines;
1444                 $to_lines   = 0 unless defined $to_lines;
1445
1446                 if ($from->{'href'}) {
1447                         $from_text = $cgi->a({-href=>"$from->{'href'}#l$from_start",
1448                                              -class=>"list"}, $from_text);
1449                 }
1450                 if ($to->{'href'}) {
1451                         $to_text   = $cgi->a({-href=>"$to->{'href'}#l$to_start",
1452                                              -class=>"list"}, $to_text);
1453                 }
1454                 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
1455                         "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
1456                 return "<div class=\"diff$diff_class\">$line</div>\n";
1457         } elsif ($from && $to && $line =~ m/^\@{3}/) {
1458                 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
1459                 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
1460
1461                 @from_text = split(' ', $ranges);
1462                 for (my $i = 0; $i < @from_text; ++$i) {
1463                         ($from_start[$i], $from_nlines[$i]) =
1464                                 (split(',', substr($from_text[$i], 1)), 0);
1465                 }
1466
1467                 $to_text   = pop @from_text;
1468                 $to_start  = pop @from_start;
1469                 $to_nlines = pop @from_nlines;
1470
1471                 $line = "<span class=\"chunk_info\">$prefix ";
1472                 for (my $i = 0; $i < @from_text; ++$i) {
1473                         if ($from->{'href'}[$i]) {
1474                                 $line .= $cgi->a({-href=>"$from->{'href'}[$i]#l$from_start[$i]",
1475                                                   -class=>"list"}, $from_text[$i]);
1476                         } else {
1477                                 $line .= $from_text[$i];
1478                         }
1479                         $line .= " ";
1480                 }
1481                 if ($to->{'href'}) {
1482                         $line .= $cgi->a({-href=>"$to->{'href'}#l$to_start",
1483                                           -class=>"list"}, $to_text);
1484                 } else {
1485                         $line .= $to_text;
1486                 }
1487                 $line .= " $prefix</span>" .
1488                          "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
1489                 return "<div class=\"diff$diff_class\">$line</div>\n";
1490         }
1491         return "<div class=\"diff$diff_class\">" . esc_html($line, -nbsp=>1) . "</div>\n";
1492 }
1493
1494 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
1495 # linked.  Pass the hash of the tree/commit to snapshot.
1496 sub format_snapshot_links {
1497         my ($hash) = @_;
1498         my @snapshot_fmts = gitweb_check_feature('snapshot');
1499         @snapshot_fmts = filter_snapshot_fmts(@snapshot_fmts);
1500         my $num_fmts = @snapshot_fmts;
1501         if ($num_fmts > 1) {
1502                 # A parenthesized list of links bearing format names.
1503                 # e.g. "snapshot (_tar.gz_ _zip_)"
1504                 return "snapshot (" . join(' ', map
1505                         $cgi->a({
1506                                 -href => href(
1507                                         action=>"snapshot",
1508                                         hash=>$hash,
1509                                         snapshot_format=>$_
1510                                 )
1511                         }, $known_snapshot_formats{$_}{'display'})
1512                 , @snapshot_fmts) . ")";
1513         } elsif ($num_fmts == 1) {
1514                 # A single "snapshot" link whose tooltip bears the format name.
1515                 # i.e. "_snapshot_"
1516                 my ($fmt) = @snapshot_fmts;
1517                 return
1518                         $cgi->a({
1519                                 -href => href(
1520                                         action=>"snapshot",
1521                                         hash=>$hash,
1522                                         snapshot_format=>$fmt
1523                                 ),
1524                                 -title => "in format: $known_snapshot_formats{$fmt}{'display'}"
1525                         }, "snapshot");
1526         } else { # $num_fmts == 0
1527                 return undef;
1528         }
1529 }
1530
1531 ## ......................................................................
1532 ## functions returning values to be passed, perhaps after some
1533 ## transformation, to other functions; e.g. returning arguments to href()
1534
1535 # returns hash to be passed to href to generate gitweb URL
1536 # in -title key it returns description of link
1537 sub get_feed_info {
1538         my $format = shift || 'Atom';
1539         my %res = (action => lc($format));
1540
1541         # feed links are possible only for project views
1542         return unless (defined $project);
1543         # some views should link to OPML, or to generic project feed,
1544         # or don't have specific feed yet (so they should use generic)
1545         return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
1546
1547         my $branch;
1548         # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
1549         # from tag links; this also makes possible to detect branch links
1550         if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
1551             (defined $hash      && $hash      =~ m!^refs/heads/(.*)$!)) {
1552                 $branch = $1;
1553         }
1554         # find log type for feed description (title)
1555         my $type = 'log';
1556         if (defined $file_name) {
1557                 $type  = "history of $file_name";
1558                 $type .= "/" if ($action eq 'tree');
1559                 $type .= " on '$branch'" if (defined $branch);
1560         } else {
1561                 $type = "log of $branch" if (defined $branch);
1562         }
1563
1564         $res{-title} = $type;
1565         $res{'hash'} = (defined $branch ? "refs/heads/$branch" : undef);
1566         $res{'file_name'} = $file_name;
1567
1568         return %res;
1569 }
1570
1571 ## ----------------------------------------------------------------------
1572 ## git utility subroutines, invoking git commands
1573
1574 # returns path to the core git executable and the --git-dir parameter as list
1575 sub git_cmd {
1576         return $GIT, '--git-dir='.$git_dir;
1577 }
1578
1579 # quote the given arguments for passing them to the shell
1580 # quote_command("command", "arg 1", "arg with ' and ! characters")
1581 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
1582 # Try to avoid using this function wherever possible.
1583 sub quote_command {
1584         return join(' ',
1585                     map( { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ ));
1586 }
1587
1588 # get HEAD ref of given project as hash
1589 sub git_get_head_hash {
1590         my $project = shift;
1591         my $o_git_dir = $git_dir;
1592         my $retval = undef;
1593         $git_dir = "$projectroot/$project";
1594         if (open my $fd, "-|", git_cmd(), "rev-parse", "--verify", "HEAD") {
1595                 my $head = <$fd>;
1596                 close $fd;
1597                 if (defined $head && $head =~ /^([0-9a-fA-F]{40})$/) {
1598                         $retval = $1;
1599                 }
1600         }
1601         if (defined $o_git_dir) {
1602                 $git_dir = $o_git_dir;
1603         }
1604         return $retval;
1605 }
1606
1607 # get type of given object
1608 sub git_get_type {
1609         my $hash = shift;
1610
1611         open my $fd, "-|", git_cmd(), "cat-file", '-t', $hash or return;
1612         my $type = <$fd>;
1613         close $fd or return;
1614         chomp $type;
1615         return $type;
1616 }
1617
1618 # repository configuration
1619 our $config_file = '';
1620 our %config;
1621
1622 # store multiple values for single key as anonymous array reference
1623 # single values stored directly in the hash, not as [ <value> ]
1624 sub hash_set_multi {
1625         my ($hash, $key, $value) = @_;
1626
1627         if (!exists $hash->{$key}) {
1628                 $hash->{$key} = $value;
1629         } elsif (!ref $hash->{$key}) {
1630                 $hash->{$key} = [ $hash->{$key}, $value ];
1631         } else {
1632                 push @{$hash->{$key}}, $value;
1633         }
1634 }
1635
1636 # return hash of git project configuration
1637 # optionally limited to some section, e.g. 'gitweb'
1638 sub git_parse_project_config {
1639         my $section_regexp = shift;
1640         my %config;
1641
1642         local $/ = "\0";
1643
1644         open my $fh, "-|", git_cmd(), "config", '-z', '-l',
1645                 or return;
1646
1647         while (my $keyval = <$fh>) {
1648                 chomp $keyval;
1649                 my ($key, $value) = split(/\n/, $keyval, 2);
1650
1651                 hash_set_multi(\%config, $key, $value)
1652                         if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
1653         }
1654         close $fh;
1655
1656         return %config;
1657 }
1658
1659 # convert config value to boolean, 'true' or 'false'
1660 # no value, number > 0, 'true' and 'yes' values are true
1661 # rest of values are treated as false (never as error)
1662 sub config_to_bool {
1663         my $val = shift;
1664
1665         # strip leading and trailing whitespace
1666         $val =~ s/^\s+//;
1667         $val =~ s/\s+$//;
1668
1669         return (!defined $val ||               # section.key
1670                 ($val =~ /^\d+$/ && $val) ||   # section.key = 1
1671                 ($val =~ /^(?:true|yes)$/i));  # section.key = true
1672 }
1673
1674 # convert config value to simple decimal number
1675 # an optional value suffix of 'k', 'm', or 'g' will cause the value
1676 # to be multiplied by 1024, 1048576, or 1073741824
1677 sub config_to_int {
1678         my $val = shift;
1679
1680         # strip leading and trailing whitespace
1681         $val =~ s/^\s+//;
1682         $val =~ s/\s+$//;
1683
1684         if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
1685                 $unit = lc($unit);
1686                 # unknown unit is treated as 1
1687                 return $num * ($unit eq 'g' ? 1073741824 :
1688                                $unit eq 'm' ?    1048576 :
1689                                $unit eq 'k' ?       1024 : 1);
1690         }
1691         return $val;
1692 }
1693
1694 # convert config value to array reference, if needed
1695 sub config_to_multi {
1696         my $val = shift;
1697
1698         return ref($val) ? $val : (defined($val) ? [ $val ] : []);
1699 }
1700
1701 sub git_get_project_config {
1702         my ($key, $type) = @_;
1703
1704         # key sanity check
1705         return unless ($key);
1706         $key =~ s/^gitweb\.//;
1707         return if ($key =~ m/\W/);
1708
1709         # type sanity check
1710         if (defined $type) {
1711                 $type =~ s/^--//;
1712                 $type = undef
1713                         unless ($type eq 'bool' || $type eq 'int');
1714         }
1715
1716         # get config
1717         if (!defined $config_file ||
1718             $config_file ne "$git_dir/config") {
1719                 %config = git_parse_project_config('gitweb');
1720                 $config_file = "$git_dir/config";
1721         }
1722
1723         # ensure given type
1724         if (!defined $type) {
1725                 return $config{"gitweb.$key"};
1726         } elsif ($type eq 'bool') {
1727                 # backward compatibility: 'git config --bool' returns true/false
1728                 return config_to_bool($config{"gitweb.$key"}) ? 'true' : 'false';
1729         } elsif ($type eq 'int') {
1730                 return config_to_int($config{"gitweb.$key"});
1731         }
1732         return $config{"gitweb.$key"};
1733 }
1734
1735 # get hash of given path at given ref
1736 sub git_get_hash_by_path {
1737         my $base = shift;
1738         my $path = shift || return undef;
1739         my $type = shift;
1740
1741         $path =~ s,/+$,,;
1742
1743         open my $fd, "-|", git_cmd(), "ls-tree", $base, "--", $path
1744                 or die_error(500, "Open git-ls-tree failed");
1745         my $line = <$fd>;
1746         close $fd or return undef;
1747
1748         if (!defined $line) {
1749                 # there is no tree or hash given by $path at $base
1750                 return undef;
1751         }
1752
1753         #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
1754         $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
1755         if (defined $type && $type ne $2) {
1756                 # type doesn't match
1757                 return undef;
1758         }
1759         return $3;
1760 }
1761
1762 # get path of entry with given hash at given tree-ish (ref)
1763 # used to get 'from' filename for combined diff (merge commit) for renames
1764 sub git_get_path_by_hash {
1765         my $base = shift || return;
1766         my $hash = shift || return;
1767
1768         local $/ = "\0";
1769
1770         open my $fd, "-|", git_cmd(), "ls-tree", '-r', '-t', '-z', $base
1771                 or return undef;
1772         while (my $line = <$fd>) {
1773                 chomp $line;
1774
1775                 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423  gitweb'
1776                 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f  gitweb/README'
1777                 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
1778                         close $fd;
1779                         return $1;
1780                 }
1781         }
1782         close $fd;
1783         return undef;
1784 }
1785
1786 ## ......................................................................
1787 ## git utility functions, directly accessing git repository
1788
1789 sub git_get_project_description {
1790         my $path = shift;
1791
1792         $git_dir = "$projectroot/$path";
1793         open my $fd, "$git_dir/description"
1794                 or return git_get_project_config('description');
1795         my $descr = <$fd>;
1796         close $fd;
1797         if (defined $descr) {
1798                 chomp $descr;
1799         }
1800         return $descr;
1801 }
1802
1803 sub git_get_project_ctags {
1804         my $path = shift;
1805         my $ctags = {};
1806
1807         $git_dir = "$projectroot/$path";
1808         foreach (<$git_dir/ctags/*>) {
1809                 open CT, $_ or next;
1810                 my $val = <CT>;
1811                 chomp $val;
1812                 close CT;
1813                 my $ctag = $_; $ctag =~ s#.*/##;
1814                 $ctags->{$ctag} = $val;
1815         }
1816         $ctags;
1817 }
1818
1819 sub git_populate_project_tagcloud {
1820         my $ctags = shift;
1821
1822         # First, merge different-cased tags; tags vote on casing
1823         my %ctags_lc;
1824         foreach (keys %$ctags) {
1825                 $ctags_lc{lc $_}->{count} += $ctags->{$_};
1826                 if (not $ctags_lc{lc $_}->{topcount}
1827                     or $ctags_lc{lc $_}->{topcount} < $ctags->{$_}) {
1828                         $ctags_lc{lc $_}->{topcount} = $ctags->{$_};
1829                         $ctags_lc{lc $_}->{topname} = $_;
1830                 }
1831         }
1832
1833         my $cloud;
1834         if (eval { require HTML::TagCloud; 1; }) {
1835                 $cloud = HTML::TagCloud->new;
1836                 foreach (sort keys %ctags_lc) {
1837                         # Pad the title with spaces so that the cloud looks
1838                         # less crammed.
1839                         my $title = $ctags_lc{$_}->{topname};
1840                         $title =~ s/ /&nbsp;/g;
1841                         $title =~ s/^/&nbsp;/g;
1842                         $title =~ s/$/&nbsp;/g;
1843                         $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count});
1844                 }
1845         } else {
1846                 $cloud = \%ctags_lc;
1847         }
1848         $cloud;
1849 }
1850
1851 sub git_show_project_tagcloud {
1852         my ($cloud, $count) = @_;
1853         print STDERR ref($cloud)."..\n";
1854         if (ref $cloud eq 'HTML::TagCloud') {
1855                 return $cloud->html_and_css($count);
1856         } else {
1857                 my @tags = sort { $cloud->{$a}->{count} <=> $cloud->{$b}->{count} } keys %$cloud;
1858                 return '<p align="center">' . join (', ', map {
1859                         "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
1860                 } splice(@tags, 0, $count)) . '</p>';
1861         }
1862 }
1863
1864 sub git_get_project_url_list {
1865         my $path = shift;
1866
1867         $git_dir = "$projectroot/$path";
1868         open my $fd, "$git_dir/cloneurl"
1869                 or return wantarray ?
1870                 @{ config_to_multi(git_get_project_config('url')) } :
1871                    config_to_multi(git_get_project_config('url'));
1872         my @git_project_url_list = map { chomp; $_ } <$fd>;
1873         close $fd;
1874
1875         return wantarray ? @git_project_url_list : \@git_project_url_list;
1876 }
1877
1878 sub git_get_projects_list {
1879         my ($filter) = @_;
1880         my @list;
1881
1882         $filter ||= '';
1883         $filter =~ s/\.git$//;
1884
1885         my ($check_forks) = gitweb_check_feature('forks');
1886
1887         if (-d $projects_list) {
1888                 # search in directory
1889                 my $dir = $projects_list . ($filter ? "/$filter" : '');
1890                 # remove the trailing "/"
1891                 $dir =~ s!/+$!!;
1892                 my $pfxlen = length("$dir");
1893                 my $pfxdepth = ($dir =~ tr!/!!);
1894
1895                 File::Find::find({
1896                         follow_fast => 1, # follow symbolic links
1897                         follow_skip => 2, # ignore duplicates
1898                         dangling_symlinks => 0, # ignore dangling symlinks, silently
1899                         wanted => sub {
1900                                 # skip project-list toplevel, if we get it.
1901                                 return if (m!^[/.]$!);
1902                                 # only directories can be git repositories
1903                                 return unless (-d $_);
1904                                 # don't traverse too deep (Find is super slow on os x)
1905                                 if (($File::Find::name =~ tr!/!!) - $pfxdepth > $project_maxdepth) {
1906                                         $File::Find::prune = 1;
1907                                         return;
1908                                 }
1909
1910                                 my $subdir = substr($File::Find::name, $pfxlen + 1);
1911                                 # we check related file in $projectroot
1912                                 if (check_export_ok("$projectroot/$filter/$subdir")) {
1913                                         push @list, { path => ($filter ? "$filter/" : '') . $subdir };
1914                                         $File::Find::prune = 1;
1915                                 }
1916                         },
1917                 }, "$dir");
1918
1919         } elsif (-f $projects_list) {
1920                 # read from file(url-encoded):
1921                 # 'git%2Fgit.git Linus+Torvalds'
1922                 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
1923                 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
1924                 my %paths;
1925                 open my ($fd), $projects_list or return;
1926         PROJECT:
1927                 while (my $line = <$fd>) {
1928                         chomp $line;
1929                         my ($path, $owner) = split ' ', $line;
1930                         $path = unescape($path);
1931                         $owner = unescape($owner);
1932                         if (!defined $path) {
1933                                 next;
1934                         }
1935                         if ($filter ne '') {
1936                                 # looking for forks;
1937                                 my $pfx = substr($path, 0, length($filter));
1938                                 if ($pfx ne $filter) {
1939                                         next PROJECT;
1940                                 }
1941                                 my $sfx = substr($path, length($filter));
1942                                 if ($sfx !~ /^\/.*\.git$/) {
1943                                         next PROJECT;
1944                                 }
1945                         } elsif ($check_forks) {
1946                         PATH:
1947                                 foreach my $filter (keys %paths) {
1948                                         # looking for forks;
1949                                         my $pfx = substr($path, 0, length($filter));
1950                                         if ($pfx ne $filter) {
1951                                                 next PATH;
1952                                         }
1953                                         my $sfx = substr($path, length($filter));
1954                                         if ($sfx !~ /^\/.*\.git$/) {
1955                                                 next PATH;
1956                                         }
1957                                         # is a fork, don't include it in
1958                                         # the list
1959                                         next PROJECT;
1960                                 }
1961                         }
1962                         if (check_export_ok("$projectroot/$path")) {
1963                                 my $pr = {
1964                                         path => $path,
1965                                         owner => to_utf8($owner),
1966                                 };
1967                                 push @list, $pr;
1968                                 (my $forks_path = $path) =~ s/\.git$//;
1969                                 $paths{$forks_path}++;
1970                         }
1971                 }
1972                 close $fd;
1973         }
1974         return @list;
1975 }
1976
1977 our $gitweb_project_owner = undef;
1978 sub git_get_project_list_from_file {
1979
1980         return if (defined $gitweb_project_owner);
1981
1982         $gitweb_project_owner = {};
1983         # read from file (url-encoded):
1984         # 'git%2Fgit.git Linus+Torvalds'
1985         # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
1986         # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
1987         if (-f $projects_list) {
1988                 open (my $fd , $projects_list);
1989                 while (my $line = <$fd>) {
1990                         chomp $line;
1991                         my ($pr, $ow) = split ' ', $line;
1992                         $pr = unescape($pr);
1993                         $ow = unescape($ow);
1994                         $gitweb_project_owner->{$pr} = to_utf8($ow);
1995                 }
1996                 close $fd;
1997         }
1998 }
1999
2000 sub git_get_project_owner {
2001         my $project = shift;
2002         my $owner;
2003
2004         return undef unless $project;
2005         $git_dir = "$projectroot/$project";
2006
2007         if (!defined $gitweb_project_owner) {
2008                 git_get_project_list_from_file();
2009         }
2010
2011         if (exists $gitweb_project_owner->{$project}) {
2012                 $owner = $gitweb_project_owner->{$project};
2013         }
2014         if (!defined $owner){
2015                 $owner = git_get_project_config('owner');
2016         }
2017         if (!defined $owner) {
2018                 $owner = get_file_owner("$git_dir");
2019         }
2020
2021         return $owner;
2022 }
2023
2024 sub git_get_last_activity {
2025         my ($path) = @_;
2026         my $fd;
2027
2028         $git_dir = "$projectroot/$path";
2029         open($fd, "-|", git_cmd(), 'for-each-ref',
2030              '--format=%(committer)',
2031              '--sort=-committerdate',
2032              '--count=1',
2033              'refs/heads') or return;
2034         my $most_recent = <$fd>;
2035         close $fd or return;
2036         if (defined $most_recent &&
2037             $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2038                 my $timestamp = $1;
2039                 my $age = time - $timestamp;
2040                 return ($age, age_string($age));
2041         }
2042         return (undef, undef);
2043 }
2044
2045 sub git_get_references {
2046         my $type = shift || "";
2047         my %refs;
2048         # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2049         # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2050         open my $fd, "-|", git_cmd(), "show-ref", "--dereference",
2051                 ($type ? ("--", "refs/$type") : ()) # use -- <pattern> if $type
2052                 or return;
2053
2054         while (my $line = <$fd>) {
2055                 chomp $line;
2056                 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2057                         if (defined $refs{$1}) {
2058                                 push @{$refs{$1}}, $2;
2059                         } else {
2060                                 $refs{$1} = [ $2 ];
2061                         }
2062                 }
2063         }
2064         close $fd or return;
2065         return \%refs;
2066 }
2067
2068 sub git_get_rev_name_tags {
2069         my $hash = shift || return undef;
2070
2071         open my $fd, "-|", git_cmd(), "name-rev", "--tags", $hash
2072                 or return;
2073         my $name_rev = <$fd>;
2074         close $fd;
2075
2076         if ($name_rev =~ m|^$hash tags/(.*)$|) {
2077                 return $1;
2078         } else {
2079                 # catches also '$hash undefined' output
2080                 return undef;
2081         }
2082 }
2083
2084 ## ----------------------------------------------------------------------
2085 ## parse to hash functions
2086
2087 sub parse_date {
2088         my $epoch = shift;
2089         my $tz = shift || "-0000";
2090
2091         my %date;
2092         my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2093         my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2094         my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2095         $date{'hour'} = $hour;
2096         $date{'minute'} = $min;
2097         $date{'mday'} = $mday;
2098         $date{'day'} = $days[$wday];
2099         $date{'month'} = $months[$mon];
2100         $date{'rfc2822'}   = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2101                              $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2102         $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2103                              $mday, $months[$mon], $hour ,$min;
2104         $date{'iso-8601'}  = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2105                              1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2106
2107         $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2108         my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2109         ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2110         $date{'hour_local'} = $hour;
2111         $date{'minute_local'} = $min;
2112         $date{'tz_local'} = $tz;
2113         $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2114                                   1900+$year, $mon+1, $mday,
2115                                   $hour, $min, $sec, $tz);
2116         return %date;
2117 }
2118
2119 sub parse_tag {
2120         my $tag_id = shift;
2121         my %tag;
2122         my @comment;
2123
2124         open my $fd, "-|", git_cmd(), "cat-file", "tag", $tag_id or return;
2125         $tag{'id'} = $tag_id;
2126         while (my $line = <$fd>) {
2127                 chomp $line;
2128                 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2129                         $tag{'object'} = $1;
2130                 } elsif ($line =~ m/^type (.+)$/) {
2131                         $tag{'type'} = $1;
2132                 } elsif ($line =~ m/^tag (.+)$/) {
2133                         $tag{'name'} = $1;
2134                 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2135                         $tag{'author'} = $1;
2136                         $tag{'epoch'} = $2;
2137                         $tag{'tz'} = $3;
2138                 } elsif ($line =~ m/--BEGIN/) {
2139                         push @comment, $line;
2140                         last;
2141                 } elsif ($line eq "") {
2142                         last;
2143                 }
2144         }
2145         push @comment, <$fd>;
2146         $tag{'comment'} = \@comment;
2147         close $fd or return;
2148         if (!defined $tag{'name'}) {
2149                 return
2150         };
2151         return %tag
2152 }
2153
2154 sub parse_commit_text {
2155         my ($commit_text, $withparents) = @_;
2156         my @commit_lines = split '\n', $commit_text;
2157         my %co;
2158
2159         pop @commit_lines; # Remove '\0'
2160
2161         if (! @commit_lines) {
2162                 return;
2163         }
2164
2165         my $header = shift @commit_lines;
2166         if ($header !~ m/^[0-9a-fA-F]{40}/) {
2167                 return;
2168         }
2169         ($co{'id'}, my @parents) = split ' ', $header;
2170         while (my $line = shift @commit_lines) {
2171                 last if $line eq "\n";
2172                 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2173                         $co{'tree'} = $1;
2174                 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2175                         push @parents, $1;
2176                 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2177                         $co{'author'} = $1;
2178                         $co{'author_epoch'} = $2;
2179                         $co{'author_tz'} = $3;
2180                         if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2181                                 $co{'author_name'}  = $1;
2182                                 $co{'author_email'} = $2;
2183                         } else {
2184                                 $co{'author_name'} = $co{'author'};
2185                         }
2186                 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2187                         $co{'committer'} = $1;
2188                         $co{'committer_epoch'} = $2;
2189                         $co{'committer_tz'} = $3;
2190                         $co{'committer_name'} = $co{'committer'};
2191                         if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2192                                 $co{'committer_name'}  = $1;
2193                                 $co{'committer_email'} = $2;
2194                         } else {
2195                                 $co{'committer_name'} = $co{'committer'};
2196                         }
2197                 }
2198         }
2199         if (!defined $co{'tree'}) {
2200                 return;
2201         };
2202         $co{'parents'} = \@parents;
2203         $co{'parent'} = $parents[0];
2204
2205         foreach my $title (@commit_lines) {
2206                 $title =~ s/^    //;
2207                 if ($title ne "") {
2208                         $co{'title'} = chop_str($title, 80, 5);
2209                         # remove leading stuff of merges to make the interesting part visible
2210                         if (length($title) > 50) {
2211                                 $title =~ s/^Automatic //;
2212                                 $title =~ s/^merge (of|with) /Merge ... /i;
2213                                 if (length($title) > 50) {
2214                                         $title =~ s/(http|rsync):\/\///;
2215                                 }
2216                                 if (length($title) > 50) {
2217                                         $title =~ s/(master|www|rsync)\.//;
2218                                 }
2219                                 if (length($title) > 50) {
2220                                         $title =~ s/kernel.org:?//;
2221                                 }
2222                                 if (length($title) > 50) {
2223                                         $title =~ s/\/pub\/scm//;
2224                                 }
2225                         }
2226                         $co{'title_short'} = chop_str($title, 50, 5);
2227                         last;
2228                 }
2229         }
2230         if (! defined $co{'title'} || $co{'title'} eq "") {
2231                 $co{'title'} = $co{'title_short'} = '(no commit message)';
2232         }
2233         # remove added spaces
2234         foreach my $line (@commit_lines) {
2235                 $line =~ s/^    //;
2236         }
2237         $co{'comment'} = \@commit_lines;
2238
2239         my $age = time - $co{'committer_epoch'};
2240         $co{'age'} = $age;
2241         $co{'age_string'} = age_string($age);
2242         my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2243         if ($age > 60*60*24*7*2) {
2244                 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2245                 $co{'age_string_age'} = $co{'age_string'};
2246         } else {
2247                 $co{'age_string_date'} = $co{'age_string'};
2248                 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2249         }
2250         return %co;
2251 }
2252
2253 sub parse_commit {
2254         my ($commit_id) = @_;
2255         my %co;
2256
2257         local $/ = "\0";
2258
2259         open my $fd, "-|", git_cmd(), "rev-list",
2260                 "--parents",
2261                 "--header",
2262                 "--max-count=1",
2263                 $commit_id,
2264                 "--",
2265                 or die_error(500, "Open git-rev-list failed");
2266         %co = parse_commit_text(<$fd>, 1);
2267         close $fd;
2268
2269         return %co;
2270 }
2271
2272 sub parse_commits {
2273         my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
2274         my @cos;
2275
2276         $maxcount ||= 1;
2277         $skip ||= 0;
2278
2279         local $/ = "\0";
2280
2281         open my $fd, "-|", git_cmd(), "rev-list",
2282                 "--header",
2283                 @args,
2284                 ("--max-count=" . $maxcount),
2285                 ("--skip=" . $skip),
2286                 @extra_options,
2287                 $commit_id,
2288                 "--",
2289                 ($filename ? ($filename) : ())
2290                 or die_error(500, "Open git-rev-list failed");
2291         while (my $line = <$fd>) {
2292                 my %co = parse_commit_text($line);
2293                 push @cos, \%co;
2294         }
2295         close $fd;
2296
2297         return wantarray ? @cos : \@cos;
2298 }
2299
2300 # parse line of git-diff-tree "raw" output
2301 sub parse_difftree_raw_line {
2302         my $line = shift;
2303         my %res;
2304
2305         # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M   ls-files.c'
2306         # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M   rev-tree.c'
2307         if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
2308                 $res{'from_mode'} = $1;
2309                 $res{'to_mode'} = $2;
2310                 $res{'from_id'} = $3;
2311                 $res{'to_id'} = $4;
2312                 $res{'status'} = $5;
2313                 $res{'similarity'} = $6;
2314                 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
2315                         ($res{'from_file'}, $res{'to_file'}) = map { unquote($_) } split("\t", $7);
2316                 } else {
2317                         $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote($7);
2318                 }
2319         }
2320         # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
2321         # combined diff (for merge commit)
2322         elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
2323                 $res{'nparents'}  = length($1);
2324                 $res{'from_mode'} = [ split(' ', $2) ];
2325                 $res{'to_mode'} = pop @{$res{'from_mode'}};
2326                 $res{'from_id'} = [ split(' ', $3) ];
2327                 $res{'to_id'} = pop @{$res{'from_id'}};
2328                 $res{'status'} = [ split('', $4) ];
2329                 $res{'to_file'} = unquote($5);
2330         }
2331         # 'c512b523472485aef4fff9e57b229d9d243c967f'
2332         elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
2333                 $res{'commit'} = $1;
2334         }
2335
2336         return wantarray ? %res : \%res;
2337 }
2338
2339 # wrapper: return parsed line of git-diff-tree "raw" output
2340 # (the argument might be raw line, or parsed info)
2341 sub parsed_difftree_line {
2342         my $line_or_ref = shift;
2343
2344         if (ref($line_or_ref) eq "HASH") {
2345                 # pre-parsed (or generated by hand)
2346                 return $line_or_ref;
2347         } else {
2348                 return parse_difftree_raw_line($line_or_ref);
2349         }
2350 }
2351
2352 # parse line of git-ls-tree output
2353 sub parse_ls_tree_line ($;%) {
2354         my $line = shift;
2355         my %opts = @_;
2356         my %res;
2357
2358         #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
2359         $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
2360
2361         $res{'mode'} = $1;
2362         $res{'type'} = $2;
2363         $res{'hash'} = $3;
2364         if ($opts{'-z'}) {
2365                 $res{'name'} = $4;
2366         } else {
2367                 $res{'name'} = unquote($4);
2368         }
2369
2370         return wantarray ? %res : \%res;
2371 }
2372
2373 # generates _two_ hashes, references to which are passed as 2 and 3 argument
2374 sub parse_from_to_diffinfo {
2375         my ($diffinfo, $from, $to, @parents) = @_;
2376
2377         if ($diffinfo->{'nparents'}) {
2378                 # combined diff
2379                 $from->{'file'} = [];
2380                 $from->{'href'} = [];
2381                 fill_from_file_info($diffinfo, @parents)
2382                         unless exists $diffinfo->{'from_file'};
2383                 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2384                         $from->{'file'}[$i] =
2385                                 defined $diffinfo->{'from_file'}[$i] ?
2386                                         $diffinfo->{'from_file'}[$i] :
2387                                         $diffinfo->{'to_file'};
2388                         if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
2389                                 $from->{'href'}[$i] = href(action=>"blob",
2390                                                            hash_base=>$parents[$i],
2391                                                            hash=>$diffinfo->{'from_id'}[$i],
2392                                                            file_name=>$from->{'file'}[$i]);
2393                         } else {
2394                                 $from->{'href'}[$i] = undef;
2395                         }
2396                 }
2397         } else {
2398                 # ordinary (not combined) diff
2399                 $from->{'file'} = $diffinfo->{'from_file'};
2400                 if ($diffinfo->{'status'} ne "A") { # not new (added) file
2401                         $from->{'href'} = href(action=>"blob", hash_base=>$hash_parent,
2402                                                hash=>$diffinfo->{'from_id'},
2403                                                file_name=>$from->{'file'});
2404                 } else {
2405                         delete $from->{'href'};
2406                 }
2407         }
2408
2409         $to->{'file'} = $diffinfo->{'to_file'};
2410         if (!is_deleted($diffinfo)) { # file exists in result
2411                 $to->{'href'} = href(action=>"blob", hash_base=>$hash,
2412                                      hash=>$diffinfo->{'to_id'},
2413                                      file_name=>$to->{'file'});
2414         } else {
2415                 delete $to->{'href'};
2416         }
2417 }
2418
2419 ## ......................................................................
2420 ## parse to array of hashes functions
2421
2422 sub git_get_heads_list {
2423         my $limit = shift;
2424         my @headslist;
2425
2426         open my $fd, '-|', git_cmd(), 'for-each-ref',
2427                 ($limit ? '--count='.($limit+1) : ()), '--sort=-committerdate',
2428                 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
2429                 'refs/heads'
2430                 or return;
2431         while (my $line = <$fd>) {
2432                 my %ref_item;
2433
2434                 chomp $line;
2435                 my ($refinfo, $committerinfo) = split(/\0/, $line);
2436                 my ($hash, $name, $title) = split(' ', $refinfo, 3);
2437                 my ($committer, $epoch, $tz) =
2438                         ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
2439                 $ref_item{'fullname'}  = $name;
2440                 $name =~ s!^refs/heads/!!;
2441
2442                 $ref_item{'name'}  = $name;
2443                 $ref_item{'id'}    = $hash;
2444                 $ref_item{'title'} = $title || '(no commit message)';
2445                 $ref_item{'epoch'} = $epoch;
2446                 if ($epoch) {
2447                         $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
2448                 } else {
2449                         $ref_item{'age'} = "unknown";
2450                 }
2451
2452                 push @headslist, \%ref_item;
2453         }
2454         close $fd;
2455
2456         return wantarray ? @headslist : \@headslist;
2457 }
2458
2459 sub git_get_tags_list {
2460         my $limit = shift;
2461         my @tagslist;
2462
2463         open my $fd, '-|', git_cmd(), 'for-each-ref',
2464                 ($limit ? '--count='.($limit+1) : ()), '--sort=-creatordate',
2465                 '--format=%(objectname) %(objecttype) %(refname) '.
2466                 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
2467                 'refs/tags'
2468                 or return;
2469         while (my $line = <$fd>) {
2470                 my %ref_item;
2471
2472                 chomp $line;
2473                 my ($refinfo, $creatorinfo) = split(/\0/, $line);
2474                 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
2475                 my ($creator, $epoch, $tz) =
2476                         ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
2477                 $ref_item{'fullname'} = $name;
2478                 $name =~ s!^refs/tags/!!;
2479
2480                 $ref_item{'type'} = $type;
2481                 $ref_item{'id'} = $id;
2482                 $ref_item{'name'} = $name;
2483                 if ($type eq "tag") {
2484                         $ref_item{'subject'} = $title;
2485                         $ref_item{'reftype'} = $reftype;
2486                         $ref_item{'refid'}   = $refid;
2487                 } else {
2488                         $ref_item{'reftype'} = $type;
2489                         $ref_item{'refid'}   = $id;
2490                 }
2491
2492                 if ($type eq "tag" || $type eq "commit") {
2493                         $ref_item{'epoch'} = $epoch;
2494                         if ($epoch) {
2495                                 $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
2496                         } else {
2497                                 $ref_item{'age'} = "unknown";
2498                         }
2499                 }
2500
2501                 push @tagslist, \%ref_item;
2502         }
2503         close $fd;
2504
2505         return wantarray ? @tagslist : \@tagslist;
2506 }
2507
2508 ## ----------------------------------------------------------------------
2509 ## filesystem-related functions
2510
2511 sub get_file_owner {
2512         my $path = shift;
2513
2514         my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
2515         my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
2516         if (!defined $gcos) {
2517                 return undef;
2518         }
2519         my $owner = $gcos;
2520         $owner =~ s/[,;].*$//;
2521         return to_utf8($owner);
2522 }
2523
2524 ## ......................................................................
2525 ## mimetype related functions
2526
2527 sub mimetype_guess_file {
2528         my $filename = shift;
2529         my $mimemap = shift;
2530         -r $mimemap or return undef;
2531
2532         my %mimemap;
2533         open(MIME, $mimemap) or return undef;
2534         while (<MIME>) {
2535                 next if m/^#/; # skip comments
2536                 my ($mime, $exts) = split(/\t+/);
2537                 if (defined $exts) {
2538                         my @exts = split(/\s+/, $exts);
2539                         foreach my $ext (@exts) {
2540                                 $mimemap{$ext} = $mime;
2541                         }
2542                 }
2543         }
2544         close(MIME);
2545
2546         $filename =~ /\.([^.]*)$/;
2547         return $mimemap{$1};
2548 }
2549
2550 sub mimetype_guess {
2551         my $filename = shift;
2552         my $mime;
2553         $filename =~ /\./ or return undef;
2554
2555         if ($mimetypes_file) {
2556                 my $file = $mimetypes_file;
2557                 if ($file !~ m!^/!) { # if it is relative path
2558                         # it is relative to project
2559                         $file = "$projectroot/$project/$file";
2560                 }
2561                 $mime = mimetype_guess_file($filename, $file);
2562         }
2563         $mime ||= mimetype_guess_file($filename, '/etc/mime.types');
2564         return $mime;
2565 }
2566
2567 sub blob_mimetype {
2568         my $fd = shift;
2569         my $filename = shift;
2570
2571         if ($filename) {
2572                 my $mime = mimetype_guess($filename);
2573                 $mime and return $mime;
2574         }
2575
2576         # just in case
2577         return $default_blob_plain_mimetype unless $fd;
2578
2579         if (-T $fd) {
2580                 return 'text/plain';
2581         } elsif (! $filename) {
2582                 return 'application/octet-stream';
2583         } elsif ($filename =~ m/\.png$/i) {
2584                 return 'image/png';
2585         } elsif ($filename =~ m/\.gif$/i) {
2586                 return 'image/gif';
2587         } elsif ($filename =~ m/\.jpe?g$/i) {
2588                 return 'image/jpeg';
2589         } else {
2590                 return 'application/octet-stream';
2591         }
2592 }
2593
2594 sub blob_contenttype {
2595         my ($fd, $file_name, $type) = @_;
2596
2597         $type ||= blob_mimetype($fd, $file_name);
2598         if ($type eq 'text/plain' && defined $default_text_plain_charset) {
2599                 $type .= "; charset=$default_text_plain_charset";
2600         }
2601
2602         return $type;
2603 }
2604
2605 ## ======================================================================
2606 ## functions printing HTML: header, footer, error page
2607
2608 sub git_header_html {
2609         my $status = shift || "200 OK";
2610         my $expires = shift;
2611
2612         my $title = "$site_name";
2613         if (defined $project) {
2614                 $title .= " - " . to_utf8($project);
2615                 if (defined $action) {
2616                         $title .= "/$action";
2617                         if (defined $file_name) {
2618                                 $title .= " - " . esc_path($file_name);
2619                                 if ($action eq "tree" && $file_name !~ m|/$|) {
2620                                         $title .= "/";
2621                                 }
2622                         }
2623                 }
2624         }
2625         my $content_type;
2626         # require explicit support from the UA if we are to send the page as
2627         # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
2628         # we have to do this because MSIE sometimes globs '*/*', pretending to
2629         # support xhtml+xml but choking when it gets what it asked for.
2630         if (defined $cgi->http('HTTP_ACCEPT') &&
2631             $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\+xml(,|;|\s|$)/ &&
2632             $cgi->Accept('application/xhtml+xml') != 0) {
2633                 $content_type = 'application/xhtml+xml';
2634         } else {
2635                 $content_type = 'text/html';
2636         }
2637         print $cgi->header(-type=>$content_type, -charset => 'utf-8',
2638                            -status=> $status, -expires => $expires);
2639         my $mod_perl_version = $ENV{'MOD_PERL'} ? " $ENV{'MOD_PERL'}" : '';
2640         print <<EOF;
2641 <?xml version="1.0" encoding="utf-8"?>
2642 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2643 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
2644 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
2645 <!-- git core binaries version $git_version -->
2646 <head>
2647 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
2648 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
2649 <meta name="robots" content="index, nofollow"/>
2650 <title>$title</title>
2651 EOF
2652 # print out each stylesheet that exist
2653         if (defined $stylesheet) {
2654 #provides backwards capability for those people who define style sheet in a config file
2655                 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2656         } else {
2657                 foreach my $stylesheet (@stylesheets) {
2658                         next unless $stylesheet;
2659                         print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2660                 }
2661         }
2662         if (defined $project) {
2663                 my %href_params = get_feed_info();
2664                 if (!exists $href_params{'-title'}) {
2665                         $href_params{'-title'} = 'log';
2666                 }
2667
2668                 foreach my $format qw(RSS Atom) {
2669                         my $type = lc($format);
2670                         my %link_attr = (
2671                                 '-rel' => 'alternate',
2672                                 '-title' => "$project - $href_params{'-title'} - $format feed",
2673                                 '-type' => "application/$type+xml"
2674                         );
2675
2676                         $href_params{'action'} = $type;
2677                         $link_attr{'-href'} = href(%href_params);
2678                         print "<link ".
2679                               "rel=\"$link_attr{'-rel'}\" ".
2680                               "title=\"$link_attr{'-title'}\" ".
2681                               "href=\"$link_attr{'-href'}\" ".
2682                               "type=\"$link_attr{'-type'}\" ".
2683                               "/>\n";
2684
2685                         $href_params{'extra_options'} = '--no-merges';
2686                         $link_attr{'-href'} = href(%href_params);
2687                         $link_attr{'-title'} .= ' (no merges)';
2688                         print "<link ".
2689                               "rel=\"$link_attr{'-rel'}\" ".
2690                               "title=\"$link_attr{'-title'}\" ".
2691                               "href=\"$link_attr{'-href'}\" ".
2692                               "type=\"$link_attr{'-type'}\" ".
2693                               "/>\n";
2694                 }
2695
2696         } else {
2697                 printf('<link rel="alternate" title="%s projects list" '.
2698                        'href="%s" type="text/plain; charset=utf-8" />'."\n",
2699                        $site_name, href(project=>undef, action=>"project_index"));
2700                 printf('<link rel="alternate" title="%s projects feeds" '.
2701                        'href="%s" type="text/x-opml" />'."\n",
2702                        $site_name, href(project=>undef, action=>"opml"));
2703         }
2704         if (defined $favicon) {
2705                 print qq(<link rel="shortcut icon" href="$favicon" type="image/png" />\n);
2706         }
2707
2708         print "</head>\n" .
2709               "<body>\n";
2710
2711         if (-f $site_header) {
2712                 open (my $fd, $site_header);
2713                 print <$fd>;
2714                 close $fd;
2715         }
2716
2717         print "<div class=\"page_header\">\n" .
2718               $cgi->a({-href => esc_url($logo_url),
2719                        -title => $logo_label},
2720                       qq(<img src="$logo" width="72" height="27" alt="git" class="logo"/>));
2721         print $cgi->a({-href => esc_url($home_link)}, $home_link_str) . " / ";
2722         if (defined $project) {
2723                 print $cgi->a({-href => href(action=>"summary")}, esc_html($project));
2724                 if (defined $action) {
2725                         print " / $action";
2726                 }
2727                 print "\n";
2728         }
2729         print "</div>\n";
2730
2731         my ($have_search) = gitweb_check_feature('search');
2732         if (defined $project && $have_search) {
2733                 if (!defined $searchtext) {
2734                         $searchtext = "";
2735                 }
2736                 my $search_hash;
2737                 if (defined $hash_base) {
2738                         $search_hash = $hash_base;
2739                 } elsif (defined $hash) {
2740                         $search_hash = $hash;
2741                 } else {
2742                         $search_hash = "HEAD";
2743                 }
2744                 my $action = $my_uri;
2745                 my ($use_pathinfo) = gitweb_check_feature('pathinfo');
2746                 if ($use_pathinfo) {
2747                         $action .= "/".esc_url($project);
2748                 }
2749                 print $cgi->startform(-method => "get", -action => $action) .
2750                       "<div class=\"search\">\n" .
2751                       (!$use_pathinfo &&
2752                       $cgi->input({-name=>"p", -value=>$project, -type=>"hidden"}) . "\n") .
2753                       $cgi->input({-name=>"a", -value=>"search", -type=>"hidden"}) . "\n" .
2754                       $cgi->input({-name=>"h", -value=>$search_hash, -type=>"hidden"}) . "\n" .
2755                       $cgi->popup_menu(-name => 'st', -default => 'commit',
2756                                        -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
2757                       $cgi->sup($cgi->a({-href => href(action=>"search_help")}, "?")) .
2758                       " search:\n",
2759                       $cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
2760                       "<span title=\"Extended regular expression\">" .
2761                       $cgi->checkbox(-name => 'sr', -value => 1, -label => 're',
2762                                      -checked => $search_use_regexp) .
2763                       "</span>" .
2764                       "</div>" .
2765                       $cgi->end_form() . "\n";
2766         }
2767 }
2768
2769 sub git_footer_html {
2770         my $feed_class = 'rss_logo';
2771
2772         print "<div class=\"page_footer\">\n";
2773         if (defined $project) {
2774                 my $descr = git_get_project_description($project);
2775                 if (defined $descr) {
2776                         print "<div class=\"page_footer_text\">" . esc_html($descr) . "</div>\n";
2777                 }
2778
2779                 my %href_params = get_feed_info();
2780                 if (!%href_params) {
2781                         $feed_class .= ' generic';
2782                 }
2783                 $href_params{'-title'} ||= 'log';
2784
2785                 foreach my $format qw(RSS Atom) {
2786                         $href_params{'action'} = lc($format);
2787                         print $cgi->a({-href => href(%href_params),
2788                                       -title => "$href_params{'-title'} $format feed",
2789                                       -class => $feed_class}, $format)."\n";
2790                 }
2791
2792         } else {
2793                 print $cgi->a({-href => href(project=>undef, action=>"opml"),
2794                               -class => $feed_class}, "OPML") . " ";
2795                 print $cgi->a({-href => href(project=>undef, action=>"project_index"),
2796                               -class => $feed_class}, "TXT") . "\n";
2797         }
2798         print "</div>\n"; # class="page_footer"
2799
2800         if (-f $site_footer) {
2801                 open (my $fd, $site_footer);
2802                 print <$fd>;
2803                 close $fd;
2804         }
2805
2806         print "</body>\n" .
2807               "</html>";
2808 }
2809
2810 # die_error(<http_status_code>, <error_message>)
2811 # Example: die_error(404, 'Hash not found')
2812 # By convention, use the following status codes (as defined in RFC 2616):
2813 # 400: Invalid or missing CGI parameters, or
2814 #      requested object exists but has wrong type.
2815 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
2816 #      this server or project.
2817 # 404: Requested object/revision/project doesn't exist.
2818 # 500: The server isn't configured properly, or
2819 #      an internal error occurred (e.g. failed assertions caused by bugs), or
2820 #      an unknown error occurred (e.g. the git binary died unexpectedly).
2821 sub die_error {
2822         my $status = shift || 500;
2823         my $error = shift || "Internal server error";
2824
2825         my %http_responses = (400 => '400 Bad Request',
2826                               403 => '403 Forbidden',
2827                               404 => '404 Not Found',
2828                               500 => '500 Internal Server Error');
2829         git_header_html($http_responses{$status});
2830         print <<EOF;
2831 <div class="page_body">
2832 <br /><br />
2833 $status - $error
2834 <br />
2835 </div>
2836 EOF
2837         git_footer_html();
2838         exit;
2839 }
2840
2841 ## ----------------------------------------------------------------------
2842 ## functions printing or outputting HTML: navigation
2843
2844 sub git_print_page_nav {
2845         my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
2846         $extra = '' if !defined $extra; # pager or formats
2847
2848         my @navs = qw(summary log commit commitdiff tree);
2849         if ($suppress) {
2850                 @navs = grep { $_ ne $suppress } @navs;
2851         }
2852
2853         my %arg = map { $_ => {action=>$_} } @navs;
2854         if (defined $head) {
2855                 for (qw(commit commitdiff)) {
2856                         $arg{$_}{'hash'} = $head;
2857                 }
2858                 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
2859                         $arg{'log'}{'hash'} = $head;
2860                 }
2861         }
2862
2863         $arg{'log'}{'action'} = 'shortlog';
2864         $arg{'tree'}{'hash'} = $treehead if defined $treehead;
2865         $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
2866
2867         my @actions = gitweb_check_feature('actions');
2868         while (@actions) {
2869                 my ($label, $link, $pos) = (shift(@actions), shift(@actions), shift(@actions));
2870                 @navs = map { $_ eq $pos ? ($_, $label) : $_ } @navs;
2871                 # munch munch
2872                 $link =~ s#%n#$project#g;
2873                 $link =~ s#%f#$git_dir#g;
2874                 $treehead ? $link =~ s#%h#$treehead#g : $link =~ s#%h##g;
2875                 $treebase ? $link =~ s#%b#$treebase#g : $link =~ s#%b##g;
2876                 $arg{$label}{'_href'} = $link;
2877         }
2878
2879         print "<div class=\"page_nav\">\n" .
2880                 (join " | ",
2881                  map { $_ eq $current ?
2882                        $_ : $cgi->a({-href => ($arg{$_}{_href} ? $arg{$_}{_href} : href(%{$arg{$_}}))}, "$_")
2883                  } @navs);
2884         print "<br/>\n$extra<br/>\n" .
2885               "</div>\n";
2886 }
2887
2888 sub format_paging_nav {
2889         my ($action, $hash, $head, $page, $has_next_link) = @_;
2890         my $paging_nav;
2891
2892
2893         if ($hash ne $head || $page) {
2894                 $paging_nav .= $cgi->a({-href => href(action=>$action)}, "HEAD");
2895         } else {
2896                 $paging_nav .= "HEAD";
2897         }
2898
2899         if ($page > 0) {
2900                 $paging_nav .= " &sdot; " .
2901                         $cgi->a({-href => href(-replay=>1, page=>$page-1),
2902                                  -accesskey => "p", -title => "Alt-p"}, "prev");
2903         } else {
2904                 $paging_nav .= " &sdot; prev";
2905         }
2906
2907         if ($has_next_link) {
2908                 $paging_nav .= " &sdot; " .
2909                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
2910                                  -accesskey => "n", -title => "Alt-n"}, "next");
2911         } else {
2912                 $paging_nav .= " &sdot; next";
2913         }
2914
2915         return $paging_nav;
2916 }
2917
2918 sub format_log_nav {
2919         my ($action, $hash, $head, $page, $has_next_link) = @_;
2920         my $paging_nav;
2921
2922         if ($action eq 'shortlog') {
2923                 $paging_nav .= 'shortlog';
2924         } else {
2925                 $paging_nav .= $cgi->a({-href => href(action=>'shortlog', -replay=>1)}, 'shortlog');
2926         }
2927         $paging_nav .= ' | ';
2928         if ($action eq 'log') {
2929                 $paging_nav .= 'fulllog';
2930         } else {
2931                 $paging_nav .= $cgi->a({-href => href(action=>'log', -replay=>1)}, 'fulllog');
2932         }
2933
2934         $paging_nav .= " | " . format_paging_nav($action, $hash, $head, $page, $has_next_link);
2935         return $paging_nav;
2936 }
2937
2938 ## ......................................................................
2939 ## functions printing or outputting HTML: div
2940
2941 sub git_print_header_div {
2942         my ($action, $title, $hash, $hash_base) = @_;
2943         my %args = ();
2944
2945         $args{'action'} = $action;
2946         $args{'hash'} = $hash if $hash;
2947         $args{'hash_base'} = $hash_base if $hash_base;
2948
2949         print "<div class=\"header\">\n" .
2950               $cgi->a({-href => href(%args), -class => "title"},
2951               $title ? $title : $action) .
2952               "\n</div>\n";
2953 }
2954
2955 #sub git_print_authorship (\%) {
2956 sub git_print_authorship {
2957         my $co = shift;
2958
2959         my %ad = parse_date($co->{'author_epoch'}, $co->{'author_tz'});
2960         print "<div class=\"author_date\">" .
2961               esc_html($co->{'author_name'}) .
2962               " [$ad{'rfc2822'}";
2963         if ($ad{'hour_local'} < 6) {
2964                 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
2965                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
2966         } else {
2967                 printf(" (%02d:%02d %s)",
2968                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
2969         }
2970         print "]</div>\n";
2971 }
2972
2973 sub git_print_page_path {
2974         my $name = shift;
2975         my $type = shift;
2976         my $hb = shift;
2977
2978
2979         print "<div class=\"page_path\">";
2980         print $cgi->a({-href => href(action=>"tree", hash_base=>$hb),
2981                       -title => 'tree root'}, to_utf8("[$project]"));
2982         print " / ";
2983         if (defined $name) {
2984                 my @dirname = split '/', $name;
2985                 my $basename = pop @dirname;
2986                 my $fullname = '';
2987
2988                 foreach my $dir (@dirname) {
2989                         $fullname .= ($fullname ? '/' : '') . $dir;
2990                         print $cgi->a({-href => href(action=>"tree", file_name=>$fullname,
2991                                                      hash_base=>$hb),
2992                                       -title => $fullname}, esc_path($dir));
2993                         print " / ";
2994                 }
2995                 if (defined $type && $type eq 'blob') {
2996                         print $cgi->a({-href => href(action=>"blob_plain", file_name=>$file_name,
2997                                                      hash_base=>$hb),
2998                                       -title => $name}, esc_path($basename));
2999                 } elsif (defined $type && $type eq 'tree') {
3000                         print $cgi->a({-href => href(action=>"tree", file_name=>$file_name,
3001                                                      hash_base=>$hb),
3002                                       -title => $name}, esc_path($basename));
3003                         print " / ";
3004                 } else {
3005                         print esc_path($basename);
3006                 }
3007         }
3008         print "<br/></div>\n";
3009 }
3010
3011 # sub git_print_log (\@;%) {
3012 sub git_print_log ($;%) {
3013         my $log = shift;
3014         my %opts = @_;
3015
3016         if ($opts{'-remove_title'}) {
3017                 # remove title, i.e. first line of log
3018                 shift @$log;
3019         }
3020         # remove leading empty lines
3021         while (defined $log->[0] && $log->[0] eq "") {
3022                 shift @$log;
3023         }
3024
3025         # print log
3026         my $signoff = 0;
3027         my $empty = 0;
3028         foreach my $line (@$log) {
3029                 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3030                         $signoff = 1;
3031                         $empty = 0;
3032                         if (! $opts{'-remove_signoff'}) {
3033                                 print "<span class=\"signoff\">" . esc_html($line) . "</span><br/>\n";
3034                                 next;
3035                         } else {
3036                                 # remove signoff lines
3037                                 next;
3038                         }
3039                 } else {
3040                         $signoff = 0;
3041                 }
3042
3043                 # print only one empty line
3044                 # do not print empty line after signoff
3045                 if ($line eq "") {
3046                         next if ($empty || $signoff);
3047                         $empty = 1;
3048                 } else {
3049                         $empty = 0;
3050                 }
3051
3052                 print format_log_line_html($line) . "<br/>\n";
3053         }
3054
3055         if ($opts{'-final_empty_line'}) {
3056                 # end with single empty line
3057                 print "<br/>\n" unless $empty;
3058         }
3059 }
3060
3061 # return link target (what link points to)
3062 sub git_get_link_target {
3063         my $hash = shift;
3064         my $link_target;
3065
3066         # read link
3067         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
3068                 or return;
3069         {
3070                 local $/;
3071                 $link_target = <$fd>;
3072         }
3073         close $fd
3074                 or return;
3075
3076         return $link_target;
3077 }
3078
3079 # given link target, and the directory (basedir) the link is in,
3080 # return target of link relative to top directory (top tree);
3081 # return undef if it is not possible (including absolute links).
3082 sub normalize_link_target {
3083         my ($link_target, $basedir, $hash_base) = @_;
3084
3085         # we can normalize symlink target only if $hash_base is provided
3086         return unless $hash_base;
3087
3088         # absolute symlinks (beginning with '/') cannot be normalized
3089         return if (substr($link_target, 0, 1) eq '/');
3090
3091         # normalize link target to path from top (root) tree (dir)
3092         my $path;
3093         if ($basedir) {
3094                 $path = $basedir . '/' . $link_target;
3095         } else {
3096                 # we are in top (root) tree (dir)
3097                 $path = $link_target;
3098         }
3099
3100         # remove //, /./, and /../
3101         my @path_parts;
3102         foreach my $part (split('/', $path)) {
3103                 # discard '.' and ''
3104                 next if (!$part || $part eq '.');
3105                 # handle '..'
3106                 if ($part eq '..') {
3107                         if (@path_parts) {
3108                                 pop @path_parts;
3109                         } else {
3110                                 # link leads outside repository (outside top dir)
3111                                 return;
3112                         }
3113                 } else {
3114                         push @path_parts, $part;
3115                 }
3116         }
3117         $path = join('/', @path_parts);
3118
3119         return $path;
3120 }
3121
3122 # print tree entry (row of git_tree), but without encompassing <tr> element
3123 sub git_print_tree_entry {
3124         my ($t, $basedir, $hash_base, $have_blame) = @_;
3125
3126         my %base_key = ();
3127         $base_key{'hash_base'} = $hash_base if defined $hash_base;
3128
3129         # The format of a table row is: mode list link.  Where mode is
3130         # the mode of the entry, list is the name of the entry, an href,
3131         # and link is the action links of the entry.
3132
3133         print "<td class=\"mode\">" . mode_str($t->{'mode'}) . "</td>\n";
3134         if ($t->{'type'} eq "blob") {
3135                 print "<td class=\"list\">" .
3136                         $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
3137                                                file_name=>"$basedir$t->{'name'}", %base_key),
3138                                 -class => "list"}, esc_path($t->{'name'}));
3139                 if (S_ISLNK(oct $t->{'mode'})) {
3140                         my $link_target = git_get_link_target($t->{'hash'});
3141                         if ($link_target) {
3142                                 my $norm_target = normalize_link_target($link_target, $basedir, $hash_base);
3143                                 if (defined $norm_target) {
3144                                         print " -> " .
3145                                               $cgi->a({-href => href(action=>"object", hash_base=>$hash_base,
3146                                                                      file_name=>$norm_target),
3147                                                        -title => $norm_target}, esc_path($link_target));
3148                                 } else {
3149                                         print " -> " . esc_path($link_target);
3150                                 }
3151                         }
3152                 }
3153                 print "</td>\n";
3154                 print "<td class=\"link\">";
3155                 print $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
3156                                              file_name=>"$basedir$t->{'name'}", %base_key)},
3157                               "blob");
3158                 if ($have_blame) {
3159                         print " | " .
3160                               $cgi->a({-href => href(action=>"blame", hash=>$t->{'hash'},
3161                                                      file_name=>"$basedir$t->{'name'}", %base_key)},
3162                                       "blame");
3163                 }
3164                 if (defined $hash_base) {
3165                         print " | " .
3166                               $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
3167                                                      hash=>$t->{'hash'}, file_name=>"$basedir$t->{'name'}")},
3168                                       "history");
3169                 }
3170                 print " | " .
3171                         $cgi->a({-href => href(action=>"blob_plain", hash_base=>$hash_base,
3172                                                file_name=>"$basedir$t->{'name'}")},
3173                                 "raw");
3174                 print "</td>\n";
3175
3176         } elsif ($t->{'type'} eq "tree") {
3177                 print "<td class=\"list\">";
3178                 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
3179                                              file_name=>"$basedir$t->{'name'}", %base_key)},
3180                               esc_path($t->{'name'}));
3181                 print "</td>\n";
3182                 print "<td class=\"link\">";
3183                 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
3184                                              file_name=>"$basedir$t->{'name'}", %base_key)},
3185                               "tree");
3186                 if (defined $hash_base) {
3187                         print " | " .
3188                               $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
3189                                                      file_name=>"$basedir$t->{'name'}")},
3190                                       "history");
3191                 }
3192                 print "</td>\n";
3193         } else {
3194                 # unknown object: we can only present history for it
3195                 # (this includes 'commit' object, i.e. submodule support)
3196                 print "<td class=\"list\">" .
3197                       esc_path($t->{'name'}) .
3198                       "</td>\n";
3199                 print "<td class=\"link\">";
3200                 if (defined $hash_base) {
3201                         print $cgi->a({-href => href(action=>"history",
3202                                                      hash_base=>$hash_base,
3203                                                      file_name=>"$basedir$t->{'name'}")},
3204                                       "history");
3205                 }
3206                 print "</td>\n";
3207         }
3208 }
3209
3210 ## ......................................................................
3211 ## functions printing large fragments of HTML
3212
3213 # get pre-image filenames for merge (combined) diff
3214 sub fill_from_file_info {
3215         my ($diff, @parents) = @_;
3216
3217         $diff->{'from_file'} = [ ];
3218         $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
3219         for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3220                 if ($diff->{'status'}[$i] eq 'R' ||
3221                     $diff->{'status'}[$i] eq 'C') {
3222                         $diff->{'from_file'}[$i] =
3223                                 git_get_path_by_hash($parents[$i], $diff->{'from_id'}[$i]);
3224                 }
3225         }
3226
3227         return $diff;
3228 }
3229
3230 # is current raw difftree line of file deletion
3231 sub is_deleted {
3232         my $diffinfo = shift;
3233
3234         return $diffinfo->{'to_id'} eq ('0' x 40);
3235 }
3236
3237 # does patch correspond to [previous] difftree raw line
3238 # $diffinfo  - hashref of parsed raw diff format
3239 # $patchinfo - hashref of parsed patch diff format
3240 #              (the same keys as in $diffinfo)
3241 sub is_patch_split {
3242         my ($diffinfo, $patchinfo) = @_;
3243
3244         return defined $diffinfo && defined $patchinfo
3245                 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
3246 }
3247
3248
3249 sub git_difftree_body {
3250         my ($difftree, $hash, @parents) = @_;
3251         my ($parent) = $parents[0];
3252         my ($have_blame) = gitweb_check_feature('blame');
3253         print "<div class=\"list_head\">\n";
3254         if ($#{$difftree} > 10) {
3255                 print(($#{$difftree} + 1) . " files changed:\n");
3256         }
3257         print "</div>\n";
3258
3259         print "<table class=\"" .
3260               (@parents > 1 ? "combined " : "") .
3261               "diff_tree\">\n";
3262
3263         # header only for combined diff in 'commitdiff' view
3264         my $has_header = @$difftree && @parents > 1 && $action eq 'commitdiff';
3265         if ($has_header) {
3266                 # table header
3267                 print "<thead><tr>\n" .
3268                        "<th></th><th></th>\n"; # filename, patchN link
3269                 for (my $i = 0; $i < @parents; $i++) {
3270                         my $par = $parents[$i];
3271                         print "<th>" .
3272                               $cgi->a({-href => href(action=>"commitdiff",
3273                                                      hash=>$hash, hash_parent=>$par),
3274                                        -title => 'commitdiff to parent number ' .
3275                                                   ($i+1) . ': ' . substr($par,0,7)},
3276                                       $i+1) .
3277                               "&nbsp;</th>\n";
3278                 }
3279                 print "</tr></thead>\n<tbody>\n";
3280         }
3281
3282         my $alternate = 1;
3283         my $patchno = 0;
3284         foreach my $line (@{$difftree}) {
3285                 my $diff = parsed_difftree_line($line);
3286
3287                 if ($alternate) {
3288                         print "<tr class=\"dark\">\n";
3289                 } else {
3290                         print "<tr class=\"light\">\n";
3291                 }
3292                 $alternate ^= 1;
3293
3294                 if (exists $diff->{'nparents'}) { # combined diff
3295
3296                         fill_from_file_info($diff, @parents)
3297                                 unless exists $diff->{'from_file'};
3298
3299                         if (!is_deleted($diff)) {
3300                                 # file exists in the result (child) commit
3301                                 print "<td>" .
3302                                       $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3303                                                              file_name=>$diff->{'to_file'},
3304                                                              hash_base=>$hash),
3305                                               -class => "list"}, esc_path($diff->{'to_file'})) .
3306                                       "</td>\n";
3307                         } else {
3308                                 print "<td>" .
3309                                       esc_path($diff->{'to_file'}) .
3310                                       "</td>\n";
3311                         }
3312
3313                         if ($action eq 'commitdiff') {
3314                                 # link to patch
3315                                 $patchno++;
3316                                 print "<td class=\"link\">" .
3317                                       $cgi->a({-href => "#patch$patchno"}, "patch") .
3318                                       " | " .
3319                                       "</td>\n";
3320                         }
3321
3322                         my $has_history = 0;
3323                         my $not_deleted = 0;
3324                         for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3325                                 my $hash_parent = $parents[$i];
3326                                 my $from_hash = $diff->{'from_id'}[$i];
3327                                 my $from_path = $diff->{'from_file'}[$i];
3328                                 my $status = $diff->{'status'}[$i];
3329
3330                                 $has_history ||= ($status ne 'A');
3331                                 $not_deleted ||= ($status ne 'D');
3332
3333                                 if ($status eq 'A') {
3334                                         print "<td  class=\"link\" align=\"right\"> | </td>\n";
3335                                 } elsif ($status eq 'D') {
3336                                         print "<td class=\"link\">" .
3337                                               $cgi->a({-href => href(action=>"blob",
3338                                                                      hash_base=>$hash,
3339                                                                      hash=>$from_hash,
3340                                                                      file_name=>$from_path)},
3341                                                       "blob" . ($i+1)) .
3342                                               " | </td>\n";
3343                                 } else {
3344                                         if ($diff->{'to_id'} eq $from_hash) {
3345                                                 print "<td class=\"link nochange\">";
3346                                         } else {
3347                                                 print "<td class=\"link\">";
3348                                         }
3349                                         print $cgi->a({-href => href(action=>"blobdiff",
3350                                                                      hash=>$diff->{'to_id'},
3351                                                                      hash_parent=>$from_hash,
3352                                                                      hash_base=>$hash,
3353                                                                      hash_parent_base=>$hash_parent,
3354                                                                      file_name=>$diff->{'to_file'},
3355                                                                      file_parent=>$from_path)},
3356                                                       "diff" . ($i+1)) .
3357                                               " | </td>\n";
3358                                 }
3359                         }
3360
3361                         print "<td class=\"link\">";
3362                         if ($not_deleted) {
3363                                 print $cgi->a({-href => href(action=>"blob",
3364                                                              hash=>$diff->{'to_id'},
3365                                                              file_name=>$diff->{'to_file'},
3366                                                              hash_base=>$hash)},
3367                                               "blob");
3368                                 print " | " if ($has_history);
3369                         }
3370                         if ($has_history) {
3371                                 print $cgi->a({-href => href(action=>"history",
3372                                                              file_name=>$diff->{'to_file'},
3373                                                              hash_base=>$hash)},
3374                                               "history");
3375                         }
3376                         print "</td>\n";
3377
3378                         print "</tr>\n";
3379                         next; # instead of 'else' clause, to avoid extra indent
3380                 }
3381                 # else ordinary diff
3382
3383                 my ($to_mode_oct, $to_mode_str, $to_file_type);
3384                 my ($from_mode_oct, $from_mode_str, $from_file_type);
3385                 if ($diff->{'to_mode'} ne ('0' x 6)) {
3386                         $to_mode_oct = oct $diff->{'to_mode'};
3387                         if (S_ISREG($to_mode_oct)) { # only for regular file
3388                                 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
3389                         }
3390                         $to_file_type = file_type($diff->{'to_mode'});
3391                 }
3392                 if ($diff->{'from_mode'} ne ('0' x 6)) {
3393                         $from_mode_oct = oct $diff->{'from_mode'};
3394                         if (S_ISREG($to_mode_oct)) { # only for regular file
3395                                 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
3396                         }
3397                         $from_file_type = file_type($diff->{'from_mode'});
3398                 }
3399
3400                 if ($diff->{'status'} eq "A") { # created
3401                         my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
3402                         $mode_chng   .= " with mode: $to_mode_str" if $to_mode_str;
3403                         $mode_chng   .= "]</span>";
3404                         print "<td>";
3405                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3406                                                      hash_base=>$hash, file_name=>$diff->{'file'}),
3407                                       -class => "list"}, esc_path($diff->{'file'}));
3408                         print "</td>\n";
3409                         print "<td>$mode_chng</td>\n";
3410                         print "<td class=\"link\">";
3411                         if ($action eq 'commitdiff') {
3412                                 # link to patch
3413                                 $patchno++;
3414                                 print $cgi->a({-href => "#patch$patchno"}, "patch");
3415                                 print " | ";
3416                         }
3417                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3418                                                      hash_base=>$hash, file_name=>$diff->{'file'})},
3419                                       "blob");
3420                         print "</td>\n";
3421
3422                 } elsif ($diff->{'status'} eq "D") { # deleted
3423                         my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
3424                         print "<td>";
3425                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
3426                                                      hash_base=>$parent, file_name=>$diff->{'file'}),
3427                                        -class => "list"}, esc_path($diff->{'file'}));
3428                         print "</td>\n";
3429                         print "<td>$mode_chng</td>\n";
3430                         print "<td class=\"link\">";
3431                         if ($action eq 'commitdiff') {
3432                                 # link to patch
3433                                 $patchno++;
3434                                 print $cgi->a({-href => "#patch$patchno"}, "patch");
3435                                 print " | ";
3436                         }
3437                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
3438                                                      hash_base=>$parent, file_name=>$diff->{'file'})},
3439                                       "blob") . " | ";
3440                         if ($have_blame) {
3441                                 print $cgi->a({-href => href(action=>"blame", hash_base=>$parent,
3442                                                              file_name=>$diff->{'file'})},
3443                                               "blame") . " | ";
3444                         }
3445                         print $cgi->a({-href => href(action=>"history", hash_base=>$parent,
3446                                                      file_name=>$diff->{'file'})},
3447                                       "history");
3448                         print "</td>\n";
3449
3450                 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
3451                         my $mode_chnge = "";
3452                         if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3453                                 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
3454                                 if ($from_file_type ne $to_file_type) {
3455                                         $mode_chnge .= " from $from_file_type to $to_file_type";
3456                                 }
3457                                 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
3458                                         if ($from_mode_str && $to_mode_str) {
3459                                                 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
3460                                         } elsif ($to_mode_str) {
3461                                                 $mode_chnge .= " mode: $to_mode_str";
3462                                         }
3463                                 }
3464                                 $mode_chnge .= "]</span>\n";
3465                         }
3466                         print "<td>";
3467                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3468                                                      hash_base=>$hash, file_name=>$diff->{'file'}),
3469                                       -class => "list"}, esc_path($diff->{'file'}));
3470                         print "</td>\n";
3471                         print "<td>$mode_chnge</td>\n";
3472                         print "<td class=\"link\">";
3473                         if ($action eq 'commitdiff') {
3474                                 # link to patch
3475                                 $patchno++;
3476                                 print $cgi->a({-href => "#patch$patchno"}, "patch") .
3477                                       " | ";
3478                         } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3479                                 # "commit" view and modified file (not onlu mode changed)
3480                                 print $cgi->a({-href => href(action=>"blobdiff",
3481                                                              hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
3482                                                              hash_base=>$hash, hash_parent_base=>$parent,
3483                                                              file_name=>$diff->{'file'})},
3484                                               "diff") .
3485                                       " | ";
3486                         }
3487                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3488                                                      hash_base=>$hash, file_name=>$diff->{'file'})},
3489                                        "blob") . " | ";
3490                         if ($have_blame) {
3491                                 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
3492                                                              file_name=>$diff->{'file'})},
3493                                               "blame") . " | ";
3494                         }
3495                         print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
3496                                                      file_name=>$diff->{'file'})},
3497                                       "history");
3498                         print "</td>\n";
3499
3500                 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
3501                         my %status_name = ('R' => 'moved', 'C' => 'copied');
3502                         my $nstatus = $status_name{$diff->{'status'}};
3503                         my $mode_chng = "";
3504                         if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3505                                 # mode also for directories, so we cannot use $to_mode_str
3506                                 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
3507                         }
3508                         print "<td>" .
3509                               $cgi->a({-href => href(action=>"blob", hash_base=>$hash,
3510                                                      hash=>$diff->{'to_id'}, file_name=>$diff->{'to_file'}),
3511                                       -class => "list"}, esc_path($diff->{'to_file'})) . "</td>\n" .
3512                               "<td><span class=\"file_status $nstatus\">[$nstatus from " .
3513                               $cgi->a({-href => href(action=>"blob", hash_base=>$parent,
3514                                                      hash=>$diff->{'from_id'}, file_name=>$diff->{'from_file'}),
3515                                       -class => "list"}, esc_path($diff->{'from_file'})) .
3516                               " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
3517                               "<td class=\"link\">";
3518                         if ($action eq 'commitdiff') {
3519                                 # link to patch
3520                                 $patchno++;
3521                                 print $cgi->a({-href => "#patch$patchno"}, "patch") .
3522                                       " | ";
3523                         } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3524                                 # "commit" view and modified file (not only pure rename or copy)
3525                                 print $cgi->a({-href => href(action=>"blobdiff",
3526                                                              hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
3527                                                              hash_base=>$hash, hash_parent_base=>$parent,
3528                                                              file_name=>$diff->{'to_file'}, file_parent=>$diff->{'from_file'})},
3529                                               "diff") .
3530                                       " | ";
3531                         }
3532                         print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
3533                                                      hash_base=>$parent, file_name=>$diff->{'to_file'})},
3534                                       "blob") . " | ";
3535                         if ($have_blame) {
3536                                 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
3537                                                              file_name=>$diff->{'to_file'})},
3538                                               "blame") . " | ";
3539                         }
3540                         print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
3541                                                     file_name=>$diff->{'to_file'})},
3542                                       "history");
3543                         print "</td>\n";
3544
3545                 } # we should not encounter Unmerged (U) or Unknown (X) status
3546                 print "</tr>\n";
3547         }
3548         print "</tbody>" if $has_header;
3549         print "</table>\n";
3550 }
3551
3552 sub git_patchset_body {
3553         my ($fd, $difftree, $hash, @hash_parents) = @_;
3554         my ($hash_parent) = $hash_parents[0];
3555
3556         my $is_combined = (@hash_parents > 1);
3557         my $patch_idx = 0;
3558         my $patch_number = 0;
3559         my $patch_line;
3560         my $diffinfo;
3561         my $to_name;
3562         my (%from, %to);
3563
3564         print "<div class=\"patchset\">\n";
3565
3566         # skip to first patch
3567         while ($patch_line = <$fd>) {
3568                 chomp $patch_line;
3569
3570                 last if ($patch_line =~ m/^diff /);
3571         }
3572
3573  PATCH:
3574         while ($patch_line) {
3575
3576                 # parse "git diff" header line
3577                 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
3578                         # $1 is from_name, which we do not use
3579                         $to_name = unquote($2);
3580                         $to_name =~ s!^b/!!;
3581                 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
3582                         # $1 is 'cc' or 'combined', which we do not use
3583                         $to_name = unquote($2);
3584                 } else {
3585                         $to_name = undef;
3586                 }
3587
3588                 # check if current patch belong to current raw line
3589                 # and parse raw git-diff line if needed
3590                 if (is_patch_split($diffinfo, { 'to_file' => $to_name })) {
3591                         # this is continuation of a split patch
3592                         print "<div class=\"patch cont\">\n";
3593                 } else {
3594                         # advance raw git-diff output if needed
3595                         $patch_idx++ if defined $diffinfo;
3596
3597                         # read and prepare patch information
3598                         $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
3599
3600                         # compact combined diff output can have some patches skipped
3601                         # find which patch (using pathname of result) we are at now;
3602                         if ($is_combined) {
3603                                 while ($to_name ne $diffinfo->{'to_file'}) {
3604                                         print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3605                                               format_diff_cc_simplified($diffinfo, @hash_parents) .
3606                                               "</div>\n";  # class="patch"
3607
3608                                         $patch_idx++;
3609                                         $patch_number++;
3610
3611                                         last if $patch_idx > $#$difftree;
3612                                         $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
3613                                 }
3614                         }
3615
3616                         # modifies %from, %to hashes
3617                         parse_from_to_diffinfo($diffinfo, \%from, \%to, @hash_parents);
3618
3619                         # this is first patch for raw difftree line with $patch_idx index
3620                         # we index @$difftree array from 0, but number patches from 1
3621                         print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
3622                 }
3623
3624                 # git diff header
3625                 #assert($patch_line =~ m/^diff /) if DEBUG;
3626                 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
3627                 $patch_number++;
3628                 # print "git diff" header
3629                 print format_git_diff_header_line($patch_line, $diffinfo,
3630                                                   \%from, \%to);
3631
3632                 # print extended diff header
3633                 print "<div class=\"diff extended_header\">\n";
3634         EXTENDED_HEADER:
3635                 while ($patch_line = <$fd>) {
3636                         chomp $patch_line;
3637
3638                         last EXTENDED_HEADER if ($patch_line =~ m/^--- |^diff /);
3639
3640                         print format_extended_diff_header_line($patch_line, $diffinfo,
3641                                                                \%from, \%to);
3642                 }
3643                 print "</div>\n"; # class="diff extended_header"
3644
3645                 # from-file/to-file diff header
3646                 if (! $patch_line) {
3647                         print "</div>\n"; # class="patch"
3648                         last PATCH;
3649                 }
3650                 next PATCH if ($patch_line =~ m/^diff /);
3651                 #assert($patch_line =~ m/^---/) if DEBUG;
3652
3653                 my $last_patch_line = $patch_line;
3654                 $patch_line = <$fd>;
3655                 chomp $patch_line;
3656                 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
3657
3658                 print format_diff_from_to_header($last_patch_line, $patch_line,
3659                                                  $diffinfo, \%from, \%to,
3660                                                  @hash_parents);
3661
3662                 # the patch itself
3663         LINE:
3664                 while ($patch_line = <$fd>) {
3665                         chomp $patch_line;
3666
3667                         next PATCH if ($patch_line =~ m/^diff /);
3668
3669                         print format_diff_line($patch_line, \%from, \%to);
3670                 }
3671
3672         } continue {
3673                 print "</div>\n"; # class="patch"
3674         }
3675
3676         # for compact combined (--cc) format, with chunk and patch simpliciaction
3677         # patchset might be empty, but there might be unprocessed raw lines
3678         for (++$patch_idx if $patch_number > 0;
3679              $patch_idx < @$difftree;
3680              ++$patch_idx) {
3681                 # read and prepare patch information
3682                 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
3683
3684                 # generate anchor for "patch" links in difftree / whatchanged part
3685                 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3686                       format_diff_cc_simplified($diffinfo, @hash_parents) .
3687                       "</div>\n";  # class="patch"
3688
3689                 $patch_number++;
3690         }
3691
3692         if ($patch_number == 0) {
3693                 if (@hash_parents > 1) {
3694                         print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
3695                 } else {
3696                         print "<div class=\"diff nodifferences\">No differences found</div>\n";
3697                 }
3698         }
3699
3700         print "</div>\n"; # class="patchset"
3701 }
3702
3703 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3704
3705 # fills project list info (age, description, owner, forks) for each
3706 # project in the list, removing invalid projects from returned list
3707 # NOTE: modifies $projlist, but does not remove entries from it
3708 sub fill_project_list_info {
3709         my ($projlist, $check_forks) = @_;
3710         my @projects;
3711
3712         my $show_ctags = gitweb_check_feature('ctags');
3713  PROJECT:
3714         foreach my $pr (@$projlist) {
3715                 my (@activity) = git_get_last_activity($pr->{'path'});
3716                 unless (@activity) {
3717                         next PROJECT;
3718                 }
3719                 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
3720                 if (!defined $pr->{'descr'}) {
3721                         my $descr = git_get_project_description($pr->{'path'}) || "";
3722                         $descr = to_utf8($descr);
3723                         $pr->{'descr_long'} = $descr;
3724                         $pr->{'descr'} = chop_str($descr, $projects_list_description_width, 5);
3725                 }
3726                 if (!defined $pr->{'owner'}) {
3727                         $pr->{'owner'} = git_get_project_owner("$pr->{'path'}") || "";
3728                 }
3729                 if ($check_forks) {
3730                         my $pname = $pr->{'path'};
3731                         if (($pname =~ s/\.git$//) &&
3732                             ($pname !~ /\/$/) &&
3733                             (-d "$projectroot/$pname")) {
3734                                 $pr->{'forks'} = "-d $projectroot/$pname";
3735                         }       else {
3736                                 $pr->{'forks'} = 0;
3737                         }
3738                 }
3739                 $show_ctags and $pr->{'ctags'} = git_get_project_ctags($pr->{'path'});
3740                 push @projects, $pr;
3741         }
3742
3743         return @projects;
3744 }
3745
3746 # print 'sort by' <th> element, generating 'sort by $name' replay link
3747 # if that order is not selected
3748 sub print_sort_th {
3749         my ($name, $order, $header) = @_;
3750         $header ||= ucfirst($name);
3751
3752         if ($order eq $name) {
3753                 print "<th>$header</th>\n";
3754         } else {
3755                 print "<th>" .
3756                       $cgi->a({-href => href(-replay=>1, order=>$name),
3757                                -class => "header"}, $header) .
3758                       "</th>\n";
3759         }
3760 }
3761
3762 sub git_project_list_body {
3763         # actually uses global variable $project
3764         my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
3765
3766         my ($check_forks) = gitweb_check_feature('forks');
3767         my @projects = fill_project_list_info($projlist, $check_forks);
3768
3769         $order ||= $default_projects_order;
3770         $from = 0 unless defined $from;
3771         $to = $#projects if (!defined $to || $#projects < $to);
3772
3773         my %order_info = (
3774                 project => { key => 'path', type => 'str' },
3775                 descr => { key => 'descr_long', type => 'str' },
3776                 owner => { key => 'owner', type => 'str' },
3777                 age => { key => 'age', type => 'num' }
3778         );
3779         my $oi = $order_info{$order};
3780         if ($oi->{'type'} eq 'str') {
3781                 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
3782         } else {
3783                 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
3784         }
3785
3786         my $show_ctags = gitweb_check_feature('ctags');
3787         if ($show_ctags) {
3788                 my %ctags;
3789                 foreach my $p (@projects) {
3790                         foreach my $ct (keys %{$p->{'ctags'}}) {
3791                                 $ctags{$ct} += $p->{'ctags'}->{$ct};
3792                         }
3793                 }
3794                 my $cloud = git_populate_project_tagcloud(\%ctags);
3795                 print git_show_project_tagcloud($cloud, 64);
3796         }
3797
3798         print "<table class=\"project_list\">\n";
3799         unless ($no_header) {
3800                 print "<tr>\n";
3801                 if ($check_forks) {
3802                         print "<th></th>\n";
3803                 }
3804                 print_sort_th('project', $order, 'Project');
3805                 print_sort_th('descr', $order, 'Description');
3806                 print_sort_th('owner', $order, 'Owner');
3807                 print_sort_th('age', $order, 'Last Change');
3808                 print "<th></th>\n" . # for links
3809                       "</tr>\n";
3810         }
3811         my $alternate = 1;
3812         my $tagfilter = $cgi->param('by_tag');
3813         for (my $i = $from; $i <= $to; $i++) {
3814                 my $pr = $projects[$i];
3815
3816                 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
3817                 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
3818                         and not $pr->{'descr_long'} =~ /$searchtext/;
3819                 # Weed out forks or non-matching entries of search
3820                 if ($check_forks) {
3821                         my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s#\.git$#/#;
3822                         $forkbase="^$forkbase" if $forkbase;
3823                         next if not $searchtext and not $tagfilter and $show_ctags
3824                                 and $pr->{'path'} =~ m#$forkbase.*/.*#; # regexp-safe
3825                 }
3826
3827                 if ($alternate) {
3828                         print "<tr class=\"dark\">\n";
3829                 } else {
3830                         print "<tr class=\"light\">\n";
3831                 }
3832                 $alternate ^= 1;
3833                 if ($check_forks) {
3834                         print "<td>";
3835                         if ($pr->{'forks'}) {
3836                                 print "<!-- $pr->{'forks'} -->\n";
3837                                 print $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "+");
3838                         }
3839                         print "</td>\n";
3840                 }
3841                 print "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
3842                                         -class => "list"}, esc_html($pr->{'path'})) . "</td>\n" .
3843                       "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
3844                                         -class => "list", -title => $pr->{'descr_long'}},
3845                                         esc_html($pr->{'descr'})) . "</td>\n" .
3846                       "<td><i>" . chop_and_escape_str($pr->{'owner'}, 15) . "</i></td>\n";
3847                 print "<td class=\"". age_class($pr->{'age'}) . "\">" .
3848                       (defined $pr->{'age_string'} ? $pr->{'age_string'} : "No commits") . "</td>\n" .
3849                       "<td class=\"link\">" .
3850                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary")}, "summary")   . " | " .
3851                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"shortlog")}, "log") . " | " .
3852                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"tree")}, "tree") .
3853                       ($pr->{'forks'} ? " | " . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "forks") : '') .
3854                       "</td>\n" .
3855                       "</tr>\n";
3856         }
3857         if (defined $extra) {
3858                 print "<tr>\n";
3859                 if ($check_forks) {
3860                         print "<td></td>\n";
3861                 }
3862                 print "<td colspan=\"5\">$extra</td>\n" .
3863                       "</tr>\n";
3864         }
3865         print "</table>\n";
3866 }
3867
3868 sub git_shortlog_body {
3869         # uses global variable $project
3870         my ($commitlist, $from, $to, $refs, $extra) = @_;
3871
3872         $from = 0 unless defined $from;
3873         $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
3874
3875         print "<table class=\"shortlog\">\n";
3876         my $alternate = 1;
3877         for (my $i = $from; $i <= $to; $i++) {
3878                 my %co = %{$commitlist->[$i]};
3879                 my $commit = $co{'id'};
3880                 my $ref = format_ref_marker($refs, $commit);
3881                 if ($alternate) {
3882                         print "<tr class=\"dark\">\n";
3883                 } else {
3884                         print "<tr class=\"light\">\n";
3885                 }
3886                 $alternate ^= 1;
3887                 my $author = chop_and_escape_str($co{'author_name'}, 10);
3888                 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
3889                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
3890                       "<td><i>" . $author . "</i></td>\n" .
3891                       "<td>";
3892                 print format_subject_html($co{'title'}, $co{'title_short'},
3893                                           href(action=>"commit", hash=>$commit), $ref);
3894                 print "</td>\n" .
3895                       "<td class=\"link\">" .
3896                       $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") . " | " .
3897                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") . " | " .
3898                       $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree");
3899                 my $snapshot_links = format_snapshot_links($commit);
3900                 if (defined $snapshot_links) {
3901                         print " | " . $snapshot_links;
3902                 }
3903                 print "</td>\n" .
3904                       "</tr>\n";
3905         }
3906         if (defined $extra) {
3907                 print "<tr>\n" .
3908                       "<td colspan=\"4\">$extra</td>\n" .
3909                       "</tr>\n";
3910         }
3911         print "</table>\n";
3912 }
3913
3914 sub git_history_body {
3915         # Warning: assumes constant type (blob or tree) during history
3916         my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
3917
3918         $from = 0 unless defined $from;
3919         $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
3920
3921         print "<table class=\"history\">\n";
3922         my $alternate = 1;
3923         for (my $i = $from; $i <= $to; $i++) {
3924                 my %co = %{$commitlist->[$i]};
3925                 if (!%co) {
3926                         next;
3927                 }
3928                 my $commit = $co{'id'};
3929
3930                 my $ref = format_ref_marker($refs, $commit);
3931
3932                 if ($alternate) {
3933                         print "<tr class=\"dark\">\n";
3934                 } else {
3935                         print "<tr class=\"light\">\n";
3936                 }
3937                 $alternate ^= 1;
3938         # shortlog uses      chop_str($co{'author_name'}, 10)
3939                 my $author = chop_and_escape_str($co{'author_name'}, 15, 3);
3940                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
3941                       "<td><i>" . $author . "</i></td>\n" .
3942                       "<td>";
3943                 # originally git_history used chop_str($co{'title'}, 50)
3944                 print format_subject_html($co{'title'}, $co{'title_short'},
3945                                           href(action=>"commit", hash=>$commit), $ref);
3946                 print "</td>\n" .
3947                       "<td class=\"link\">" .
3948                       $cgi->a({-href => href(action=>$ftype, hash_base=>$commit, file_name=>$file_name)}, $ftype) . " | " .
3949                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff");
3950
3951                 if ($ftype eq 'blob') {
3952                         my $blob_current = git_get_hash_by_path($hash_base, $file_name);
3953                         my $blob_parent  = git_get_hash_by_path($commit, $file_name);
3954                         if (defined $blob_current && defined $blob_parent &&
3955                                         $blob_current ne $blob_parent) {
3956                                 print " | " .
3957                                         $cgi->a({-href => href(action=>"blobdiff",
3958                                                                hash=>$blob_current, hash_parent=>$blob_parent,
3959                                                                hash_base=>$hash_base, hash_parent_base=>$commit,
3960                                                                file_name=>$file_name)},
3961                                                 "diff to current");
3962                         }
3963                 }
3964                 print "</td>\n" .
3965                       "</tr>\n";
3966         }
3967         if (defined $extra) {
3968                 print "<tr>\n" .
3969                       "<td colspan=\"4\">$extra</td>\n" .
3970                       "</tr>\n";
3971         }
3972         print "</table>\n";
3973 }
3974
3975 sub git_tags_body {
3976         # uses global variable $project
3977         my ($taglist, $from, $to, $extra) = @_;
3978         $from = 0 unless defined $from;
3979         $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
3980
3981         print "<table class=\"tags\">\n";
3982         my $alternate = 1;
3983         for (my $i = $from; $i <= $to; $i++) {
3984                 my $entry = $taglist->[$i];
3985                 my %tag = %$entry;
3986                 my $comment = $tag{'subject'};
3987                 my $comment_short;
3988                 if (defined $comment) {
3989                         $comment_short = chop_str($comment, 30, 5);
3990                 }
3991                 if ($alternate) {
3992                         print "<tr class=\"dark\">\n";
3993                 } else {
3994                         print "<tr class=\"light\">\n";
3995                 }
3996                 $alternate ^= 1;
3997                 if (defined $tag{'age'}) {
3998                         print "<td><i>$tag{'age'}</i></td>\n";
3999                 } else {
4000                         print "<td></td>\n";
4001                 }
4002                 print "<td>" .
4003                       $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'}),
4004                                -class => "list name"}, esc_html($tag{'name'})) .
4005                       "</td>\n" .
4006                       "<td>";
4007                 if (defined $comment) {
4008                         print format_subject_html($comment, $comment_short,
4009                                                   href(action=>"tag", hash=>$tag{'id'}));
4010                 }
4011                 print "</td>\n" .
4012                       "<td class=\"selflink\">";
4013                 if ($tag{'type'} eq "tag") {
4014                         print $cgi->a({-href => href(action=>"tag", hash=>$tag{'id'})}, "tag");
4015                 } else {
4016                         print "&nbsp;";
4017                 }
4018                 print "</td>\n" .
4019                       "<td class=\"link\">" . " | " .
4020                       $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'})}, $tag{'reftype'});
4021                 if ($tag{'reftype'} eq "commit") {
4022                         print " | " . $cgi->a({-href => href(action=>"shortlog", hash=>$tag{'fullname'})}, "log");
4023                 } elsif ($tag{'reftype'} eq "blob") {
4024                         print " | " . $cgi->a({-href => href(action=>"blob_plain", hash=>$tag{'refid'})}, "raw");
4025                 }
4026                 print "</td>\n" .
4027                       "</tr>";
4028         }
4029         if (defined $extra) {
4030                 print "<tr>\n" .
4031                       "<td colspan=\"5\">$extra</td>\n" .
4032                       "</tr>\n";
4033         }
4034         print "</table>\n";
4035 }
4036
4037 sub git_heads_body {
4038         # uses global variable $project
4039         my ($headlist, $head, $from, $to, $extra) = @_;
4040         $from = 0 unless defined $from;
4041         $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4042
4043         print "<table class=\"heads\">\n";
4044         my $alternate = 1;
4045         for (my $i = $from; $i <= $to; $i++) {
4046                 my $entry = $headlist->[$i];
4047                 my %ref = %$entry;
4048                 my $curr = $ref{'id'} eq $head;
4049                 if ($alternate) {
4050                         print "<tr class=\"dark\">\n";
4051                 } else {
4052                         print "<tr class=\"light\">\n";
4053                 }
4054                 $alternate ^= 1;
4055                 print "<td><i>$ref{'age'}</i></td>\n" .
4056                       ($curr ? "<td class=\"current_head\">" : "<td>") .
4057                       $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'}),
4058                                -class => "list name"},esc_html($ref{'name'})) .
4059                       "</td>\n" .
4060                       "<td class=\"link\">" .
4061                       $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'})}, "log") . " | " .
4062                       $cgi->a({-href => href(action=>"tree", hash=>$ref{'fullname'}, hash_base=>$ref{'name'})}, "tree") .
4063                       "</td>\n" .
4064                       "</tr>";
4065         }
4066         if (defined $extra) {
4067                 print "<tr>\n" .
4068                       "<td colspan=\"3\">$extra</td>\n" .
4069                       "</tr>\n";
4070         }
4071         print "</table>\n";
4072 }
4073
4074 sub git_search_grep_body {
4075         my ($commitlist, $from, $to, $extra) = @_;
4076         $from = 0 unless defined $from;
4077         $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4078
4079         print "<table class=\"commit_search\">\n";
4080         my $alternate = 1;
4081         for (my $i = $from; $i <= $to; $i++) {
4082                 my %co = %{$commitlist->[$i]};
4083                 if (!%co) {
4084                         next;
4085                 }
4086                 my $commit = $co{'id'};
4087                 if ($alternate) {
4088                         print "<tr class=\"dark\">\n";
4089                 } else {
4090                         print "<tr class=\"light\">\n";
4091                 }
4092                 $alternate ^= 1;
4093                 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
4094                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4095                       "<td><i>" . $author . "</i></td>\n" .
4096                       "<td>" .
4097                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
4098                                -class => "list subject"},
4099                               chop_and_escape_str($co{'title'}, 50) . "<br/>");
4100                 my $comment = $co{'comment'};
4101                 foreach my $line (@$comment) {
4102                         if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
4103                                 my ($lead, $match, $trail) = ($1, $2, $3);
4104                                 $match = chop_str($match, 70, 5, 'center');
4105                                 my $contextlen = int((80 - length($match))/2);
4106                                 $contextlen = 30 if ($contextlen > 30);
4107                                 $lead  = chop_str($lead,  $contextlen, 10, 'left');
4108                                 $trail = chop_str($trail, $contextlen, 10, 'right');
4109
4110                                 $lead  = esc_html($lead);
4111                                 $match = esc_html($match);
4112                                 $trail = esc_html($trail);
4113
4114                                 print "$lead<span class=\"match\">$match</span>$trail<br />";
4115                         }
4116                 }
4117                 print "</td>\n" .
4118                       "<td class=\"link\">" .
4119                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
4120                       " | " .
4121                       $cgi->a({-href => href(action=>"commitdiff", hash=>$co{'id'})}, "commitdiff") .
4122                       " | " .
4123                       $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
4124                 print "</td>\n" .
4125                       "</tr>\n";
4126         }
4127         if (defined $extra) {
4128                 print "<tr>\n" .
4129                       "<td colspan=\"3\">$extra</td>\n" .
4130                       "</tr>\n";
4131         }
4132         print "</table>\n";
4133 }
4134
4135 ## ======================================================================
4136 ## ======================================================================
4137 ## actions
4138
4139 sub git_project_list {
4140         my $order = $cgi->param('o');
4141         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4142                 die_error(400, "Unknown order parameter");
4143         }
4144
4145         my @list = git_get_projects_list();
4146         if (!@list) {
4147                 die_error(404, "No projects found");
4148         }
4149
4150         git_header_html();
4151         if (-f $home_text) {
4152                 print "<div class=\"index_include\">\n";
4153                 open (my $fd, $home_text);
4154                 print <$fd>;
4155                 close $fd;
4156                 print "</div>\n";
4157         }
4158         print $cgi->startform(-method => "get") .
4159               "<p class=\"projsearch\">Search:\n" .
4160               $cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
4161               "</p>" .
4162               $cgi->end_form() . "\n";
4163         git_project_list_body(\@list, $order);
4164         git_footer_html();
4165 }
4166
4167 sub git_forks {
4168         my $order = $cgi->param('o');
4169         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4170                 die_error(400, "Unknown order parameter");
4171         }
4172
4173         my @list = git_get_projects_list($project);
4174         if (!@list) {
4175                 die_error(404, "No forks found");
4176         }
4177
4178         git_header_html();
4179         git_print_page_nav('','');
4180         git_print_header_div('summary', "$project forks");
4181         git_project_list_body(\@list, $order);
4182         git_footer_html();
4183 }
4184
4185 sub git_project_index {
4186         my @projects = git_get_projects_list($project);
4187
4188         print $cgi->header(
4189                 -type => 'text/plain',
4190                 -charset => 'utf-8',
4191                 -content_disposition => 'inline; filename="index.aux"');
4192
4193         foreach my $pr (@projects) {
4194                 if (!exists $pr->{'owner'}) {
4195                         $pr->{'owner'} = git_get_project_owner("$pr->{'path'}");
4196                 }
4197
4198                 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
4199                 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
4200                 $path  =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
4201                 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
4202                 $path  =~ s/ /\+/g;
4203                 $owner =~ s/ /\+/g;
4204
4205                 print "$path $owner\n";
4206         }
4207 }
4208
4209 sub git_summary {
4210         my $descr = git_get_project_description($project) || "none";
4211         my %co = parse_commit("HEAD");
4212         my %cd = %co ? parse_date($co{'committer_epoch'}, $co{'committer_tz'}) : ();
4213         my $head = $co{'id'};
4214
4215         my $owner = git_get_project_owner($project);
4216
4217         my $refs = git_get_references();
4218         # These get_*_list functions return one more to allow us to see if
4219         # there are more ...
4220         my @taglist  = git_get_tags_list(16);
4221         my @headlist = git_get_heads_list(16);
4222         my @forklist;
4223         my ($check_forks) = gitweb_check_feature('forks');
4224
4225         if ($check_forks) {
4226                 @forklist = git_get_projects_list($project);
4227         }
4228
4229         git_header_html();
4230         git_print_page_nav('summary','', $head);
4231
4232         print "<div class=\"title\">&nbsp;</div>\n";
4233         print "<table class=\"projects_list\">\n" .
4234               "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html($descr) . "</td></tr>\n" .
4235               "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html($owner) . "</td></tr>\n";
4236         if (defined $cd{'rfc2822'}) {
4237                 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
4238         }
4239
4240         # use per project git URL list in $projectroot/$project/cloneurl
4241         # or make project git URL from git base URL and project name
4242         my $url_tag = "URL";
4243         my @url_list = git_get_project_url_list($project);
4244         @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
4245         foreach my $git_url (@url_list) {
4246                 next unless $git_url;
4247                 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
4248                 $url_tag = "";
4249         }
4250
4251         # Tag cloud
4252         my $show_ctags = (gitweb_check_feature('ctags'))[0];
4253         if ($show_ctags) {
4254                 my $ctags = git_get_project_ctags($project);
4255                 my $cloud = git_populate_project_tagcloud($ctags);
4256                 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
4257                 print "</td>\n<td>" unless %$ctags;
4258                 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
4259                 print "</td>\n<td>" if %$ctags;
4260                 print git_show_project_tagcloud($cloud, 48);
4261                 print "</td></tr>";
4262         }
4263
4264         print "</table>\n";
4265
4266         if (-s "$projectroot/$project/README.html") {
4267                 if (open my $fd, "$projectroot/$project/README.html") {
4268                         print "<div class=\"title\">readme</div>\n" .
4269                               "<div class=\"readme\">\n";
4270                         print $_ while (<$fd>);
4271                         print "\n</div>\n"; # class="readme"
4272                         close $fd;
4273                 }
4274         }
4275
4276         # we need to request one more than 16 (0..15) to check if
4277         # those 16 are all
4278         my @commitlist = $head ? parse_commits($head, 17) : ();
4279         if (@commitlist) {
4280                 git_print_header_div('shortlog');
4281                 git_shortlog_body(\@commitlist, 0, 15, $refs,
4282                                   $#commitlist <=  15 ? undef :
4283                                   $cgi->a({-href => href(action=>"shortlog")}, "..."));
4284         }
4285
4286         if (@taglist) {
4287                 git_print_header_div('tags');
4288                 git_tags_body(\@taglist, 0, 15,
4289                               $#taglist <=  15 ? undef :
4290                               $cgi->a({-href => href(action=>"tags")}, "..."));
4291         }
4292
4293         if (@headlist) {
4294                 git_print_header_div('heads');
4295                 git_heads_body(\@headlist, $head, 0, 15,
4296                                $#headlist <= 15 ? undef :
4297                                $cgi->a({-href => href(action=>"heads")}, "..."));
4298         }
4299
4300         if (@forklist) {
4301                 git_print_header_div('forks');
4302                 git_project_list_body(\@forklist, 'age', 0, 15,
4303                                       $#forklist <= 15 ? undef :
4304                                       $cgi->a({-href => href(action=>"forks")}, "..."),
4305                                       'no_header');
4306         }
4307
4308         git_footer_html();
4309 }
4310
4311 sub git_tag {
4312         my $head = git_get_head_hash($project);
4313         git_header_html();
4314         git_print_page_nav('','', $head,undef,$head);
4315         my %tag = parse_tag($hash);
4316
4317         if (! %tag) {
4318                 die_error(404, "Unknown tag object");
4319         }
4320
4321         git_print_header_div('commit', esc_html($tag{'name'}), $hash);
4322         print "<div class=\"title_text\">\n" .
4323               "<table class=\"object_header\">\n" .
4324               "<tr>\n" .
4325               "<td>object</td>\n" .
4326               "<td>" . $cgi->a({-class => "list", -href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
4327                                $tag{'object'}) . "</td>\n" .
4328               "<td class=\"link\">" . $cgi->a({-href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
4329                                               $tag{'type'}) . "</td>\n" .
4330               "</tr>\n";
4331         if (defined($tag{'author'})) {
4332                 my %ad = parse_date($tag{'epoch'}, $tag{'tz'});
4333                 print "<tr><td>author</td><td>" . esc_html($tag{'author'}) . "</td></tr>\n";
4334                 print "<tr><td></td><td>" . $ad{'rfc2822'} .
4335                         sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
4336                         "</td></tr>\n";
4337         }
4338         print "</table>\n\n" .
4339               "</div>\n";
4340         print "<div class=\"page_body\">";
4341         my $comment = $tag{'comment'};
4342         foreach my $line (@$comment) {
4343                 chomp $line;
4344                 print esc_html($line, -nbsp=>1) . "<br/>\n";
4345         }
4346         print "</div>\n";
4347         git_footer_html();
4348 }
4349
4350 sub git_blame {
4351         my $fd;
4352         my $ftype;
4353
4354         gitweb_check_feature('blame')
4355             or die_error(403, "Blame view not allowed");
4356
4357         die_error(400, "No file name given") unless $file_name;
4358         $hash_base ||= git_get_head_hash($project);
4359         die_error(404, "Couldn't find base commit") unless ($hash_base);
4360         my %co = parse_commit($hash_base)
4361                 or die_error(404, "Commit not found");
4362         if (!defined $hash) {
4363                 $hash = git_get_hash_by_path($hash_base, $file_name, "blob")
4364                         or die_error(404, "Error looking up file");
4365         }
4366         $ftype = git_get_type($hash);
4367         if ($ftype !~ "blob") {
4368                 die_error(400, "Object is not a blob");
4369         }
4370         open ($fd, "-|", git_cmd(), "blame", '-p', '--',
4371               $file_name, $hash_base)
4372                 or die_error(500, "Open git-blame failed");
4373         git_header_html();
4374         my $formats_nav =
4375                 $cgi->a({-href => href(action=>"blob", -replay=>1)},
4376                         "blob") .
4377                 " | " .
4378                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4379                         "history") .
4380                 " | " .
4381                 $cgi->a({-href => href(action=>"blame", file_name=>$file_name)},
4382                         "HEAD");
4383         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4384         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
4385         git_print_page_path($file_name, $ftype, $hash_base);
4386         my @rev_color = (qw(light2 dark2));
4387         my $num_colors = scalar(@rev_color);
4388         my $current_color = 0;
4389         my $last_rev;
4390         print <<HTML;
4391 <div class="page_body">
4392 <table class="blame">
4393 <tr><th>Commit</th><th>Line</th><th>Data</th></tr>
4394 HTML
4395         my %metainfo = ();
4396         while (1) {
4397                 $_ = <$fd>;
4398                 last unless defined $_;
4399                 my ($full_rev, $orig_lineno, $lineno, $group_size) =
4400                     /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/;
4401                 if (!exists $metainfo{$full_rev}) {
4402                         $metainfo{$full_rev} = {};
4403                 }
4404                 my $meta = $metainfo{$full_rev};
4405                 while (<$fd>) {
4406                         last if (s/^\t//);
4407                         if (/^(\S+) (.*)$/) {
4408                                 $meta->{$1} = $2;
4409                         }
4410                 }
4411                 my $data = $_;
4412                 chomp $data;
4413                 my $rev = substr($full_rev, 0, 8);
4414                 my $author = $meta->{'author'};
4415                 my %date = parse_date($meta->{'author-time'},
4416                                       $meta->{'author-tz'});
4417                 my $date = $date{'iso-tz'};
4418                 if ($group_size) {
4419                         $current_color = ++$current_color % $num_colors;
4420                 }
4421                 print "<tr class=\"$rev_color[$current_color]\">\n";
4422                 if ($group_size) {
4423                         print "<td class=\"sha1\"";
4424                         print " title=\"". esc_html($author) . ", $date\"";
4425                         print " rowspan=\"$group_size\"" if ($group_size > 1);
4426                         print ">";
4427                         print $cgi->a({-href => href(action=>"commit",
4428                                                      hash=>$full_rev,
4429                                                      file_name=>$file_name)},
4430                                       esc_html($rev));
4431                         print "</td>\n";
4432                 }
4433                 open (my $dd, "-|", git_cmd(), "rev-parse", "$full_rev^")
4434                         or die_error(500, "Open git-rev-parse failed");
4435                 my $parent_commit = <$dd>;
4436                 close $dd;
4437                 chomp($parent_commit);
4438                 my $blamed = href(action => 'blame',
4439                                   file_name => $meta->{'filename'},
4440                                   hash_base => $parent_commit);
4441                 print "<td class=\"linenr\">";
4442                 print $cgi->a({ -href => "$blamed#l$orig_lineno",
4443                                 -id => "l$lineno",
4444                                 -class => "linenr" },
4445                               esc_html($lineno));
4446                 print "</td>";
4447                 print "<td class=\"pre\">" . esc_html($data) . "</td>\n";
4448                 print "</tr>\n";
4449         }
4450         print "</table>\n";
4451         print "</div>";
4452         close $fd
4453                 or print "Reading blob failed\n";
4454         git_footer_html();
4455 }
4456
4457 sub git_tags {
4458         my $head = git_get_head_hash($project);
4459         git_header_html();
4460         git_print_page_nav('','', $head,undef,$head);
4461         git_print_header_div('summary', $project);
4462
4463         my @tagslist = git_get_tags_list();
4464         if (@tagslist) {
4465                 git_tags_body(\@tagslist);
4466         }
4467         git_footer_html();
4468 }
4469
4470 sub git_heads {
4471         my $head = git_get_head_hash($project);
4472         git_header_html();
4473         git_print_page_nav('','', $head,undef,$head);
4474         git_print_header_div('summary', $project);
4475
4476         my @headslist = git_get_heads_list();
4477         if (@headslist) {
4478                 git_heads_body(\@headslist, $head);
4479         }
4480         git_footer_html();
4481 }
4482
4483 sub git_blob_plain {
4484         my $type = shift;
4485         my $expires;
4486
4487         if (!defined $hash) {
4488                 if (defined $file_name) {
4489                         my $base = $hash_base || git_get_head_hash($project);
4490                         $hash = git_get_hash_by_path($base, $file_name, "blob")
4491                                 or die_error(404, "Cannot find file");
4492                 } else {
4493                         die_error(400, "No file name defined");
4494                 }
4495         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4496                 # blobs defined by non-textual hash id's can be cached
4497                 $expires = "+1d";
4498         }
4499
4500         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4501                 or die_error(500, "Open git-cat-file blob '$hash' failed");
4502
4503         # content-type (can include charset)
4504         $type = blob_contenttype($fd, $file_name, $type);
4505
4506         # "save as" filename, even when no $file_name is given
4507         my $save_as = "$hash";
4508         if (defined $file_name) {
4509                 $save_as = $file_name;
4510         } elsif ($type =~ m/^text\//) {
4511                 $save_as .= '.txt';
4512         }
4513
4514         print $cgi->header(
4515                 -type => $type,
4516                 -expires => $expires,
4517                 -content_disposition => 'inline; filename="' . $save_as . '"');
4518         undef $/;
4519         binmode STDOUT, ':raw';
4520         print <$fd>;
4521         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
4522         $/ = "\n";
4523         close $fd;
4524 }
4525
4526 sub git_blob {
4527         my $expires;
4528
4529         if (!defined $hash) {
4530                 if (defined $file_name) {
4531                         my $base = $hash_base || git_get_head_hash($project);
4532                         $hash = git_get_hash_by_path($base, $file_name, "blob")
4533                                 or die_error(404, "Cannot find file");
4534                 } else {
4535                         die_error(400, "No file name defined");
4536                 }
4537         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4538                 # blobs defined by non-textual hash id's can be cached
4539                 $expires = "+1d";
4540         }
4541
4542         my ($have_blame) = gitweb_check_feature('blame');
4543         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4544                 or die_error(500, "Couldn't cat $file_name, $hash");
4545         my $mimetype = blob_mimetype($fd, $file_name);
4546         if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B $fd) {
4547                 close $fd;
4548                 return git_blob_plain($mimetype);
4549         }
4550         # we can have blame only for text/* mimetype
4551         $have_blame &&= ($mimetype =~ m!^text/!);
4552
4553         git_header_html(undef, $expires);
4554         my $formats_nav = '';
4555         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
4556                 if (defined $file_name) {
4557                         if ($have_blame) {
4558                                 $formats_nav .=
4559                                         $cgi->a({-href => href(action=>"blame", -replay=>1)},
4560                                                 "blame") .
4561                                         " | ";
4562                         }
4563                         $formats_nav .=
4564                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4565                                         "history") .
4566                                 " | " .
4567                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
4568                                         "raw") .
4569                                 " | " .
4570                                 $cgi->a({-href => href(action=>"blob",
4571                                                        hash_base=>"HEAD", file_name=>$file_name)},
4572                                         "HEAD");
4573                 } else {
4574                         $formats_nav .=
4575                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
4576                                         "raw");
4577                 }
4578                 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4579                 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
4580         } else {
4581                 print "<div class=\"page_nav\">\n" .
4582                       "<br/><br/></div>\n" .
4583                       "<div class=\"title\">$hash</div>\n";
4584         }
4585         git_print_page_path($file_name, "blob", $hash_base);
4586         print "<div class=\"page_body\">\n";
4587         if ($mimetype =~ m!^image/!) {
4588                 print qq!<img type="$mimetype"!;
4589                 if ($file_name) {
4590                         print qq! alt="$file_name" title="$file_name"!;
4591                 }
4592                 print qq! src="! .
4593                       href(action=>"blob_plain", hash=>$hash,
4594                            hash_base=>$hash_base, file_name=>$file_name) .
4595                       qq!" />\n!;
4596         } else {
4597                 my $nr;
4598                 while (my $line = <$fd>) {
4599                         chomp $line;
4600                         $nr++;
4601                         $line = untabify($line);
4602                         printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
4603                                $nr, $nr, $nr, esc_html($line, -nbsp=>1);
4604                 }
4605         }
4606         close $fd
4607                 or print "Reading blob failed.\n";
4608         print "</div>";
4609         git_footer_html();
4610 }
4611
4612 sub git_tree {
4613         if (!defined $hash_base) {
4614                 $hash_base = "HEAD";
4615         }
4616         if (!defined $hash) {
4617                 if (defined $file_name) {
4618                         $hash = git_get_hash_by_path($hash_base, $file_name, "tree");
4619                 } else {
4620                         $hash = $hash_base;
4621                 }
4622         }
4623         die_error(404, "No such tree") unless defined($hash);
4624         $/ = "\0";
4625         open my $fd, "-|", git_cmd(), "ls-tree", '-z', $hash
4626                 or die_error(500, "Open git-ls-tree failed");
4627         my @entries = map { chomp; $_ } <$fd>;
4628         close $fd or die_error(404, "Reading tree failed");
4629         $/ = "\n";
4630
4631         my $refs = git_get_references();
4632         my $ref = format_ref_marker($refs, $hash_base);
4633         git_header_html();
4634         my $basedir = '';
4635         my ($have_blame) = gitweb_check_feature('blame');
4636         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
4637                 my @views_nav = ();
4638                 if (defined $file_name) {
4639                         push @views_nav,
4640                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4641                                         "history"),
4642                                 $cgi->a({-href => href(action=>"tree",
4643                                                        hash_base=>"HEAD", file_name=>$file_name)},
4644                                         "HEAD"),
4645                 }
4646                 my $snapshot_links = format_snapshot_links($hash);
4647                 if (defined $snapshot_links) {
4648                         # FIXME: Should be available when we have no hash base as well.
4649                         push @views_nav, $snapshot_links;
4650                 }
4651                 git_print_page_nav('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
4652                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash_base);
4653         } else {
4654                 undef $hash_base;
4655                 print "<div class=\"page_nav\">\n";
4656                 print "<br/><br/></div>\n";
4657                 print "<div class=\"title\">$hash</div>\n";
4658         }
4659         if (defined $file_name) {
4660                 $basedir = $file_name;
4661                 if ($basedir ne '' && substr($basedir, -1) ne '/') {
4662                         $basedir .= '/';
4663                 }
4664                 git_print_page_path($file_name, 'tree', $hash_base);
4665         }
4666         print "<div class=\"page_body\">\n";
4667         print "<table class=\"tree\">\n";
4668         my $alternate = 1;
4669         # '..' (top directory) link if possible
4670         if (defined $hash_base &&
4671             defined $file_name && $file_name =~ m![^/]+$!) {
4672                 if ($alternate) {
4673                         print "<tr class=\"dark\">\n";
4674                 } else {
4675                         print "<tr class=\"light\">\n";
4676                 }
4677                 $alternate ^= 1;
4678
4679                 my $up = $file_name;
4680                 $up =~ s!/?[^/]+$!!;
4681                 undef $up unless $up;
4682                 # based on git_print_tree_entry
4683                 print '<td class="mode">' . mode_str('040000') . "</td>\n";
4684                 print '<td class="list">';
4685                 print $cgi->a({-href => href(action=>"tree", hash_base=>$hash_base,
4686                                              file_name=>$up)},
4687                               "..");
4688                 print "</td>\n";
4689                 print "<td class=\"link\"></td>\n";
4690
4691                 print "</tr>\n";
4692         }
4693         foreach my $line (@entries) {
4694                 my %t = parse_ls_tree_line($line, -z => 1);
4695
4696                 if ($alternate) {
4697                         print "<tr class=\"dark\">\n";
4698                 } else {
4699                         print "<tr class=\"light\">\n";
4700                 }
4701                 $alternate ^= 1;
4702
4703                 git_print_tree_entry(\%t, $basedir, $hash_base, $have_blame);
4704
4705                 print "</tr>\n";
4706         }
4707         print "</table>\n" .
4708               "</div>";
4709         git_footer_html();
4710 }
4711
4712 sub git_snapshot {
4713         my @supported_fmts = gitweb_check_feature('snapshot');
4714         @supported_fmts = filter_snapshot_fmts(@supported_fmts);
4715
4716         my $format = $cgi->param('sf');
4717         if (!@supported_fmts) {
4718                 die_error(403, "Snapshots not allowed");
4719         }
4720         # default to first supported snapshot format
4721         $format ||= $supported_fmts[0];
4722         if ($format !~ m/^[a-z0-9]+$/) {
4723                 die_error(400, "Invalid snapshot format parameter");
4724         } elsif (!exists($known_snapshot_formats{$format})) {
4725                 die_error(400, "Unknown snapshot format");
4726         } elsif (!grep($_ eq $format, @supported_fmts)) {
4727                 die_error(403, "Unsupported snapshot format");
4728         }
4729
4730         if (!defined $hash) {
4731                 $hash = git_get_head_hash($project);
4732         }
4733
4734         my $name = $project;
4735         $name =~ s,([^/])/*\.git$,$1,;
4736         $name = basename($name);
4737         my $filename = to_utf8($name);
4738         $name =~ s/\047/\047\\\047\047/g;
4739         my $cmd;
4740         $filename .= "-$hash$known_snapshot_formats{$format}{'suffix'}";
4741         $cmd = quote_command(
4742                 git_cmd(), 'archive',
4743                 "--format=$known_snapshot_formats{$format}{'format'}",
4744                 "--prefix=$name/", $hash);
4745         if (exists $known_snapshot_formats{$format}{'compressor'}) {
4746                 $cmd .= ' | ' . quote_command(@{$known_snapshot_formats{$format}{'compressor'}});
4747         }
4748
4749         print $cgi->header(
4750                 -type => $known_snapshot_formats{$format}{'type'},
4751                 -content_disposition => 'inline; filename="' . "$filename" . '"',
4752                 -status => '200 OK');
4753
4754         open my $fd, "-|", $cmd
4755                 or die_error(500, "Execute git-archive failed");
4756         binmode STDOUT, ':raw';
4757         print <$fd>;
4758         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
4759         close $fd;
4760 }
4761
4762 sub git_log {
4763         my $head = git_get_head_hash($project);
4764         if (!defined $hash) {
4765                 $hash = $head;
4766         }
4767         if (!defined $page) {
4768                 $page = 0;
4769         }
4770         my $refs = git_get_references();
4771
4772         my @commitlist = parse_commits($hash, 101, (100 * $page));
4773
4774         my $paging_nav = format_log_nav('log', $hash, $head, $page, $#commitlist >= 100);
4775
4776         {
4777                 local $action = 'fulllog';
4778                 git_header_html();
4779         }
4780         git_print_page_nav('log','', $hash,undef,undef, $paging_nav);
4781
4782         if (!@commitlist) {
4783                 my %co = parse_commit($hash);
4784
4785                 git_print_header_div('summary', $project);
4786                 print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
4787         }
4788         my $to = ($#commitlist >= 99) ? (99) : ($#commitlist);
4789         for (my $i = 0; $i <= $to; $i++) {
4790                 my %co = %{$commitlist[$i]};
4791                 next if !%co;
4792                 my $commit = $co{'id'};
4793                 my $ref = format_ref_marker($refs, $commit);
4794                 my %ad = parse_date($co{'author_epoch'});
4795                 git_print_header_div('commit',
4796                                "<span class=\"age\">$co{'age_string'}</span>" .
4797                                esc_html($co{'title'}) . $ref,
4798                                $commit);
4799                 print "<div class=\"title_text\">\n" .
4800                       "<div class=\"log_link\">\n" .
4801                       $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") .
4802                       " | " .
4803                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") .
4804                       " | " .
4805                       $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree") .
4806                       "<br/>\n" .
4807                       "</div>\n" .
4808                       "<i>" . esc_html($co{'author_name'}) .  " [$ad{'rfc2822'}]</i><br/>\n" .
4809                       "</div>\n";
4810
4811                 print "<div class=\"log_body\">\n";
4812                 git_print_log($co{'comment'}, -final_empty_line=> 1);
4813                 print "</div>\n";
4814         }
4815         if ($#commitlist >= 100) {
4816                 print "<div class=\"page_nav\">\n";
4817                 print $cgi->a({-href => href(-replay=>1, page=>$page+1),
4818                                -accesskey => "n", -title => "Alt-n"}, "next");
4819                 print "</div>\n";
4820         }
4821         git_footer_html();
4822 }
4823
4824 sub git_commit {
4825         $hash ||= $hash_base || "HEAD";
4826         my %co = parse_commit($hash)
4827             or die_error(404, "Unknown commit object");
4828         my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
4829         my %cd = parse_date($co{'committer_epoch'}, $co{'committer_tz'});
4830
4831         my $parent  = $co{'parent'};
4832         my $parents = $co{'parents'}; # listref
4833
4834         # we need to prepare $formats_nav before any parameter munging
4835         my $formats_nav;
4836         if (!defined $parent) {
4837                 # --root commitdiff
4838                 $formats_nav .= '(initial)';
4839         } elsif (@$parents == 1) {
4840                 # single parent commit
4841                 $formats_nav .=
4842                         '(parent: ' .
4843                         $cgi->a({-href => href(action=>"commit",
4844                                                hash=>$parent)},
4845                                 esc_html(substr($parent, 0, 7))) .
4846                         ')';
4847         } else {
4848                 # merge commit
4849                 $formats_nav .=
4850                         '(merge: ' .
4851                         join(' ', map {
4852                                 $cgi->a({-href => href(action=>"commit",
4853                                                        hash=>$_)},
4854                                         esc_html(substr($_, 0, 7)));
4855                         } @$parents ) .
4856                         ')';
4857         }
4858
4859         if (!defined $parent) {
4860                 $parent = "--root";
4861         }
4862         my @difftree;
4863         open my $fd, "-|", git_cmd(), "diff-tree", '-r', "--no-commit-id",
4864                 @diff_opts,
4865                 (@$parents <= 1 ? $parent : '-c'),
4866                 $hash, "--"
4867                 or die_error(500, "Open git-diff-tree failed");
4868         @difftree = map { chomp; $_ } <$fd>;
4869         close $fd or die_error(404, "Reading git-diff-tree failed");
4870
4871         # non-textual hash id's can be cached
4872         my $expires;
4873         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4874                 $expires = "+1d";
4875         }
4876         my $refs = git_get_references();
4877         my $ref = format_ref_marker($refs, $co{'id'});
4878
4879         git_header_html(undef, $expires);
4880         git_print_page_nav('commit', '',
4881                            $hash, $co{'tree'}, $hash,
4882                            $formats_nav);
4883
4884         if (defined $co{'parent'}) {
4885                 git_print_header_div('commitdiff', esc_html($co{'title'}) . $ref, $hash);
4886         } else {
4887                 git_print_header_div('tree', esc_html($co{'title'}) . $ref, $co{'tree'}, $hash);
4888         }
4889         print "<div class=\"title_text\">\n" .
4890               "<table class=\"object_header\">\n";
4891         print "<tr><td>author</td><td>" . esc_html($co{'author'}) . "</td></tr>\n".
4892               "<tr>" .
4893               "<td></td><td> $ad{'rfc2822'}";
4894         if ($ad{'hour_local'} < 6) {
4895                 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
4896                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
4897         } else {
4898                 printf(" (%02d:%02d %s)",
4899                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
4900         }
4901         print "</td>" .
4902               "</tr>\n";
4903         print "<tr><td>committer</td><td>" . esc_html($co{'committer'}) . "</td></tr>\n";
4904         print "<tr><td></td><td> $cd{'rfc2822'}" .
4905               sprintf(" (%02d:%02d %s)", $cd{'hour_local'}, $cd{'minute_local'}, $cd{'tz_local'}) .
4906               "</td></tr>\n";
4907         print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
4908         print "<tr>" .
4909               "<td>tree</td>" .
4910               "<td class=\"sha1\">" .
4911               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash),
4912                        class => "list"}, $co{'tree'}) .
4913               "</td>" .
4914               "<td class=\"link\">" .
4915               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash)},
4916                       "tree");
4917         my $snapshot_links = format_snapshot_links($hash);
4918         if (defined $snapshot_links) {
4919                 print " | " . $snapshot_links;
4920         }
4921         print "</td>" .
4922               "</tr>\n";
4923
4924         foreach my $par (@$parents) {
4925                 print "<tr>" .
4926                       "<td>parent</td>" .
4927                       "<td class=\"sha1\">" .
4928                       $cgi->a({-href => href(action=>"commit", hash=>$par),
4929                                class => "list"}, $par) .
4930                       "</td>" .
4931                       "<td class=\"link\">" .
4932                       $cgi->a({-href => href(action=>"commit", hash=>$par)}, "commit") .
4933                       " | " .
4934                       $cgi->a({-href => href(action=>"commitdiff", hash=>$hash, hash_parent=>$par)}, "diff") .
4935                       "</td>" .
4936                       "</tr>\n";
4937         }
4938         print "</table>".
4939               "</div>\n";
4940
4941         print "<div class=\"page_body\">\n";
4942         git_print_log($co{'comment'});
4943         print "</div>\n";
4944
4945         git_difftree_body(\@difftree, $hash, @$parents);
4946
4947         git_footer_html();
4948 }
4949
4950 sub git_object {
4951         # object is defined by:
4952         # - hash or hash_base alone
4953         # - hash_base and file_name
4954         my $type;
4955
4956         # - hash or hash_base alone
4957         if ($hash || ($hash_base && !defined $file_name)) {
4958                 my $object_id = $hash || $hash_base;
4959
4960                 open my $fd, "-|", quote_command(
4961                         git_cmd(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
4962                         or die_error(404, "Object does not exist");
4963                 $type = <$fd>;
4964                 chomp $type;
4965                 close $fd
4966                         or die_error(404, "Object does not exist");
4967
4968         # - hash_base and file_name
4969         } elsif ($hash_base && defined $file_name) {
4970                 $file_name =~ s,/+$,,;
4971
4972                 system(git_cmd(), "cat-file", '-e', $hash_base) == 0
4973                         or die_error(404, "Base object does not exist");
4974
4975                 # here errors should not hapen
4976                 open my $fd, "-|", git_cmd(), "ls-tree", $hash_base, "--", $file_name
4977                         or die_error(500, "Open git-ls-tree failed");
4978                 my $line = <$fd>;
4979                 close $fd;
4980
4981                 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
4982                 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
4983                         die_error(404, "File or directory for given base does not exist");
4984                 }
4985                 $type = $2;
4986                 $hash = $3;
4987         } else {
4988                 die_error(400, "Not enough information to find object");
4989         }
4990
4991         print $cgi->redirect(-uri => href(action=>$type, -full=>1,
4992                                           hash=>$hash, hash_base=>$hash_base,
4993                                           file_name=>$file_name),
4994                              -status => '302 Found');
4995 }
4996
4997 sub git_blobdiff {
4998         my $format = shift || 'html';
4999
5000         my $fd;
5001         my @difftree;
5002         my %diffinfo;
5003         my $expires;
5004
5005         # preparing $fd and %diffinfo for git_patchset_body
5006         # new style URI
5007         if (defined $hash_base && defined $hash_parent_base) {
5008                 if (defined $file_name) {
5009                         # read raw output
5010                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5011                                 $hash_parent_base, $hash_base,
5012                                 "--", (defined $file_parent ? $file_parent : ()), $file_name
5013                                 or die_error(500, "Open git-diff-tree failed");
5014                         @difftree = map { chomp; $_ } <$fd>;
5015                         close $fd
5016                                 or die_error(404, "Reading git-diff-tree failed");
5017                         @difftree
5018                                 or die_error(404, "Blob diff not found");
5019
5020                 } elsif (defined $hash &&
5021                          $hash =~ /[0-9a-fA-F]{40}/) {
5022                         # try to find filename from $hash
5023
5024                         # read filtered raw output
5025                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5026                                 $hash_parent_base, $hash_base, "--"
5027                                 or die_error(500, "Open git-diff-tree failed");
5028                         @difftree =
5029                                 # ':100644 100644 03b21826... 3b93d5e7... M     ls-files.c'
5030                                 # $hash == to_id
5031                                 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
5032                                 map { chomp; $_ } <$fd>;
5033                         close $fd
5034                                 or die_error(404, "Reading git-diff-tree failed");
5035                         @difftree
5036                                 or die_error(404, "Blob diff not found");
5037
5038                 } else {
5039                         die_error(400, "Missing one of the blob diff parameters");
5040                 }
5041
5042                 if (@difftree > 1) {
5043                         die_error(400, "Ambiguous blob diff specification");
5044                 }
5045
5046                 %diffinfo = parse_difftree_raw_line($difftree[0]);
5047                 $file_parent ||= $diffinfo{'from_file'} || $file_name;
5048                 $file_name   ||= $diffinfo{'to_file'};
5049
5050                 $hash_parent ||= $diffinfo{'from_id'};
5051                 $hash        ||= $diffinfo{'to_id'};
5052
5053                 # non-textual hash id's can be cached
5054                 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
5055                     $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
5056                         $expires = '+1d';
5057                 }
5058
5059                 # open patch output
5060                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5061                         '-p', ($format eq 'html' ? "--full-index" : ()),
5062                         $hash_parent_base, $hash_base,
5063                         "--", (defined $file_parent ? $file_parent : ()), $file_name
5064                         or die_error(500, "Open git-diff-tree failed");
5065         }
5066
5067         # old/legacy style URI
5068         if (!%diffinfo && # if new style URI failed
5069             defined $hash && defined $hash_parent) {
5070                 # fake git-diff-tree raw output
5071                 $diffinfo{'from_mode'} = $diffinfo{'to_mode'} = "blob";
5072                 $diffinfo{'from_id'} = $hash_parent;
5073                 $diffinfo{'to_id'}   = $hash;
5074                 if (defined $file_name) {
5075                         if (defined $file_parent) {
5076                                 $diffinfo{'status'} = '2';
5077                                 $diffinfo{'from_file'} = $file_parent;
5078                                 $diffinfo{'to_file'}   = $file_name;
5079                         } else { # assume not renamed
5080                                 $diffinfo{'status'} = '1';
5081                                 $diffinfo{'from_file'} = $file_name;
5082                                 $diffinfo{'to_file'}   = $file_name;
5083                         }
5084                 } else { # no filename given
5085                         $diffinfo{'status'} = '2';
5086                         $diffinfo{'from_file'} = $hash_parent;
5087                         $diffinfo{'to_file'}   = $hash;
5088                 }
5089
5090                 # non-textual hash id's can be cached
5091                 if ($hash =~ m/^[0-9a-fA-F]{40}$/ &&
5092                     $hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5093                         $expires = '+1d';
5094                 }
5095
5096                 # open patch output
5097                 open $fd, "-|", git_cmd(), "diff", @diff_opts,
5098                         '-p', ($format eq 'html' ? "--full-index" : ()),
5099                         $hash_parent, $hash, "--"
5100                         or die_error(500, "Open git-diff failed");
5101         } else  {
5102                 die_error(400, "Missing one of the blob diff parameters")
5103                         unless %diffinfo;
5104         }
5105
5106         # header
5107         if ($format eq 'html') {
5108                 my $formats_nav =
5109                         $cgi->a({-href => href(action=>"blobdiff_plain", -replay=>1)},
5110                                 "raw");
5111                 git_header_html(undef, $expires);
5112                 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
5113                         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5114                         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
5115                 } else {
5116                         print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
5117                         print "<div class=\"title\">$hash vs $hash_parent</div>\n";
5118                 }
5119                 if (defined $file_name) {
5120                         git_print_page_path($file_name, "blob", $hash_base);
5121                 } else {
5122                         print "<div class=\"page_path\"></div>\n";
5123                 }
5124
5125         } elsif ($format eq 'plain') {
5126                 print $cgi->header(
5127                         -type => 'text/plain',
5128                         -charset => 'utf-8',
5129                         -expires => $expires,
5130                         -content_disposition => 'inline; filename="' . "$file_name" . '.patch"');
5131
5132                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5133
5134         } else {
5135                 die_error(400, "Unknown blobdiff format");
5136         }
5137
5138         # patch
5139         if ($format eq 'html') {
5140                 print "<div class=\"page_body\">\n";
5141
5142                 git_patchset_body($fd, [ \%diffinfo ], $hash_base, $hash_parent_base);
5143                 close $fd;
5144
5145                 print "</div>\n"; # class="page_body"
5146                 git_footer_html();
5147
5148         } else {
5149                 while (my $line = <$fd>) {
5150                         $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
5151                         $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
5152
5153                         print $line;
5154
5155                         last if $line =~ m!^\+\+\+!;
5156                 }
5157                 local $/ = undef;
5158                 print <$fd>;
5159                 close $fd;
5160         }
5161 }
5162
5163 sub git_blobdiff_plain {
5164         git_blobdiff('plain');
5165 }
5166
5167 sub git_commitdiff {
5168         my $format = shift || 'html';
5169         $hash ||= $hash_base || "HEAD";
5170         my %co = parse_commit($hash)
5171             or die_error(404, "Unknown commit object");
5172
5173         # choose format for commitdiff for merge
5174         if (! defined $hash_parent && @{$co{'parents'}} > 1) {
5175                 $hash_parent = '--cc';
5176         }
5177         # we need to prepare $formats_nav before almost any parameter munging
5178         my $formats_nav;
5179         if ($format eq 'html') {
5180                 $formats_nav =
5181                         $cgi->a({-href => href(action=>"commitdiff_plain", -replay=>1)},
5182                                 "raw");
5183
5184                 if (defined $hash_parent &&
5185                     $hash_parent ne '-c' && $hash_parent ne '--cc') {
5186                         # commitdiff with two commits given
5187                         my $hash_parent_short = $hash_parent;
5188                         if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5189                                 $hash_parent_short = substr($hash_parent, 0, 7);
5190                         }
5191                         $formats_nav .=
5192                                 ' (from';
5193                         for (my $i = 0; $i < @{$co{'parents'}}; $i++) {
5194                                 if ($co{'parents'}[$i] eq $hash_parent) {
5195                                         $formats_nav .= ' parent ' . ($i+1);
5196                                         last;
5197                                 }
5198                         }
5199                         $formats_nav .= ': ' .
5200                                 $cgi->a({-href => href(action=>"commitdiff",
5201                                                        hash=>$hash_parent)},
5202                                         esc_html($hash_parent_short)) .
5203                                 ')';
5204                 } elsif (!$co{'parent'}) {
5205                         # --root commitdiff
5206                         $formats_nav .= ' (initial)';
5207                 } elsif (scalar @{$co{'parents'}} == 1) {
5208                         # single parent commit
5209                         $formats_nav .=
5210                                 ' (parent: ' .
5211                                 $cgi->a({-href => href(action=>"commitdiff",
5212                                                        hash=>$co{'parent'})},
5213                                         esc_html(substr($co{'parent'}, 0, 7))) .
5214                                 ')';
5215                 } else {
5216                         # merge commit
5217                         if ($hash_parent eq '--cc') {
5218                                 $formats_nav .= ' | ' .
5219                                         $cgi->a({-href => href(action=>"commitdiff",
5220                                                                hash=>$hash, hash_parent=>'-c')},
5221                                                 'combined');
5222                         } else { # $hash_parent eq '-c'
5223                                 $formats_nav .= ' | ' .
5224                                         $cgi->a({-href => href(action=>"commitdiff",
5225                                                                hash=>$hash, hash_parent=>'--cc')},
5226                                                 'compact');
5227                         }
5228                         $formats_nav .=
5229                                 ' (merge: ' .
5230                                 join(' ', map {
5231                                         $cgi->a({-href => href(action=>"commitdiff",
5232                                                                hash=>$_)},
5233                                                 esc_html(substr($_, 0, 7)));
5234                                 } @{$co{'parents'}} ) .
5235                                 ')';
5236                 }
5237         }
5238
5239         my $hash_parent_param = $hash_parent;
5240         if (!defined $hash_parent_param) {
5241                 # --cc for multiple parents, --root for parentless
5242                 $hash_parent_param =
5243                         @{$co{'parents'}} > 1 ? '--cc' : $co{'parent'} || '--root';
5244         }
5245
5246         # read commitdiff
5247         my $fd;
5248         my @difftree;
5249         if ($format eq 'html') {
5250                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5251                         "--no-commit-id", "--patch-with-raw", "--full-index",
5252                         $hash_parent_param, $hash, "--"
5253                         or die_error(500, "Open git-diff-tree failed");
5254
5255                 while (my $line = <$fd>) {
5256                         chomp $line;
5257                         # empty line ends raw part of diff-tree output
5258                         last unless $line;
5259                         push @difftree, scalar parse_difftree_raw_line($line);
5260                 }
5261
5262         } elsif ($format eq 'plain') {
5263                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5264                         '-p', $hash_parent_param, $hash, "--"
5265                         or die_error(500, "Open git-diff-tree failed");
5266
5267         } else {
5268                 die_error(400, "Unknown commitdiff format");
5269         }
5270
5271         # non-textual hash id's can be cached
5272         my $expires;
5273         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5274                 $expires = "+1d";
5275         }
5276
5277         # write commit message
5278         if ($format eq 'html') {
5279                 my $refs = git_get_references();
5280                 my $ref = format_ref_marker($refs, $co{'id'});
5281
5282                 git_header_html(undef, $expires);
5283                 git_print_page_nav('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
5284                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash);
5285                 git_print_authorship(\%co);
5286                 print "<div class=\"page_body\">\n";
5287                 if (@{$co{'comment'}} > 1) {
5288                         print "<div class=\"log\">\n";
5289                         git_print_log($co{'comment'}, -final_empty_line=> 1, -remove_title => 1);
5290                         print "</div>\n"; # class="log"
5291                 }
5292
5293         } elsif ($format eq 'plain') {
5294                 my $refs = git_get_references("tags");
5295                 my $tagname = git_get_rev_name_tags($hash);
5296                 my $filename = basename($project) . "-$hash.patch";
5297
5298                 print $cgi->header(
5299                         -type => 'text/plain',
5300                         -charset => 'utf-8',
5301                         -expires => $expires,
5302                         -content_disposition => 'inline; filename="' . "$filename" . '"');
5303                 my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
5304                 print "From: " . to_utf8($co{'author'}) . "\n";
5305                 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
5306                 print "Subject: " . to_utf8($co{'title'}) . "\n";
5307
5308                 print "X-Git-Tag: $tagname\n" if $tagname;
5309                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5310
5311                 foreach my $line (@{$co{'comment'}}) {
5312                         print to_utf8($line) . "\n";
5313                 }
5314                 print "---\n\n";
5315         }
5316
5317         # write patch
5318         if ($format eq 'html') {
5319                 my $use_parents = !defined $hash_parent ||
5320                         $hash_parent eq '-c' || $hash_parent eq '--cc';
5321                 git_difftree_body(\@difftree, $hash,
5322                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
5323                 print "<br/>\n";
5324
5325                 git_patchset_body($fd, \@difftree, $hash,
5326                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
5327                 close $fd;
5328                 print "</div>\n"; # class="page_body"
5329                 git_footer_html();
5330
5331         } elsif ($format eq 'plain') {
5332                 local $/ = undef;
5333                 print <$fd>;
5334                 close $fd
5335                         or print "Reading git-diff-tree failed\n";
5336         }
5337 }
5338
5339 sub git_commitdiff_plain {
5340         git_commitdiff('plain');
5341 }
5342
5343 sub git_history {
5344         if (!defined $hash_base) {
5345                 $hash_base = git_get_head_hash($project);
5346         }
5347         if (!defined $page) {
5348                 $page = 0;
5349         }
5350         my $ftype;
5351         my %co = parse_commit($hash_base)
5352             or die_error(404, "Unknown commit object");
5353
5354         my $refs = git_get_references();
5355         my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
5356
5357         my @commitlist = parse_commits($hash_base, 101, (100 * $page),
5358                                        $file_name, "--full-history")
5359             or die_error(404, "No such file or directory on given branch");
5360
5361         if (!defined $hash && defined $file_name) {
5362                 # some commits could have deleted file in question,
5363                 # and not have it in tree, but one of them has to have it
5364                 for (my $i = 0; $i <= @commitlist; $i++) {
5365                         $hash = git_get_hash_by_path($commitlist[$i]{'id'}, $file_name);
5366                         last if defined $hash;
5367                 }
5368         }
5369         if (defined $hash) {
5370                 $ftype = git_get_type($hash);
5371         }
5372         if (!defined $ftype) {
5373                 die_error(500, "Unknown type of object");
5374         }
5375
5376         my $paging_nav = '';
5377         if ($page > 0) {
5378                 $paging_nav .=
5379                         $cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base,
5380                                                file_name=>$file_name)},
5381                                 "first");
5382                 $paging_nav .= " &sdot; " .
5383                         $cgi->a({-href => href(-replay=>1, page=>$page-1),
5384                                  -accesskey => "p", -title => "Alt-p"}, "prev");
5385         } else {
5386                 $paging_nav .= "first";
5387                 $paging_nav .= " &sdot; prev";
5388         }
5389         my $next_link = '';
5390         if ($#commitlist >= 100) {
5391                 $next_link =
5392                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
5393                                  -accesskey => "n", -title => "Alt-n"}, "next");
5394                 $paging_nav .= " &sdot; $next_link";
5395         } else {
5396                 $paging_nav .= " &sdot; next";
5397         }
5398
5399         git_header_html();
5400         git_print_page_nav('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
5401         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
5402         git_print_page_path($file_name, $ftype, $hash_base);
5403
5404         git_history_body(\@commitlist, 0, 99,
5405                          $refs, $hash_base, $ftype, $next_link);
5406
5407         git_footer_html();
5408 }
5409
5410 sub git_search {
5411         gitweb_check_feature('search') or die_error(403, "Search is disabled");
5412         if (!defined $searchtext) {
5413                 die_error(400, "Text field is empty");
5414         }
5415         if (!defined $hash) {
5416                 $hash = git_get_head_hash($project);
5417         }
5418         my %co = parse_commit($hash);
5419         if (!%co) {
5420                 die_error(404, "Unknown commit object");
5421         }
5422         if (!defined $page) {
5423                 $page = 0;
5424         }
5425
5426         $searchtype ||= 'commit';
5427         if ($searchtype eq 'pickaxe') {
5428                 # pickaxe may take all resources of your box and run for several minutes
5429                 # with every query - so decide by yourself how public you make this feature
5430                 gitweb_check_feature('pickaxe')
5431                     or die_error(403, "Pickaxe is disabled");
5432         }
5433         if ($searchtype eq 'grep') {
5434                 gitweb_check_feature('grep')
5435                     or die_error(403, "Grep is disabled");
5436         }
5437
5438         git_header_html();
5439
5440         if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
5441                 my $greptype;
5442                 if ($searchtype eq 'commit') {
5443                         $greptype = "--grep=";
5444                 } elsif ($searchtype eq 'author') {
5445                         $greptype = "--author=";
5446                 } elsif ($searchtype eq 'committer') {
5447                         $greptype = "--committer=";
5448                 }
5449                 $greptype .= $searchtext;
5450                 my @commitlist = parse_commits($hash, 101, (100 * $page), undef,
5451                                                $greptype, '--regexp-ignore-case',
5452                                                $search_use_regexp ? '--extended-regexp' : '--fixed-strings');
5453
5454                 my $paging_nav = '';
5455                 if ($page > 0) {
5456                         $paging_nav .=
5457                                 $cgi->a({-href => href(action=>"search", hash=>$hash,
5458                                                        searchtext=>$searchtext,
5459                                                        searchtype=>$searchtype)},
5460                                         "first");
5461                         $paging_nav .= " &sdot; " .
5462                                 $cgi->a({-href => href(-replay=>1, page=>$page-1),
5463                                          -accesskey => "p", -title => "Alt-p"}, "prev");
5464                 } else {
5465                         $paging_nav .= "first";
5466                         $paging_nav .= " &sdot; prev";
5467                 }
5468                 my $next_link = '';
5469                 if ($#commitlist >= 100) {
5470                         $next_link =
5471                                 $cgi->a({-href => href(-replay=>1, page=>$page+1),
5472                                          -accesskey => "n", -title => "Alt-n"}, "next");
5473                         $paging_nav .= " &sdot; $next_link";
5474                 } else {
5475                         $paging_nav .= " &sdot; next";
5476                 }
5477
5478                 if ($#commitlist >= 100) {
5479                 }
5480
5481                 git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
5482                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5483                 git_search_grep_body(\@commitlist, 0, 99, $next_link);
5484         }
5485
5486         if ($searchtype eq 'pickaxe') {
5487                 git_print_page_nav('','', $hash,$co{'tree'},$hash);
5488                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5489
5490                 print "<table class=\"pickaxe search\">\n";
5491                 my $alternate = 1;
5492                 $/ = "\n";
5493                 open my $fd, '-|', git_cmd(), '--no-pager', 'log', @diff_opts,
5494                         '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5495                         ($search_use_regexp ? '--pickaxe-regex' : ());
5496                 undef %co;
5497                 my @files;
5498                 while (my $line = <$fd>) {
5499                         chomp $line;
5500                         next unless $line;
5501
5502                         my %set = parse_difftree_raw_line($line);
5503                         if (defined $set{'commit'}) {
5504                                 # finish previous commit
5505                                 if (%co) {
5506                                         print "</td>\n" .
5507                                               "<td class=\"link\">" .
5508                                               $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5509                                               " | " .
5510                                               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5511                                         print "</td>\n" .
5512                                               "</tr>\n";
5513                                 }
5514
5515                                 if ($alternate) {
5516                                         print "<tr class=\"dark\">\n";
5517                                 } else {
5518                                         print "<tr class=\"light\">\n";
5519                                 }
5520                                 $alternate ^= 1;
5521                                 %co = parse_commit($set{'commit'});
5522                                 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
5523                                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5524                                       "<td><i>$author</i></td>\n" .
5525                                       "<td>" .
5526                                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
5527                                               -class => "list subject"},
5528                                               chop_and_escape_str($co{'title'}, 50) . "<br/>");
5529                         } elsif (defined $set{'to_id'}) {
5530                                 next if ($set{'to_id'} =~ m/^0{40}$/);
5531
5532                                 print $cgi->a({-href => href(action=>"blob", hash_base=>$co{'id'},
5533                                                              hash=>$set{'to_id'}, file_name=>$set{'to_file'}),
5534                                               -class => "list"},
5535                                               "<span class=\"match\">" . esc_path($set{'file'}) . "</span>") .
5536                                       "<br/>\n";
5537                         }
5538                 }
5539                 close $fd;
5540
5541                 # finish last commit (warning: repetition!)
5542                 if (%co) {
5543                         print "</td>\n" .
5544                               "<td class=\"link\">" .
5545                               $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5546                               " | " .
5547                               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5548                         print "</td>\n" .
5549                               "</tr>\n";
5550                 }
5551
5552                 print "</table>\n";
5553         }
5554
5555         if ($searchtype eq 'grep') {
5556                 git_print_page_nav('','', $hash,$co{'tree'},$hash);
5557                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5558
5559                 print "<table class=\"grep_search\">\n";
5560                 my $alternate = 1;
5561                 my $matches = 0;
5562                 $/ = "\n";
5563                 open my $fd, "-|", git_cmd(), 'grep', '-n',
5564                         $search_use_regexp ? ('-E', '-i') : '-F',
5565                         $searchtext, $co{'tree'};
5566                 my $lastfile = '';
5567                 while (my $line = <$fd>) {
5568                         chomp $line;
5569                         my ($file, $lno, $ltext, $binary);
5570                         last if ($matches++ > 1000);
5571                         if ($line =~ /^Binary file (.+) matches$/) {
5572                                 $file = $1;
5573                                 $binary = 1;
5574                         } else {
5575                                 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5576                         }
5577                         if ($file ne $lastfile) {
5578                                 $lastfile and print "</td></tr>\n";
5579                                 if ($alternate++) {
5580                                         print "<tr class=\"dark\">\n";
5581                                 } else {
5582                                         print "<tr class=\"light\">\n";
5583                                 }
5584                                 print "<td class=\"list\">".
5585                                         $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5586                                                                file_name=>"$file"),
5587                                                 -class => "list"}, esc_path($file));
5588                                 print "</td><td>\n";
5589                                 $lastfile = $file;
5590                         }
5591                         if ($binary) {
5592                                 print "<div class=\"binary\">Binary file</div>\n";
5593                         } else {
5594                                 $ltext = untabify($ltext);
5595                                 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5596                                         $ltext = esc_html($1, -nbsp=>1);
5597                                         $ltext .= '<span class="match">';
5598                                         $ltext .= esc_html($2, -nbsp=>1);
5599                                         $ltext .= '</span>';
5600                                         $ltext .= esc_html($3, -nbsp=>1);
5601                                 } else {
5602                                         $ltext = esc_html($ltext, -nbsp=>1);
5603                                 }
5604                                 print "<div class=\"pre\">" .
5605                                         $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5606                                                                file_name=>"$file").'#l'.$lno,
5607                                                 -class => "linenr"}, sprintf('%4i', $lno))
5608                                         . ' ' .  $ltext . "</div>\n";
5609                         }
5610                 }
5611                 if ($lastfile) {
5612                         print "</td></tr>\n";
5613                         if ($matches > 1000) {
5614                                 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5615                         }
5616                 } else {
5617                         print "<div class=\"diff nodifferences\">No matches found</div>\n";
5618                 }
5619                 close $fd;
5620
5621                 print "</table>\n";
5622         }
5623         git_footer_html();
5624 }
5625
5626 sub git_search_help {
5627         git_header_html();
5628         git_print_page_nav('','', $hash,$hash,$hash);
5629         print <<EOT;
5630 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
5631 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
5632 the pattern entered is recognized as the POSIX extended
5633 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
5634 insensitive).</p>
5635 <dl>
5636 <dt><b>commit</b></dt>
5637 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
5638 EOT
5639         my ($have_grep) = gitweb_check_feature('grep');
5640         if ($have_grep) {
5641                 print <<EOT;
5642 <dt><b>grep</b></dt>
5643 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
5644     a different one) are searched for the given pattern. On large trees, this search can take
5645 a while and put some strain on the server, so please use it with some consideration. Note that
5646 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
5647 case-sensitive.</dd>
5648 EOT
5649         }
5650         print <<EOT;
5651 <dt><b>author</b></dt>
5652 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
5653 <dt><b>committer</b></dt>
5654 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
5655 EOT
5656         my ($have_pickaxe) = gitweb_check_feature('pickaxe');
5657         if ($have_pickaxe) {
5658                 print <<EOT;
5659 <dt><b>pickaxe</b></dt>
5660 <dd>All commits that caused the string to appear or disappear from any file (changes that
5661 added, removed or "modified" the string) will be listed. This search can take a while and
5662 takes a lot of strain on the server, so please use it wisely. Note that since you may be
5663 interested even in changes just changing the case as well, this search is case sensitive.</dd>
5664 EOT
5665         }
5666         print "</dl>\n";
5667         git_footer_html();
5668 }
5669
5670 sub git_shortlog {
5671         my $head = git_get_head_hash($project);
5672         if (!defined $hash) {
5673                 $hash = $head;
5674         }
5675         if (!defined $page) {
5676                 $page = 0;
5677         }
5678         my $refs = git_get_references();
5679
5680         my $commit_hash = $hash;
5681         if (defined $hash_parent) {
5682                 $commit_hash = "$hash_parent..$hash";
5683         }
5684         my @commitlist = parse_commits($commit_hash, 101, (100 * $page));
5685
5686         my $paging_nav = format_log_nav('shortlog', $hash, $head, $page, $#commitlist >= 100);
5687
5688         my $next_link = '';
5689         if ($#commitlist >= 100) {
5690                 $next_link =
5691                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
5692                                  -accesskey => "n", -title => "Alt-n"}, "next");
5693         }
5694
5695         git_header_html();
5696         git_print_page_nav('shortlog','', $hash,$hash,$hash, $paging_nav);
5697         git_print_header_div('summary', $project);
5698
5699         git_shortlog_body(\@commitlist, 0, 99, $refs, $next_link);
5700
5701         git_footer_html();
5702 }
5703
5704 ## ......................................................................
5705 ## feeds (RSS, Atom; OPML)
5706
5707 sub git_feed {
5708         my $format = shift || 'atom';
5709         my ($have_blame) = gitweb_check_feature('blame');
5710
5711         # Atom: http://www.atomenabled.org/developers/syndication/
5712         # RSS:  http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
5713         if ($format ne 'rss' && $format ne 'atom') {
5714                 die_error(400, "Unknown web feed format");
5715         }
5716
5717         # log/feed of current (HEAD) branch, log of given branch, history of file/directory
5718         my $head = $hash || 'HEAD';
5719         my @commitlist = parse_commits($head, 150, 0, $file_name);
5720
5721         my %latest_commit;
5722         my %latest_date;
5723         my $content_type = "application/$format+xml";
5724         if (defined $cgi->http('HTTP_ACCEPT') &&
5725                  $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
5726                 # browser (feed reader) prefers text/xml
5727                 $content_type = 'text/xml';
5728         }
5729         if (defined($commitlist[0])) {
5730                 %latest_commit = %{$commitlist[0]};
5731                 %latest_date   = parse_date($latest_commit{'author_epoch'});
5732                 print $cgi->header(
5733                         -type => $content_type,
5734                         -charset => 'utf-8',
5735                         -last_modified => $latest_date{'rfc2822'});
5736         } else {
5737                 print $cgi->header(
5738                         -type => $content_type,
5739                         -charset => 'utf-8');
5740         }
5741
5742         # Optimization: skip generating the body if client asks only
5743         # for Last-Modified date.
5744         return if ($cgi->request_method() eq 'HEAD');
5745
5746         # header variables
5747         my $title = "$site_name - $project/$action";
5748         my $feed_type = 'log';
5749         if (defined $hash) {
5750                 $title .= " - '$hash'";
5751                 $feed_type = 'branch log';
5752                 if (defined $file_name) {
5753                         $title .= " :: $file_name";
5754                         $feed_type = 'history';
5755                 }
5756         } elsif (defined $file_name) {
5757                 $title .= " - $file_name";
5758                 $feed_type = 'history';
5759         }
5760         $title .= " $feed_type";
5761         my $descr = git_get_project_description($project);
5762         if (defined $descr) {
5763                 $descr = esc_html($descr);
5764         } else {
5765                 $descr = "$project " .
5766                          ($format eq 'rss' ? 'RSS' : 'Atom') .
5767                          " feed";
5768         }
5769         my $owner = git_get_project_owner($project);
5770         $owner = esc_html($owner);
5771
5772         #header
5773         my $alt_url;
5774         if (defined $file_name) {
5775                 $alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
5776         } elsif (defined $hash) {
5777                 $alt_url = href(-full=>1, action=>"log", hash=>$hash);
5778         } else {
5779                 $alt_url = href(-full=>1, action=>"summary");
5780         }
5781         print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
5782         if ($format eq 'rss') {
5783                 print <<XML;
5784 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
5785 <channel>
5786 XML
5787                 print "<title>$title</title>\n" .
5788                       "<link>$alt_url</link>\n" .
5789                       "<description>$descr</description>\n" .
5790                       "<language>en</language>\n";
5791         } elsif ($format eq 'atom') {
5792                 print <<XML;
5793 <feed xmlns="http://www.w3.org/2005/Atom">
5794 XML
5795                 print "<title>$title</title>\n" .
5796                       "<subtitle>$descr</subtitle>\n" .
5797                       '<link rel="alternate" type="text/html" href="' .
5798                       $alt_url . '" />' . "\n" .
5799                       '<link rel="self" type="' . $content_type . '" href="' .
5800                       $cgi->self_url() . '" />' . "\n" .
5801                       "<id>" . href(-full=>1) . "</id>\n" .
5802                       # use project owner for feed author
5803                       "<author><name>$owner</name></author>\n";
5804                 if (defined $favicon) {
5805                         print "<icon>" . esc_url($favicon) . "</icon>\n";
5806                 }
5807                 if (defined $logo_url) {
5808                         # not twice as wide as tall: 72 x 27 pixels
5809                         print "<logo>" . esc_url($logo) . "</logo>\n";
5810                 }
5811                 if (! %latest_date) {
5812                         # dummy date to keep the feed valid until commits trickle in:
5813                         print "<updated>1970-01-01T00:00:00Z</updated>\n";
5814                 } else {
5815                         print "<updated>$latest_date{'iso-8601'}</updated>\n";
5816                 }
5817         }
5818
5819         # contents
5820         for (my $i = 0; $i <= $#commitlist; $i++) {
5821                 my %co = %{$commitlist[$i]};
5822                 my $commit = $co{'id'};
5823                 # we read 150, we always show 30 and the ones more recent than 48 hours
5824                 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
5825                         last;
5826                 }
5827                 my %cd = parse_date($co{'author_epoch'});
5828
5829                 # get list of changed files
5830                 open my $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5831                         $co{'parent'} || "--root",
5832                         $co{'id'}, "--", (defined $file_name ? $file_name : ())
5833                         or next;
5834                 my @difftree = map { chomp; $_ } <$fd>;
5835                 close $fd
5836                         or next;
5837
5838                 # print element (entry, item)
5839                 my $co_url = href(-full=>1, action=>"commitdiff", hash=>$commit);
5840                 if ($format eq 'rss') {
5841                         print "<item>\n" .
5842                               "<title>" . esc_html($co{'title'}) . "</title>\n" .
5843                               "<author>" . esc_html($co{'author'}) . "</author>\n" .
5844                               "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
5845                               "<guid isPermaLink=\"true\">$co_url</guid>\n" .
5846                               "<link>$co_url</link>\n" .
5847                               "<description>" . esc_html($co{'title'}) . "</description>\n" .
5848                               "<content:encoded>" .
5849                               "<![CDATA[\n";
5850                 } elsif ($format eq 'atom') {
5851                         print "<entry>\n" .
5852                               "<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
5853                               "<updated>$cd{'iso-8601'}</updated>\n" .
5854                               "<author>\n" .
5855                               "  <name>" . esc_html($co{'author_name'}) . "</name>\n";
5856                         if ($co{'author_email'}) {
5857                                 print "  <email>" . esc_html($co{'author_email'}) . "</email>\n";
5858                         }
5859                         print "</author>\n" .
5860                               # use committer for contributor
5861                               "<contributor>\n" .
5862                               "  <name>" . esc_html($co{'committer_name'}) . "</name>\n";
5863                         if ($co{'committer_email'}) {
5864                                 print "  <email>" . esc_html($co{'committer_email'}) . "</email>\n";
5865                         }
5866                         print "</contributor>\n" .
5867                               "<published>$cd{'iso-8601'}</published>\n" .
5868                               "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
5869                               "<id>$co_url</id>\n" .
5870                               "<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
5871                               "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
5872                 }
5873                 my $comment = $co{'comment'};
5874                 print "<pre>\n";
5875                 foreach my $line (@$comment) {
5876                         $line = esc_html($line);
5877                         print "$line\n";
5878                 }
5879                 print "</pre><ul>\n";
5880                 foreach my $difftree_line (@difftree) {
5881                         my %difftree = parse_difftree_raw_line($difftree_line);
5882                         next if !$difftree{'from_id'};
5883
5884                         my $file = $difftree{'file'} || $difftree{'to_file'};
5885
5886                         print "<li>" .
5887                               "[" .
5888                               $cgi->a({-href => href(-full=>1, action=>"blobdiff",
5889                                                      hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
5890                                                      hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
5891                                                      file_name=>$file, file_parent=>$difftree{'from_file'}),
5892                                       -title => "diff"}, 'D');
5893                         if ($have_blame) {
5894                                 print $cgi->a({-href => href(-full=>1, action=>"blame",
5895                                                              file_name=>$file, hash_base=>$commit),
5896                                               -title => "blame"}, 'B');
5897                         }
5898                         # if this is not a feed of a file history
5899                         if (!defined $file_name || $file_name ne $file) {
5900                                 print $cgi->a({-href => href(-full=>1, action=>"history",
5901                                                              file_name=>$file, hash=>$commit),
5902                                               -title => "history"}, 'H');
5903                         }
5904                         $file = esc_path($file);
5905                         print "] ".
5906                               "$file</li>\n";
5907                 }
5908                 if ($format eq 'rss') {
5909                         print "</ul>]]>\n" .
5910                               "</content:encoded>\n" .
5911                               "</item>\n";
5912                 } elsif ($format eq 'atom') {
5913                         print "</ul>\n</div>\n" .
5914                               "</content>\n" .
5915                               "</entry>\n";
5916                 }
5917         }
5918
5919         # end of feed
5920         if ($format eq 'rss') {
5921                 print "</channel>\n</rss>\n";
5922         }       elsif ($format eq 'atom') {
5923                 print "</feed>\n";
5924         }
5925 }
5926
5927 sub git_rss {
5928         git_feed('rss');
5929 }
5930
5931 sub git_atom {
5932         git_feed('atom');
5933 }
5934
5935 sub git_opml {
5936         my @list = git_get_projects_list();
5937
5938         print $cgi->header(-type => 'text/xml', -charset => 'utf-8');
5939         print <<XML;
5940 <?xml version="1.0" encoding="utf-8"?>
5941 <opml version="1.0">
5942 <head>
5943   <title>$site_name OPML Export</title>
5944 </head>
5945 <body>
5946 <outline text="git RSS feeds">
5947 XML
5948
5949         foreach my $pr (@list) {
5950                 my %proj = %$pr;
5951                 my $head = git_get_head_hash($proj{'path'});
5952                 if (!defined $head) {
5953                         next;
5954                 }
5955                 $git_dir = "$projectroot/$proj{'path'}";
5956                 my %co = parse_commit($head);
5957                 if (!%co) {
5958                         next;
5959                 }
5960
5961                 my $path = esc_html(chop_str($proj{'path'}, 25, 5));
5962                 my $rss  = "$my_url?p=$proj{'path'};a=rss";
5963                 my $html = "$my_url?p=$proj{'path'};a=summary";
5964                 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";
5965         }
5966         print <<XML;
5967 </outline>
5968 </body>
5969 </opml>
5970 XML
5971 }