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

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