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 # print 'sort by' <th> element, either sorting by $key if $name eq $order
3603 # (changing $list), or generating 'sort by $name' replay link otherwise
3604 sub print_sort_th {
3605         my ($str_sort, $name, $order, $key, $header, $list) = @_;
3606         $key    ||= $name;
3607         $header ||= ucfirst($name);
3608
3609         if ($order eq $name) {
3610                 if ($str_sort) {
3611                         @$list = sort {$a->{$key} cmp $b->{$key}} @$list;
3612                 } else {
3613                         @$list = sort {$a->{$key} <=> $b->{$key}} @$list;
3614                 }
3615                 print "<th>$header</th>\n";
3616         } else {
3617                 print "<th>" .
3618                       $cgi->a({-href => href(-replay=>1, order=>$name),
3619                                -class => "header"}, $header) .
3620                       "</th>\n";
3621         }
3622 }
3623
3624 sub print_sort_th_str {
3625         print_sort_th(1, @_);
3626 }
3627
3628 sub print_sort_th_num {
3629         print_sort_th(0, @_);
3630 }
3631
3632 sub git_project_list_body {
3633         my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
3634
3635         my ($check_forks) = gitweb_check_feature('forks');
3636         my @projects = fill_project_list_info($projlist, $check_forks);
3637
3638         $order ||= $default_projects_order;
3639         $from = 0 unless defined $from;
3640         $to = $#projects if (!defined $to || $#projects < $to);
3641
3642         print "<table class=\"project_list\">\n";
3643         unless ($no_header) {
3644                 print "<tr>\n";
3645                 if ($check_forks) {
3646                         print "<th></th>\n";
3647                 }
3648                 print_sort_th_str('project', $order, 'path',
3649                                   'Project', \@projects);
3650                 print_sort_th_str('descr', $order, 'descr_long',
3651                                   'Description', \@projects);
3652                 print_sort_th_str('owner', $order, 'owner',
3653                                   'Owner', \@projects);
3654                 print_sort_th_num('age', $order, 'age',
3655                                   'Last Change', \@projects);
3656                 print "<th></th>\n" . # for links
3657                       "</tr>\n";
3658         }
3659         my $alternate = 1;
3660         for (my $i = $from; $i <= $to; $i++) {
3661                 my $pr = $projects[$i];
3662                 if ($alternate) {
3663                         print "<tr class=\"dark\">\n";
3664                 } else {
3665                         print "<tr class=\"light\">\n";
3666                 }
3667                 $alternate ^= 1;
3668                 if ($check_forks) {
3669                         print "<td>";
3670                         if ($pr->{'forks'}) {
3671                                 print "<!-- $pr->{'forks'} -->\n";
3672                                 print $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "+");
3673                         }
3674                         print "</td>\n";
3675                 }
3676                 print "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
3677                                         -class => "list"}, esc_html($pr->{'path'})) . "</td>\n" .
3678                       "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
3679                                         -class => "list", -title => $pr->{'descr_long'}},
3680                                         esc_html($pr->{'descr'})) . "</td>\n" .
3681                       "<td><i>" . chop_and_escape_str($pr->{'owner'}, 15) . "</i></td>\n";
3682                 print "<td class=\"". age_class($pr->{'age'}) . "\">" .
3683                       (defined $pr->{'age_string'} ? $pr->{'age_string'} : "No commits") . "</td>\n" .
3684                       "<td class=\"link\">" .
3685                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary")}, "summary")   . " | " .
3686                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"shortlog")}, "shortlog") . " | " .
3687                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"log")}, "log") . " | " .
3688                       $cgi->a({-href => href(project=>$pr->{'path'}, action=>"tree")}, "tree") .
3689                       ($pr->{'forks'} ? " | " . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "forks") : '') .
3690                       "</td>\n" .
3691                       "</tr>\n";
3692         }
3693         if (defined $extra) {
3694                 print "<tr>\n";
3695                 if ($check_forks) {
3696                         print "<td></td>\n";
3697                 }
3698                 print "<td colspan=\"5\">$extra</td>\n" .
3699                       "</tr>\n";
3700         }
3701         print "</table>\n";
3702 }
3703
3704 sub git_shortlog_body {
3705         # uses global variable $project
3706         my ($commitlist, $from, $to, $refs, $extra) = @_;
3707
3708         $from = 0 unless defined $from;
3709         $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
3710
3711         print "<table class=\"shortlog\">\n";
3712         my $alternate = 1;
3713         for (my $i = $from; $i <= $to; $i++) {
3714                 my %co = %{$commitlist->[$i]};
3715                 my $commit = $co{'id'};
3716                 my $ref = format_ref_marker($refs, $commit);
3717                 if ($alternate) {
3718                         print "<tr class=\"dark\">\n";
3719                 } else {
3720                         print "<tr class=\"light\">\n";
3721                 }
3722                 $alternate ^= 1;
3723                 my $author = chop_and_escape_str($co{'author_name'}, 10);
3724                 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
3725                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
3726                       "<td><i>" . $author . "</i></td>\n" .
3727                       "<td>";
3728                 print format_subject_html($co{'title'}, $co{'title_short'},
3729                                           href(action=>"commit", hash=>$commit), $ref);
3730                 print "</td>\n" .
3731                       "<td class=\"link\">" .
3732                       $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") . " | " .
3733                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") . " | " .
3734                       $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree");
3735                 my $snapshot_links = format_snapshot_links($commit);
3736                 if (defined $snapshot_links) {
3737                         print " | " . $snapshot_links;
3738                 }
3739                 print "</td>\n" .
3740                       "</tr>\n";
3741         }
3742         if (defined $extra) {
3743                 print "<tr>\n" .
3744                       "<td colspan=\"4\">$extra</td>\n" .
3745                       "</tr>\n";
3746         }
3747         print "</table>\n";
3748 }
3749
3750 sub git_history_body {
3751         # Warning: assumes constant type (blob or tree) during history
3752         my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
3753
3754         $from = 0 unless defined $from;
3755         $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
3756
3757         print "<table class=\"history\">\n";
3758         my $alternate = 1;
3759         for (my $i = $from; $i <= $to; $i++) {
3760                 my %co = %{$commitlist->[$i]};
3761                 if (!%co) {
3762                         next;
3763                 }
3764                 my $commit = $co{'id'};
3765
3766                 my $ref = format_ref_marker($refs, $commit);
3767
3768                 if ($alternate) {
3769                         print "<tr class=\"dark\">\n";
3770                 } else {
3771                         print "<tr class=\"light\">\n";
3772                 }
3773                 $alternate ^= 1;
3774         # shortlog uses      chop_str($co{'author_name'}, 10)
3775                 my $author = chop_and_escape_str($co{'author_name'}, 15, 3);
3776                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
3777                       "<td><i>" . $author . "</i></td>\n" .
3778                       "<td>";
3779                 # originally git_history used chop_str($co{'title'}, 50)
3780                 print format_subject_html($co{'title'}, $co{'title_short'},
3781                                           href(action=>"commit", hash=>$commit), $ref);
3782                 print "</td>\n" .
3783                       "<td class=\"link\">" .
3784                       $cgi->a({-href => href(action=>$ftype, hash_base=>$commit, file_name=>$file_name)}, $ftype) . " | " .
3785                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff");
3786
3787                 if ($ftype eq 'blob') {
3788                         my $blob_current = git_get_hash_by_path($hash_base, $file_name);
3789                         my $blob_parent  = git_get_hash_by_path($commit, $file_name);
3790                         if (defined $blob_current && defined $blob_parent &&
3791                                         $blob_current ne $blob_parent) {
3792                                 print " | " .
3793                                         $cgi->a({-href => href(action=>"blobdiff",
3794                                                                hash=>$blob_current, hash_parent=>$blob_parent,
3795                                                                hash_base=>$hash_base, hash_parent_base=>$commit,
3796                                                                file_name=>$file_name)},
3797                                                 "diff to current");
3798                         }
3799                 }
3800                 print "</td>\n" .
3801                       "</tr>\n";
3802         }
3803         if (defined $extra) {
3804                 print "<tr>\n" .
3805                       "<td colspan=\"4\">$extra</td>\n" .
3806                       "</tr>\n";
3807         }
3808         print "</table>\n";
3809 }
3810
3811 sub git_tags_body {
3812         # uses global variable $project
3813         my ($taglist, $from, $to, $extra) = @_;
3814         $from = 0 unless defined $from;
3815         $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
3816
3817         print "<table class=\"tags\">\n";
3818         my $alternate = 1;
3819         for (my $i = $from; $i <= $to; $i++) {
3820                 my $entry = $taglist->[$i];
3821                 my %tag = %$entry;
3822                 my $comment = $tag{'subject'};
3823                 my $comment_short;
3824                 if (defined $comment) {
3825                         $comment_short = chop_str($comment, 30, 5);
3826                 }
3827                 if ($alternate) {
3828                         print "<tr class=\"dark\">\n";
3829                 } else {
3830                         print "<tr class=\"light\">\n";
3831                 }
3832                 $alternate ^= 1;
3833                 if (defined $tag{'age'}) {
3834                         print "<td><i>$tag{'age'}</i></td>\n";
3835                 } else {
3836                         print "<td></td>\n";
3837                 }
3838                 print "<td>" .
3839                       $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'}),
3840                                -class => "list name"}, esc_html($tag{'name'})) .
3841                       "</td>\n" .
3842                       "<td>";
3843                 if (defined $comment) {
3844                         print format_subject_html($comment, $comment_short,
3845                                                   href(action=>"tag", hash=>$tag{'id'}));
3846                 }
3847                 print "</td>\n" .
3848                       "<td class=\"selflink\">";
3849                 if ($tag{'type'} eq "tag") {
3850                         print $cgi->a({-href => href(action=>"tag", hash=>$tag{'id'})}, "tag");
3851                 } else {
3852                         print "&nbsp;";
3853                 }
3854                 print "</td>\n" .
3855                       "<td class=\"link\">" . " | " .
3856                       $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'})}, $tag{'reftype'});
3857                 if ($tag{'reftype'} eq "commit") {
3858                         print " | " . $cgi->a({-href => href(action=>"shortlog", hash=>$tag{'fullname'})}, "shortlog") .
3859                               " | " . $cgi->a({-href => href(action=>"log", hash=>$tag{'fullname'})}, "log");
3860                 } elsif ($tag{'reftype'} eq "blob") {
3861                         print " | " . $cgi->a({-href => href(action=>"blob_plain", hash=>$tag{'refid'})}, "raw");
3862                 }
3863                 print "</td>\n" .
3864                       "</tr>";
3865         }
3866         if (defined $extra) {
3867                 print "<tr>\n" .
3868                       "<td colspan=\"5\">$extra</td>\n" .
3869                       "</tr>\n";
3870         }
3871         print "</table>\n";
3872 }
3873
3874 sub git_heads_body {
3875         # uses global variable $project
3876         my ($headlist, $head, $from, $to, $extra) = @_;
3877         $from = 0 unless defined $from;
3878         $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
3879
3880         print "<table class=\"heads\">\n";
3881         my $alternate = 1;
3882         for (my $i = $from; $i <= $to; $i++) {
3883                 my $entry = $headlist->[$i];
3884                 my %ref = %$entry;
3885                 my $curr = $ref{'id'} eq $head;
3886                 if ($alternate) {
3887                         print "<tr class=\"dark\">\n";
3888                 } else {
3889                         print "<tr class=\"light\">\n";
3890                 }
3891                 $alternate ^= 1;
3892                 print "<td><i>$ref{'age'}</i></td>\n" .
3893                       ($curr ? "<td class=\"current_head\">" : "<td>") .
3894                       $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'}),
3895                                -class => "list name"},esc_html($ref{'name'})) .
3896                       "</td>\n" .
3897                       "<td class=\"link\">" .
3898                       $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'})}, "shortlog") . " | " .
3899                       $cgi->a({-href => href(action=>"log", hash=>$ref{'fullname'})}, "log") . " | " .
3900                       $cgi->a({-href => href(action=>"tree", hash=>$ref{'fullname'}, hash_base=>$ref{'name'})}, "tree") .
3901                       "</td>\n" .
3902                       "</tr>";
3903         }
3904         if (defined $extra) {
3905                 print "<tr>\n" .
3906                       "<td colspan=\"3\">$extra</td>\n" .
3907                       "</tr>\n";
3908         }
3909         print "</table>\n";
3910 }
3911
3912 sub git_search_grep_body {
3913         my ($commitlist, $from, $to, $extra) = @_;
3914         $from = 0 unless defined $from;
3915         $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
3916
3917         print "<table class=\"commit_search\">\n";
3918         my $alternate = 1;
3919         for (my $i = $from; $i <= $to; $i++) {
3920                 my %co = %{$commitlist->[$i]};
3921                 if (!%co) {
3922                         next;
3923                 }
3924                 my $commit = $co{'id'};
3925                 if ($alternate) {
3926                         print "<tr class=\"dark\">\n";
3927                 } else {
3928                         print "<tr class=\"light\">\n";
3929                 }
3930                 $alternate ^= 1;
3931                 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
3932                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
3933                       "<td><i>" . $author . "</i></td>\n" .
3934                       "<td>" .
3935                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
3936                                -class => "list subject"},
3937                               chop_and_escape_str($co{'title'}, 50) . "<br/>");
3938                 my $comment = $co{'comment'};
3939                 foreach my $line (@$comment) {
3940                         if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
3941                                 my ($lead, $match, $trail) = ($1, $2, $3);
3942                                 $match = chop_str($match, 70, 5, 'center');
3943                                 my $contextlen = int((80 - length($match))/2);
3944                                 $contextlen = 30 if ($contextlen > 30);
3945                                 $lead  = chop_str($lead,  $contextlen, 10, 'left');
3946                                 $trail = chop_str($trail, $contextlen, 10, 'right');
3947
3948                                 $lead  = esc_html($lead);
3949                                 $match = esc_html($match);
3950                                 $trail = esc_html($trail);
3951
3952                                 print "$lead<span class=\"match\">$match</span>$trail<br />";
3953                         }
3954                 }
3955                 print "</td>\n" .
3956                       "<td class=\"link\">" .
3957                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
3958                       " | " .
3959                       $cgi->a({-href => href(action=>"commitdiff", hash=>$co{'id'})}, "commitdiff") .
3960                       " | " .
3961                       $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
3962                 print "</td>\n" .
3963                       "</tr>\n";
3964         }
3965         if (defined $extra) {
3966                 print "<tr>\n" .
3967                       "<td colspan=\"3\">$extra</td>\n" .
3968                       "</tr>\n";
3969         }
3970         print "</table>\n";
3971 }
3972
3973 ## ======================================================================
3974 ## ======================================================================
3975 ## actions
3976
3977 sub git_project_list {
3978         my $order = $cgi->param('o');
3979         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
3980                 die_error(undef, "Unknown order parameter");
3981         }
3982
3983         my @list = git_get_projects_list();
3984         if (!@list) {
3985                 die_error(undef, "No projects found");
3986         }
3987
3988         git_header_html();
3989         if (-f $home_text) {
3990                 print "<div class=\"index_include\">\n";
3991                 open (my $fd, $home_text);
3992                 print <$fd>;
3993                 close $fd;
3994                 print "</div>\n";
3995         }
3996         git_project_list_body(\@list, $order);
3997         git_footer_html();
3998 }
3999
4000 sub git_forks {
4001         my $order = $cgi->param('o');
4002         if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4003                 die_error(undef, "Unknown order parameter");
4004         }
4005
4006         my @list = git_get_projects_list($project);
4007         if (!@list) {
4008                 die_error(undef, "No forks found");
4009         }
4010
4011         git_header_html();
4012         git_print_page_nav('','');
4013         git_print_header_div('summary', "$project forks");
4014         git_project_list_body(\@list, $order);
4015         git_footer_html();
4016 }
4017
4018 sub git_project_index {
4019         my @projects = git_get_projects_list($project);
4020
4021         print $cgi->header(
4022                 -type => 'text/plain',
4023                 -charset => 'utf-8',
4024                 -content_disposition => 'inline; filename="index.aux"');
4025
4026         foreach my $pr (@projects) {
4027                 if (!exists $pr->{'owner'}) {
4028                         $pr->{'owner'} = git_get_project_owner("$pr->{'path'}");
4029                 }
4030
4031                 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
4032                 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
4033                 $path  =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
4034                 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
4035                 $path  =~ s/ /\+/g;
4036                 $owner =~ s/ /\+/g;
4037
4038                 print "$path $owner\n";
4039         }
4040 }
4041
4042 sub git_summary {
4043         my $descr = git_get_project_description($project) || "none";
4044         my %co = parse_commit("HEAD");
4045         my %cd = %co ? parse_date($co{'committer_epoch'}, $co{'committer_tz'}) : ();
4046         my $head = $co{'id'};
4047
4048         my $owner = git_get_project_owner($project);
4049
4050         my $refs = git_get_references();
4051         # These get_*_list functions return one more to allow us to see if
4052         # there are more ...
4053         my @taglist  = git_get_tags_list(16);
4054         my @headlist = git_get_heads_list(16);
4055         my @forklist;
4056         my ($check_forks) = gitweb_check_feature('forks');
4057
4058         if ($check_forks) {
4059                 @forklist = git_get_projects_list($project);
4060         }
4061
4062         git_header_html();
4063         git_print_page_nav('summary','', $head);
4064
4065         print "<div class=\"title\">&nbsp;</div>\n";
4066         print "<table class=\"projects_list\">\n" .
4067               "<tr><td>description</td><td>" . esc_html($descr) . "</td></tr>\n" .
4068               "<tr><td>owner</td><td>" . esc_html($owner) . "</td></tr>\n";
4069         if (defined $cd{'rfc2822'}) {
4070                 print "<tr><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
4071         }
4072
4073         # use per project git URL list in $projectroot/$project/cloneurl
4074         # or make project git URL from git base URL and project name
4075         my $url_tag = "URL";
4076         my @url_list = git_get_project_url_list($project);
4077         @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
4078         foreach my $git_url (@url_list) {
4079                 next unless $git_url;
4080                 print "<tr><td>$url_tag</td><td>$git_url</td></tr>\n";
4081                 $url_tag = "";
4082         }
4083         print "</table>\n";
4084
4085         if (-s "$projectroot/$project/README.html") {
4086                 if (open my $fd, "$projectroot/$project/README.html") {
4087                         print "<div class=\"title\">readme</div>\n" .
4088                               "<div class=\"readme\">\n";
4089                         print $_ while (<$fd>);
4090                         print "\n</div>\n"; # class="readme"
4091                         close $fd;
4092                 }
4093         }
4094
4095         # we need to request one more than 16 (0..15) to check if
4096         # those 16 are all
4097         my @commitlist = $head ? parse_commits($head, 17) : ();
4098         if (@commitlist) {
4099                 git_print_header_div('shortlog');
4100                 git_shortlog_body(\@commitlist, 0, 15, $refs,
4101                                   $#commitlist <=  15 ? undef :
4102                                   $cgi->a({-href => href(action=>"shortlog")}, "..."));
4103         }
4104
4105         if (@taglist) {
4106                 git_print_header_div('tags');
4107                 git_tags_body(\@taglist, 0, 15,
4108                               $#taglist <=  15 ? undef :
4109                               $cgi->a({-href => href(action=>"tags")}, "..."));
4110         }
4111
4112         if (@headlist) {
4113                 git_print_header_div('heads');
4114                 git_heads_body(\@headlist, $head, 0, 15,
4115                                $#headlist <= 15 ? undef :
4116                                $cgi->a({-href => href(action=>"heads")}, "..."));
4117         }
4118
4119         if (@forklist) {
4120                 git_print_header_div('forks');
4121                 git_project_list_body(\@forklist, undef, 0, 15,
4122                                       $#forklist <= 15 ? undef :
4123                                       $cgi->a({-href => href(action=>"forks")}, "..."),
4124                                       'noheader');
4125         }
4126
4127         git_footer_html();
4128 }
4129
4130 sub git_tag {
4131         my $head = git_get_head_hash($project);
4132         git_header_html();
4133         git_print_page_nav('','', $head,undef,$head);
4134         my %tag = parse_tag($hash);
4135
4136         if (! %tag) {
4137                 die_error(undef, "Unknown tag object");
4138         }
4139
4140         git_print_header_div('commit', esc_html($tag{'name'}), $hash);
4141         print "<div class=\"title_text\">\n" .
4142               "<table class=\"object_header\">\n" .
4143               "<tr>\n" .
4144               "<td>object</td>\n" .
4145               "<td>" . $cgi->a({-class => "list", -href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
4146                                $tag{'object'}) . "</td>\n" .
4147               "<td class=\"link\">" . $cgi->a({-href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
4148                                               $tag{'type'}) . "</td>\n" .
4149               "</tr>\n";
4150         if (defined($tag{'author'})) {
4151                 my %ad = parse_date($tag{'epoch'}, $tag{'tz'});
4152                 print "<tr><td>author</td><td>" . esc_html($tag{'author'}) . "</td></tr>\n";
4153                 print "<tr><td></td><td>" . $ad{'rfc2822'} .
4154                         sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
4155                         "</td></tr>\n";
4156         }
4157         print "</table>\n\n" .
4158               "</div>\n";
4159         print "<div class=\"page_body\">";
4160         my $comment = $tag{'comment'};
4161         foreach my $line (@$comment) {
4162                 chomp $line;
4163                 print esc_html($line, -nbsp=>1) . "<br/>\n";
4164         }
4165         print "</div>\n";
4166         git_footer_html();
4167 }
4168
4169 sub git_blame {
4170         my $fd;
4171         my $ftype;
4172
4173         my ($have_blame) = gitweb_check_feature('blame');
4174         if (!$have_blame) {
4175                 die_error('403 Permission denied', "Permission denied");
4176         }
4177         die_error('404 Not Found', "File name not defined") if (!$file_name);
4178         $hash_base ||= git_get_head_hash($project);
4179         die_error(undef, "Couldn't find base commit") unless ($hash_base);
4180         my %co = parse_commit($hash_base)
4181                 or die_error(undef, "Reading commit failed");
4182         if (!defined $hash) {
4183                 $hash = git_get_hash_by_path($hash_base, $file_name, "blob")
4184                         or die_error(undef, "Error looking up file");
4185         }
4186         $ftype = git_get_type($hash);
4187         if ($ftype !~ "blob") {
4188                 die_error('400 Bad Request', "Object is not a blob");
4189         }
4190         open ($fd, "-|", git_cmd(), "blame", '-p', '--',
4191               $file_name, $hash_base)
4192                 or die_error(undef, "Open git-blame failed");
4193         git_header_html();
4194         my $formats_nav =
4195                 $cgi->a({-href => href(action=>"blob", -replay=>1)},
4196                         "blob") .
4197                 " | " .
4198                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4199                         "history") .
4200                 " | " .
4201                 $cgi->a({-href => href(action=>"blame", file_name=>$file_name)},
4202                         "HEAD");
4203         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4204         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
4205         git_print_page_path($file_name, $ftype, $hash_base);
4206         my @rev_color = (qw(light2 dark2));
4207         my $num_colors = scalar(@rev_color);
4208         my $current_color = 0;
4209         my $last_rev;
4210         print <<HTML;
4211 <div class="page_body">
4212 <table class="blame">
4213 <tr><th>Commit</th><th>Line</th><th>Data</th></tr>
4214 HTML
4215         my %metainfo = ();
4216         while (1) {
4217                 $_ = <$fd>;
4218                 last unless defined $_;
4219                 my ($full_rev, $orig_lineno, $lineno, $group_size) =
4220                     /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/;
4221                 if (!exists $metainfo{$full_rev}) {
4222                         $metainfo{$full_rev} = {};
4223                 }
4224                 my $meta = $metainfo{$full_rev};
4225                 while (<$fd>) {
4226                         last if (s/^\t//);
4227                         if (/^(\S+) (.*)$/) {
4228                                 $meta->{$1} = $2;
4229                         }
4230                 }
4231                 my $data = $_;
4232                 chomp $data;
4233                 my $rev = substr($full_rev, 0, 8);
4234                 my $author = $meta->{'author'};
4235                 my %date = parse_date($meta->{'author-time'},
4236                                       $meta->{'author-tz'});
4237                 my $date = $date{'iso-tz'};
4238                 if ($group_size) {
4239                         $current_color = ++$current_color % $num_colors;
4240                 }
4241                 print "<tr class=\"$rev_color[$current_color]\">\n";
4242                 if ($group_size) {
4243                         print "<td class=\"sha1\"";
4244                         print " title=\"". esc_html($author) . ", $date\"";
4245                         print " rowspan=\"$group_size\"" if ($group_size > 1);
4246                         print ">";
4247                         print $cgi->a({-href => href(action=>"commit",
4248                                                      hash=>$full_rev,
4249                                                      file_name=>$file_name)},
4250                                       esc_html($rev));
4251                         print "</td>\n";
4252                 }
4253                 open (my $dd, "-|", git_cmd(), "rev-parse", "$full_rev^")
4254                         or die_error(undef, "Open git-rev-parse failed");
4255                 my $parent_commit = <$dd>;
4256                 close $dd;
4257                 chomp($parent_commit);
4258                 my $blamed = href(action => 'blame',
4259                                   file_name => $meta->{'filename'},
4260                                   hash_base => $parent_commit);
4261                 print "<td class=\"linenr\">";
4262                 print $cgi->a({ -href => "$blamed#l$orig_lineno",
4263                                 -id => "l$lineno",
4264                                 -class => "linenr" },
4265                               esc_html($lineno));
4266                 print "</td>";
4267                 print "<td class=\"pre\">" . esc_html($data) . "</td>\n";
4268                 print "</tr>\n";
4269         }
4270         print "</table>\n";
4271         print "</div>";
4272         close $fd
4273                 or print "Reading blob failed\n";
4274         git_footer_html();
4275 }
4276
4277 sub git_tags {
4278         my $head = git_get_head_hash($project);
4279         git_header_html();
4280         git_print_page_nav('','', $head,undef,$head);
4281         git_print_header_div('summary', $project);
4282
4283         my @tagslist = git_get_tags_list();
4284         if (@tagslist) {
4285                 git_tags_body(\@tagslist);
4286         }
4287         git_footer_html();
4288 }
4289
4290 sub git_heads {
4291         my $head = git_get_head_hash($project);
4292         git_header_html();
4293         git_print_page_nav('','', $head,undef,$head);
4294         git_print_header_div('summary', $project);
4295
4296         my @headslist = git_get_heads_list();
4297         if (@headslist) {
4298                 git_heads_body(\@headslist, $head);
4299         }
4300         git_footer_html();
4301 }
4302
4303 sub git_blob_plain {
4304         my $type = shift;
4305         my $expires;
4306
4307         if (!defined $hash) {
4308                 if (defined $file_name) {
4309                         my $base = $hash_base || git_get_head_hash($project);
4310                         $hash = git_get_hash_by_path($base, $file_name, "blob")
4311                                 or die_error(undef, "Error lookup file");
4312                 } else {
4313                         die_error(undef, "No file name defined");
4314                 }
4315         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4316                 # blobs defined by non-textual hash id's can be cached
4317                 $expires = "+1d";
4318         }
4319
4320         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4321                 or die_error(undef, "Open git-cat-file blob '$hash' failed");
4322
4323         # content-type (can include charset)
4324         $type = blob_contenttype($fd, $file_name, $type);
4325
4326         # "save as" filename, even when no $file_name is given
4327         my $save_as = "$hash";
4328         if (defined $file_name) {
4329                 $save_as = $file_name;
4330         } elsif ($type =~ m/^text\//) {
4331                 $save_as .= '.txt';
4332         }
4333
4334         print $cgi->header(
4335                 -type => $type,
4336                 -expires => $expires,
4337                 -content_disposition => 'inline; filename="' . $save_as . '"');
4338         undef $/;
4339         binmode STDOUT, ':raw';
4340         print <$fd>;
4341         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
4342         $/ = "\n";
4343         close $fd;
4344 }
4345
4346 sub git_blob {
4347         my $expires;
4348
4349         if (!defined $hash) {
4350                 if (defined $file_name) {
4351                         my $base = $hash_base || git_get_head_hash($project);
4352                         $hash = git_get_hash_by_path($base, $file_name, "blob")
4353                                 or die_error(undef, "Error lookup file");
4354                 } else {
4355                         die_error(undef, "No file name defined");
4356                 }
4357         } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4358                 # blobs defined by non-textual hash id's can be cached
4359                 $expires = "+1d";
4360         }
4361
4362         my ($have_blame) = gitweb_check_feature('blame');
4363         open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4364                 or die_error(undef, "Couldn't cat $file_name, $hash");
4365         my $mimetype = blob_mimetype($fd, $file_name);
4366         if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B $fd) {
4367                 close $fd;
4368                 return git_blob_plain($mimetype);
4369         }
4370         # we can have blame only for text/* mimetype
4371         $have_blame &&= ($mimetype =~ m!^text/!);
4372
4373         git_header_html(undef, $expires);
4374         my $formats_nav = '';
4375         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
4376                 if (defined $file_name) {
4377                         if ($have_blame) {
4378                                 $formats_nav .=
4379                                         $cgi->a({-href => href(action=>"blame", -replay=>1)},
4380                                                 "blame") .
4381                                         " | ";
4382                         }
4383                         $formats_nav .=
4384                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4385                                         "history") .
4386                                 " | " .
4387                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
4388                                         "raw") .
4389                                 " | " .
4390                                 $cgi->a({-href => href(action=>"blob",
4391                                                        hash_base=>"HEAD", file_name=>$file_name)},
4392                                         "HEAD");
4393                 } else {
4394                         $formats_nav .=
4395                                 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
4396                                         "raw");
4397                 }
4398                 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4399                 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
4400         } else {
4401                 print "<div class=\"page_nav\">\n" .
4402                       "<br/><br/></div>\n" .
4403                       "<div class=\"title\">$hash</div>\n";
4404         }
4405         git_print_page_path($file_name, "blob", $hash_base);
4406         print "<div class=\"page_body\">\n";
4407         if ($mimetype =~ m!^image/!) {
4408                 print qq!<img type="$mimetype"!;
4409                 if ($file_name) {
4410                         print qq! alt="$file_name" title="$file_name"!;
4411                 }
4412                 print qq! src="! .
4413                       href(action=>"blob_plain", hash=>$hash,
4414                            hash_base=>$hash_base, file_name=>$file_name) .
4415                       qq!" />\n!;
4416         } else {
4417                 my $nr;
4418                 while (my $line = <$fd>) {
4419                         chomp $line;
4420                         $nr++;
4421                         $line = untabify($line);
4422                         printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
4423                                $nr, $nr, $nr, esc_html($line, -nbsp=>1);
4424                 }
4425         }
4426         close $fd
4427                 or print "Reading blob failed.\n";
4428         print "</div>";
4429         git_footer_html();
4430 }
4431
4432 sub git_tree {
4433         if (!defined $hash_base) {
4434                 $hash_base = "HEAD";
4435         }
4436         if (!defined $hash) {
4437                 if (defined $file_name) {
4438                         $hash = git_get_hash_by_path($hash_base, $file_name, "tree");
4439                 } else {
4440                         $hash = $hash_base;
4441                 }
4442         }
4443         $/ = "\0";
4444         open my $fd, "-|", git_cmd(), "ls-tree", '-z', $hash
4445                 or die_error(undef, "Open git-ls-tree failed");
4446         my @entries = map { chomp; $_ } <$fd>;
4447         close $fd or die_error(undef, "Reading tree failed");
4448         $/ = "\n";
4449
4450         my $refs = git_get_references();
4451         my $ref = format_ref_marker($refs, $hash_base);
4452         git_header_html();
4453         my $basedir = '';
4454         my ($have_blame) = gitweb_check_feature('blame');
4455         if (defined $hash_base && (my %co = parse_commit($hash_base))) {
4456                 my @views_nav = ();
4457                 if (defined $file_name) {
4458                         push @views_nav,
4459                                 $cgi->a({-href => href(action=>"history", -replay=>1)},
4460                                         "history"),
4461                                 $cgi->a({-href => href(action=>"tree",
4462                                                        hash_base=>"HEAD", file_name=>$file_name)},
4463                                         "HEAD"),
4464                 }
4465                 my $snapshot_links = format_snapshot_links($hash);
4466                 if (defined $snapshot_links) {
4467                         # FIXME: Should be available when we have no hash base as well.
4468                         push @views_nav, $snapshot_links;
4469                 }
4470                 git_print_page_nav('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
4471                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash_base);
4472         } else {
4473                 undef $hash_base;
4474                 print "<div class=\"page_nav\">\n";
4475                 print "<br/><br/></div>\n";
4476                 print "<div class=\"title\">$hash</div>\n";
4477         }
4478         if (defined $file_name) {
4479                 $basedir = $file_name;
4480                 if ($basedir ne '' && substr($basedir, -1) ne '/') {
4481                         $basedir .= '/';
4482                 }
4483         }
4484         git_print_page_path($file_name, 'tree', $hash_base);
4485         print "<div class=\"page_body\">\n";
4486         print "<table class=\"tree\">\n";
4487         my $alternate = 1;
4488         # '..' (top directory) link if possible
4489         if (defined $hash_base &&
4490             defined $file_name && $file_name =~ m![^/]+$!) {
4491                 if ($alternate) {
4492                         print "<tr class=\"dark\">\n";
4493                 } else {
4494                         print "<tr class=\"light\">\n";
4495                 }
4496                 $alternate ^= 1;
4497
4498                 my $up = $file_name;
4499                 $up =~ s!/?[^/]+$!!;
4500                 undef $up unless $up;
4501                 # based on git_print_tree_entry
4502                 print '<td class="mode">' . mode_str('040000') . "</td>\n";
4503                 print '<td class="list">';
4504                 print $cgi->a({-href => href(action=>"tree", hash_base=>$hash_base,
4505                                              file_name=>$up)},
4506                               "..");
4507                 print "</td>\n";
4508                 print "<td class=\"link\"></td>\n";
4509
4510                 print "</tr>\n";
4511         }
4512         foreach my $line (@entries) {
4513                 my %t = parse_ls_tree_line($line, -z => 1);
4514
4515                 if ($alternate) {
4516                         print "<tr class=\"dark\">\n";
4517                 } else {
4518                         print "<tr class=\"light\">\n";
4519                 }
4520                 $alternate ^= 1;
4521
4522                 git_print_tree_entry(\%t, $basedir, $hash_base, $have_blame);
4523
4524                 print "</tr>\n";
4525         }
4526         print "</table>\n" .
4527               "</div>";
4528         git_footer_html();
4529 }
4530
4531 sub git_snapshot {
4532         my @supported_fmts = gitweb_check_feature('snapshot');
4533         @supported_fmts = filter_snapshot_fmts(@supported_fmts);
4534
4535         my $format = $cgi->param('sf');
4536         if (!@supported_fmts) {
4537                 die_error('403 Permission denied', "Permission denied");
4538         }
4539         # default to first supported snapshot format
4540         $format ||= $supported_fmts[0];
4541         if ($format !~ m/^[a-z0-9]+$/) {
4542                 die_error(undef, "Invalid snapshot format parameter");
4543         } elsif (!exists($known_snapshot_formats{$format})) {
4544                 die_error(undef, "Unknown snapshot format");
4545         } elsif (!grep($_ eq $format, @supported_fmts)) {
4546                 die_error(undef, "Unsupported snapshot format");
4547         }
4548
4549         if (!defined $hash) {
4550                 $hash = git_get_head_hash($project);
4551         }
4552
4553         my $git_command = git_cmd_str();
4554         my $name = $project;
4555         $name =~ s,([^/])/*\.git$,$1,;
4556         $name = basename($name);
4557         my $filename = to_utf8($name);
4558         $name =~ s/\047/\047\\\047\047/g;
4559         my $cmd;
4560         $filename .= "-$hash$known_snapshot_formats{$format}{'suffix'}";
4561         $cmd = "$git_command archive " .
4562                 "--format=$known_snapshot_formats{$format}{'format'} " .
4563                 "--prefix=\'$name\'/ $hash";
4564         if (exists $known_snapshot_formats{$format}{'compressor'}) {
4565                 $cmd .= ' | ' . join ' ', @{$known_snapshot_formats{$format}{'compressor'}};
4566         }
4567
4568         print $cgi->header(
4569                 -type => $known_snapshot_formats{$format}{'type'},
4570                 -content_disposition => 'inline; filename="' . "$filename" . '"',
4571                 -status => '200 OK');
4572
4573         open my $fd, "-|", $cmd
4574                 or die_error(undef, "Execute git-archive failed");
4575         binmode STDOUT, ':raw';
4576         print <$fd>;
4577         binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
4578         close $fd;
4579 }
4580
4581 sub git_log {
4582         my $head = git_get_head_hash($project);
4583         if (!defined $hash) {
4584                 $hash = $head;
4585         }
4586         if (!defined $page) {
4587                 $page = 0;
4588         }
4589         my $refs = git_get_references();
4590
4591         my @commitlist = parse_commits($hash, 101, (100 * $page));
4592
4593         my $paging_nav = format_paging_nav('log', $hash, $head, $page, $#commitlist >= 100);
4594
4595         git_header_html();
4596         git_print_page_nav('log','', $hash,undef,undef, $paging_nav);
4597
4598         if (!@commitlist) {
4599                 my %co = parse_commit($hash);
4600
4601                 git_print_header_div('summary', $project);
4602                 print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
4603         }
4604         my $to = ($#commitlist >= 99) ? (99) : ($#commitlist);
4605         for (my $i = 0; $i <= $to; $i++) {
4606                 my %co = %{$commitlist[$i]};
4607                 next if !%co;
4608                 my $commit = $co{'id'};
4609                 my $ref = format_ref_marker($refs, $commit);
4610                 my %ad = parse_date($co{'author_epoch'});
4611                 git_print_header_div('commit',
4612                                "<span class=\"age\">$co{'age_string'}</span>" .
4613                                esc_html($co{'title'}) . $ref,
4614                                $commit);
4615                 print "<div class=\"title_text\">\n" .
4616                       "<div class=\"log_link\">\n" .
4617                       $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") .
4618                       " | " .
4619                       $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") .
4620                       " | " .
4621                       $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree") .
4622                       "<br/>\n" .
4623                       "</div>\n" .
4624                       "<i>" . esc_html($co{'author_name'}) .  " [$ad{'rfc2822'}]</i><br/>\n" .
4625                       "</div>\n";
4626
4627                 print "<div class=\"log_body\">\n";
4628                 git_print_log($co{'comment'}, -final_empty_line=> 1);
4629                 print "</div>\n";
4630         }
4631         if ($#commitlist >= 100) {
4632                 print "<div class=\"page_nav\">\n";
4633                 print $cgi->a({-href => href(-replay=>1, page=>$page+1),
4634                                -accesskey => "n", -title => "Alt-n"}, "next");
4635                 print "</div>\n";
4636         }
4637         git_footer_html();
4638 }
4639
4640 sub git_commit {
4641         $hash ||= $hash_base || "HEAD";
4642         my %co = parse_commit($hash);
4643         if (!%co) {
4644                 die_error(undef, "Unknown commit object");
4645         }
4646         my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
4647         my %cd = parse_date($co{'committer_epoch'}, $co{'committer_tz'});
4648
4649         my $parent  = $co{'parent'};
4650         my $parents = $co{'parents'}; # listref
4651
4652         # we need to prepare $formats_nav before any parameter munging
4653         my $formats_nav;
4654         if (!defined $parent) {
4655                 # --root commitdiff
4656                 $formats_nav .= '(initial)';
4657         } elsif (@$parents == 1) {
4658                 # single parent commit
4659                 $formats_nav .=
4660                         '(parent: ' .
4661                         $cgi->a({-href => href(action=>"commit",
4662                                                hash=>$parent)},
4663                                 esc_html(substr($parent, 0, 7))) .
4664                         ')';
4665         } else {
4666                 # merge commit
4667                 $formats_nav .=
4668                         '(merge: ' .
4669                         join(' ', map {
4670                                 $cgi->a({-href => href(action=>"commit",
4671                                                        hash=>$_)},
4672                                         esc_html(substr($_, 0, 7)));
4673                         } @$parents ) .
4674                         ')';
4675         }
4676
4677         if (!defined $parent) {
4678                 $parent = "--root";
4679         }
4680         my @difftree;
4681         open my $fd, "-|", git_cmd(), "diff-tree", '-r', "--no-commit-id",
4682                 @diff_opts,
4683                 (@$parents <= 1 ? $parent : '-c'),
4684                 $hash, "--"
4685                 or die_error(undef, "Open git-diff-tree failed");
4686         @difftree = map { chomp; $_ } <$fd>;
4687         close $fd or die_error(undef, "Reading git-diff-tree failed");
4688
4689         # non-textual hash id's can be cached
4690         my $expires;
4691         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4692                 $expires = "+1d";
4693         }
4694         my $refs = git_get_references();
4695         my $ref = format_ref_marker($refs, $co{'id'});
4696
4697         git_header_html(undef, $expires);
4698         git_print_page_nav('commit', '',
4699                            $hash, $co{'tree'}, $hash,
4700                            $formats_nav);
4701
4702         if (defined $co{'parent'}) {
4703                 git_print_header_div('commitdiff', esc_html($co{'title'}) . $ref, $hash);
4704         } else {
4705                 git_print_header_div('tree', esc_html($co{'title'}) . $ref, $co{'tree'}, $hash);
4706         }
4707         print "<div class=\"title_text\">\n" .
4708               "<table class=\"object_header\">\n";
4709         print "<tr><td>author</td><td>" . esc_html($co{'author'}) . "</td></tr>\n".
4710               "<tr>" .
4711               "<td></td><td> $ad{'rfc2822'}";
4712         if ($ad{'hour_local'} < 6) {
4713                 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
4714                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
4715         } else {
4716                 printf(" (%02d:%02d %s)",
4717                        $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
4718         }
4719         print "</td>" .
4720               "</tr>\n";
4721         print "<tr><td>committer</td><td>" . esc_html($co{'committer'}) . "</td></tr>\n";
4722         print "<tr><td></td><td> $cd{'rfc2822'}" .
4723               sprintf(" (%02d:%02d %s)", $cd{'hour_local'}, $cd{'minute_local'}, $cd{'tz_local'}) .
4724               "</td></tr>\n";
4725         print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
4726         print "<tr>" .
4727               "<td>tree</td>" .
4728               "<td class=\"sha1\">" .
4729               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash),
4730                        class => "list"}, $co{'tree'}) .
4731               "</td>" .
4732               "<td class=\"link\">" .
4733               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash)},
4734                       "tree");
4735         my $snapshot_links = format_snapshot_links($hash);
4736         if (defined $snapshot_links) {
4737                 print " | " . $snapshot_links;
4738         }
4739         print "</td>" .
4740               "</tr>\n";
4741
4742         foreach my $par (@$parents) {
4743                 print "<tr>" .
4744                       "<td>parent</td>" .
4745                       "<td class=\"sha1\">" .
4746                       $cgi->a({-href => href(action=>"commit", hash=>$par),
4747                                class => "list"}, $par) .
4748                       "</td>" .
4749                       "<td class=\"link\">" .
4750                       $cgi->a({-href => href(action=>"commit", hash=>$par)}, "commit") .
4751                       " | " .
4752                       $cgi->a({-href => href(action=>"commitdiff", hash=>$hash, hash_parent=>$par)}, "diff") .
4753                       "</td>" .
4754                       "</tr>\n";
4755         }
4756         print "</table>".
4757               "</div>\n";
4758
4759         print "<div class=\"page_body\">\n";
4760         git_print_log($co{'comment'});
4761         print "</div>\n";
4762
4763         git_difftree_body(\@difftree, $hash, @$parents);
4764
4765         git_footer_html();
4766 }
4767
4768 sub git_object {
4769         # object is defined by:
4770         # - hash or hash_base alone
4771         # - hash_base and file_name
4772         my $type;
4773
4774         # - hash or hash_base alone
4775         if ($hash || ($hash_base && !defined $file_name)) {
4776                 my $object_id = $hash || $hash_base;
4777
4778                 my $git_command = git_cmd_str();
4779                 open my $fd, "-|", "$git_command cat-file -t $object_id 2>/dev/null"
4780                         or die_error('404 Not Found', "Object does not exist");
4781                 $type = <$fd>;
4782                 chomp $type;
4783                 close $fd
4784                         or die_error('404 Not Found', "Object does not exist");
4785
4786         # - hash_base and file_name
4787         } elsif ($hash_base && defined $file_name) {
4788                 $file_name =~ s,/+$,,;
4789
4790                 system(git_cmd(), "cat-file", '-e', $hash_base) == 0
4791                         or die_error('404 Not Found', "Base object does not exist");
4792
4793                 # here errors should not hapen
4794                 open my $fd, "-|", git_cmd(), "ls-tree", $hash_base, "--", $file_name
4795                         or die_error(undef, "Open git-ls-tree failed");
4796                 my $line = <$fd>;
4797                 close $fd;
4798
4799                 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa  panic.c'
4800                 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
4801                         die_error('404 Not Found', "File or directory for given base does not exist");
4802                 }
4803                 $type = $2;
4804                 $hash = $3;
4805         } else {
4806                 die_error('404 Not Found', "Not enough information to find object");
4807         }
4808
4809         print $cgi->redirect(-uri => href(action=>$type, -full=>1,
4810                                           hash=>$hash, hash_base=>$hash_base,
4811                                           file_name=>$file_name),
4812                              -status => '302 Found');
4813 }
4814
4815 sub git_blobdiff {
4816         my $format = shift || 'html';
4817
4818         my $fd;
4819         my @difftree;
4820         my %diffinfo;
4821         my $expires;
4822
4823         # preparing $fd and %diffinfo for git_patchset_body
4824         # new style URI
4825         if (defined $hash_base && defined $hash_parent_base) {
4826                 if (defined $file_name) {
4827                         # read raw output
4828                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
4829                                 $hash_parent_base, $hash_base,
4830                                 "--", (defined $file_parent ? $file_parent : ()), $file_name
4831                                 or die_error(undef, "Open git-diff-tree failed");
4832                         @difftree = map { chomp; $_ } <$fd>;
4833                         close $fd
4834                                 or die_error(undef, "Reading git-diff-tree failed");
4835                         @difftree
4836                                 or die_error('404 Not Found', "Blob diff not found");
4837
4838                 } elsif (defined $hash &&
4839                          $hash =~ /[0-9a-fA-F]{40}/) {
4840                         # try to find filename from $hash
4841
4842                         # read filtered raw output
4843                         open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
4844                                 $hash_parent_base, $hash_base, "--"
4845                                 or die_error(undef, "Open git-diff-tree failed");
4846                         @difftree =
4847                                 # ':100644 100644 03b21826... 3b93d5e7... M     ls-files.c'
4848                                 # $hash == to_id
4849                                 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
4850                                 map { chomp; $_ } <$fd>;
4851                         close $fd
4852                                 or die_error(undef, "Reading git-diff-tree failed");
4853                         @difftree
4854                                 or die_error('404 Not Found', "Blob diff not found");
4855
4856                 } else {
4857                         die_error('404 Not Found', "Missing one of the blob diff parameters");
4858                 }
4859
4860                 if (@difftree > 1) {
4861                         die_error('404 Not Found', "Ambiguous blob diff specification");
4862                 }
4863
4864                 %diffinfo = parse_difftree_raw_line($difftree[0]);
4865                 $file_parent ||= $diffinfo{'from_file'} || $file_name;
4866                 $file_name   ||= $diffinfo{'to_file'};
4867
4868                 $hash_parent ||= $diffinfo{'from_id'};
4869                 $hash        ||= $diffinfo{'to_id'};
4870
4871                 # non-textual hash id's can be cached
4872                 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
4873                     $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
4874                         $expires = '+1d';
4875                 }
4876
4877                 # open patch output
4878                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
4879                         '-p', ($format eq 'html' ? "--full-index" : ()),
4880                         $hash_parent_base, $hash_base,
4881                         "--", (defined $file_parent ? $file_parent : ()), $file_name
4882                         or die_error(undef, "Open git-diff-tree failed");
4883         }
4884
4885         # old/legacy style URI
4886         if (!%diffinfo && # if new style URI failed
4887             defined $hash && defined $hash_parent) {
4888                 # fake git-diff-tree raw output
4889                 $diffinfo{'from_mode'} = $diffinfo{'to_mode'} = "blob";
4890                 $diffinfo{'from_id'} = $hash_parent;
4891                 $diffinfo{'to_id'}   = $hash;
4892                 if (defined $file_name) {
4893                         if (defined $file_parent) {
4894                                 $diffinfo{'status'} = '2';
4895                                 $diffinfo{'from_file'} = $file_parent;
4896                                 $diffinfo{'to_file'}   = $file_name;
4897                         } else { # assume not renamed
4898                                 $diffinfo{'status'} = '1';
4899                                 $diffinfo{'from_file'} = $file_name;
4900                                 $diffinfo{'to_file'}   = $file_name;
4901                         }
4902                 } else { # no filename given
4903                         $diffinfo{'status'} = '2';
4904                         $diffinfo{'from_file'} = $hash_parent;
4905                         $diffinfo{'to_file'}   = $hash;
4906                 }
4907
4908                 # non-textual hash id's can be cached
4909                 if ($hash =~ m/^[0-9a-fA-F]{40}$/ &&
4910                     $hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
4911                         $expires = '+1d';
4912                 }
4913
4914                 # open patch output
4915                 open $fd, "-|", git_cmd(), "diff", @diff_opts,
4916                         '-p', ($format eq 'html' ? "--full-index" : ()),
4917                         $hash_parent, $hash, "--"
4918                         or die_error(undef, "Open git-diff failed");
4919         } else  {
4920                 die_error('404 Not Found', "Missing one of the blob diff parameters")
4921                         unless %diffinfo;
4922         }
4923
4924         # header
4925         if ($format eq 'html') {
4926                 my $formats_nav =
4927                         $cgi->a({-href => href(action=>"blobdiff_plain", -replay=>1)},
4928                                 "raw");
4929                 git_header_html(undef, $expires);
4930                 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
4931                         git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4932                         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
4933                 } else {
4934                         print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
4935                         print "<div class=\"title\">$hash vs $hash_parent</div>\n";
4936                 }
4937                 if (defined $file_name) {
4938                         git_print_page_path($file_name, "blob", $hash_base);
4939                 } else {
4940                         print "<div class=\"page_path\"></div>\n";
4941                 }
4942
4943         } elsif ($format eq 'plain') {
4944                 print $cgi->header(
4945                         -type => 'text/plain',
4946                         -charset => 'utf-8',
4947                         -expires => $expires,
4948                         -content_disposition => 'inline; filename="' . "$file_name" . '.patch"');
4949
4950                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
4951
4952         } else {
4953                 die_error(undef, "Unknown blobdiff format");
4954         }
4955
4956         # patch
4957         if ($format eq 'html') {
4958                 print "<div class=\"page_body\">\n";
4959
4960                 git_patchset_body($fd, [ \%diffinfo ], $hash_base, $hash_parent_base);
4961                 close $fd;
4962
4963                 print "</div>\n"; # class="page_body"
4964                 git_footer_html();
4965
4966         } else {
4967                 while (my $line = <$fd>) {
4968                         $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
4969                         $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
4970
4971                         print $line;
4972
4973                         last if $line =~ m!^\+\+\+!;
4974                 }
4975                 local $/ = undef;
4976                 print <$fd>;
4977                 close $fd;
4978         }
4979 }
4980
4981 sub git_blobdiff_plain {
4982         git_blobdiff('plain');
4983 }
4984
4985 sub git_commitdiff {
4986         my $format = shift || 'html';
4987         $hash ||= $hash_base || "HEAD";
4988         my %co = parse_commit($hash);
4989         if (!%co) {
4990                 die_error(undef, "Unknown commit object");
4991         }
4992
4993         # choose format for commitdiff for merge
4994         if (! defined $hash_parent && @{$co{'parents'}} > 1) {
4995                 $hash_parent = '--cc';
4996         }
4997         # we need to prepare $formats_nav before almost any parameter munging
4998         my $formats_nav;
4999         if ($format eq 'html') {
5000                 $formats_nav =
5001                         $cgi->a({-href => href(action=>"commitdiff_plain", -replay=>1)},
5002                                 "raw");
5003
5004                 if (defined $hash_parent &&
5005                     $hash_parent ne '-c' && $hash_parent ne '--cc') {
5006                         # commitdiff with two commits given
5007                         my $hash_parent_short = $hash_parent;
5008                         if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5009                                 $hash_parent_short = substr($hash_parent, 0, 7);
5010                         }
5011                         $formats_nav .=
5012                                 ' (from';
5013                         for (my $i = 0; $i < @{$co{'parents'}}; $i++) {
5014                                 if ($co{'parents'}[$i] eq $hash_parent) {
5015                                         $formats_nav .= ' parent ' . ($i+1);
5016                                         last;
5017                                 }
5018                         }
5019                         $formats_nav .= ': ' .
5020                                 $cgi->a({-href => href(action=>"commitdiff",
5021                                                        hash=>$hash_parent)},
5022                                         esc_html($hash_parent_short)) .
5023                                 ')';
5024                 } elsif (!$co{'parent'}) {
5025                         # --root commitdiff
5026                         $formats_nav .= ' (initial)';
5027                 } elsif (scalar @{$co{'parents'}} == 1) {
5028                         # single parent commit
5029                         $formats_nav .=
5030                                 ' (parent: ' .
5031                                 $cgi->a({-href => href(action=>"commitdiff",
5032                                                        hash=>$co{'parent'})},
5033                                         esc_html(substr($co{'parent'}, 0, 7))) .
5034                                 ')';
5035                 } else {
5036                         # merge commit
5037                         if ($hash_parent eq '--cc') {
5038                                 $formats_nav .= ' | ' .
5039                                         $cgi->a({-href => href(action=>"commitdiff",
5040                                                                hash=>$hash, hash_parent=>'-c')},
5041                                                 'combined');
5042                         } else { # $hash_parent eq '-c'
5043                                 $formats_nav .= ' | ' .
5044                                         $cgi->a({-href => href(action=>"commitdiff",
5045                                                                hash=>$hash, hash_parent=>'--cc')},
5046                                                 'compact');
5047                         }
5048                         $formats_nav .=
5049                                 ' (merge: ' .
5050                                 join(' ', map {
5051                                         $cgi->a({-href => href(action=>"commitdiff",
5052                                                                hash=>$_)},
5053                                                 esc_html(substr($_, 0, 7)));
5054                                 } @{$co{'parents'}} ) .
5055                                 ')';
5056                 }
5057         }
5058
5059         my $hash_parent_param = $hash_parent;
5060         if (!defined $hash_parent_param) {
5061                 # --cc for multiple parents, --root for parentless
5062                 $hash_parent_param =
5063                         @{$co{'parents'}} > 1 ? '--cc' : $co{'parent'} || '--root';
5064         }
5065
5066         # read commitdiff
5067         my $fd;
5068         my @difftree;
5069         if ($format eq 'html') {
5070                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5071                         "--no-commit-id", "--patch-with-raw", "--full-index",
5072                         $hash_parent_param, $hash, "--"
5073                         or die_error(undef, "Open git-diff-tree failed");
5074
5075                 while (my $line = <$fd>) {
5076                         chomp $line;
5077                         # empty line ends raw part of diff-tree output
5078                         last unless $line;
5079                         push @difftree, scalar parse_difftree_raw_line($line);
5080                 }
5081
5082         } elsif ($format eq 'plain') {
5083                 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5084                         '-p', $hash_parent_param, $hash, "--"
5085                         or die_error(undef, "Open git-diff-tree failed");
5086
5087         } else {
5088                 die_error(undef, "Unknown commitdiff format");
5089         }
5090
5091         # non-textual hash id's can be cached
5092         my $expires;
5093         if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5094                 $expires = "+1d";
5095         }
5096
5097         # write commit message
5098         if ($format eq 'html') {
5099                 my $refs = git_get_references();
5100                 my $ref = format_ref_marker($refs, $co{'id'});
5101
5102                 git_header_html(undef, $expires);
5103                 git_print_page_nav('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
5104                 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash);
5105                 git_print_authorship(\%co);
5106                 print "<div class=\"page_body\">\n";
5107                 if (@{$co{'comment'}} > 1) {
5108                         print "<div class=\"log\">\n";
5109                         git_print_log($co{'comment'}, -final_empty_line=> 1, -remove_title => 1);
5110                         print "</div>\n"; # class="log"
5111                 }
5112
5113         } elsif ($format eq 'plain') {
5114                 my $refs = git_get_references("tags");
5115                 my $tagname = git_get_rev_name_tags($hash);
5116                 my $filename = basename($project) . "-$hash.patch";
5117
5118                 print $cgi->header(
5119                         -type => 'text/plain',
5120                         -charset => 'utf-8',
5121                         -expires => $expires,
5122                         -content_disposition => 'inline; filename="' . "$filename" . '"');
5123                 my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
5124                 print "From: " . to_utf8($co{'author'}) . "\n";
5125                 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
5126                 print "Subject: " . to_utf8($co{'title'}) . "\n";
5127
5128                 print "X-Git-Tag: $tagname\n" if $tagname;
5129                 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5130
5131                 foreach my $line (@{$co{'comment'}}) {
5132                         print to_utf8($line) . "\n";
5133                 }
5134                 print "---\n\n";
5135         }
5136
5137         # write patch
5138         if ($format eq 'html') {
5139                 my $use_parents = !defined $hash_parent ||
5140                         $hash_parent eq '-c' || $hash_parent eq '--cc';
5141                 git_difftree_body(\@difftree, $hash,
5142                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
5143                 print "<br/>\n";
5144
5145                 git_patchset_body($fd, \@difftree, $hash,
5146                                   $use_parents ? @{$co{'parents'}} : $hash_parent);
5147                 close $fd;
5148                 print "</div>\n"; # class="page_body"
5149                 git_footer_html();
5150
5151         } elsif ($format eq 'plain') {
5152                 local $/ = undef;
5153                 print <$fd>;
5154                 close $fd
5155                         or print "Reading git-diff-tree failed\n";
5156         }
5157 }
5158
5159 sub git_commitdiff_plain {
5160         git_commitdiff('plain');
5161 }
5162
5163 sub git_history {
5164         if (!defined $hash_base) {
5165                 $hash_base = git_get_head_hash($project);
5166         }
5167         if (!defined $page) {
5168                 $page = 0;
5169         }
5170         my $ftype;
5171         my %co = parse_commit($hash_base);
5172         if (!%co) {
5173                 die_error(undef, "Unknown commit object");
5174         }
5175
5176         my $refs = git_get_references();
5177         my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
5178
5179         my @commitlist = parse_commits($hash_base, 101, (100 * $page),
5180                                        $file_name, "--full-history");
5181         if (!@commitlist) {
5182                 die_error('404 Not Found', "No such file or directory on given branch");
5183         }
5184
5185         if (!defined $hash && defined $file_name) {
5186                 # some commits could have deleted file in question,
5187                 # and not have it in tree, but one of them has to have it
5188                 for (my $i = 0; $i <= @commitlist; $i++) {
5189                         $hash = git_get_hash_by_path($commitlist[$i]{'id'}, $file_name);
5190                         last if defined $hash;
5191                 }
5192         }
5193         if (defined $hash) {
5194                 $ftype = git_get_type($hash);
5195         }
5196         if (!defined $ftype) {
5197                 die_error(undef, "Unknown type of object");
5198         }
5199
5200         my $paging_nav = '';
5201         if ($page > 0) {
5202                 $paging_nav .=
5203                         $cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base,
5204                                                file_name=>$file_name)},
5205                                 "first");
5206                 $paging_nav .= " &sdot; " .
5207                         $cgi->a({-href => href(-replay=>1, page=>$page-1),
5208                                  -accesskey => "p", -title => "Alt-p"}, "prev");
5209         } else {
5210                 $paging_nav .= "first";
5211                 $paging_nav .= " &sdot; prev";
5212         }
5213         my $next_link = '';
5214         if ($#commitlist >= 100) {
5215                 $next_link =
5216                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
5217                                  -accesskey => "n", -title => "Alt-n"}, "next");
5218                 $paging_nav .= " &sdot; $next_link";
5219         } else {
5220                 $paging_nav .= " &sdot; next";
5221         }
5222
5223         git_header_html();
5224         git_print_page_nav('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
5225         git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
5226         git_print_page_path($file_name, $ftype, $hash_base);
5227
5228         git_history_body(\@commitlist, 0, 99,
5229                          $refs, $hash_base, $ftype, $next_link);
5230
5231         git_footer_html();
5232 }
5233
5234 sub git_search {
5235         my ($have_search) = gitweb_check_feature('search');
5236         if (!$have_search) {
5237                 die_error('403 Permission denied', "Permission denied");
5238         }
5239         if (!defined $searchtext) {
5240                 die_error(undef, "Text field empty");
5241         }
5242         if (!defined $hash) {
5243                 $hash = git_get_head_hash($project);
5244         }
5245         my %co = parse_commit($hash);
5246         if (!%co) {
5247                 die_error(undef, "Unknown commit object");
5248         }
5249         if (!defined $page) {
5250                 $page = 0;
5251         }
5252
5253         $searchtype ||= 'commit';
5254         if ($searchtype eq 'pickaxe') {
5255                 # pickaxe may take all resources of your box and run for several minutes
5256                 # with every query - so decide by yourself how public you make this feature
5257                 my ($have_pickaxe) = gitweb_check_feature('pickaxe');
5258                 if (!$have_pickaxe) {
5259                         die_error('403 Permission denied', "Permission denied");
5260                 }
5261         }
5262         if ($searchtype eq 'grep') {
5263                 my ($have_grep) = gitweb_check_feature('grep');
5264                 if (!$have_grep) {
5265                         die_error('403 Permission denied', "Permission denied");
5266                 }
5267         }
5268
5269         git_header_html();
5270
5271         if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
5272                 my $greptype;
5273                 if ($searchtype eq 'commit') {
5274                         $greptype = "--grep=";
5275                 } elsif ($searchtype eq 'author') {
5276                         $greptype = "--author=";
5277                 } elsif ($searchtype eq 'committer') {
5278                         $greptype = "--committer=";
5279                 }
5280                 $greptype .= $searchtext;
5281                 my @commitlist = parse_commits($hash, 101, (100 * $page), undef,
5282                                                $greptype, '--regexp-ignore-case',
5283                                                $search_use_regexp ? '--extended-regexp' : '--fixed-strings');
5284
5285                 my $paging_nav = '';
5286                 if ($page > 0) {
5287                         $paging_nav .=
5288                                 $cgi->a({-href => href(action=>"search", hash=>$hash,
5289                                                        searchtext=>$searchtext,
5290                                                        searchtype=>$searchtype)},
5291                                         "first");
5292                         $paging_nav .= " &sdot; " .
5293                                 $cgi->a({-href => href(-replay=>1, page=>$page-1),
5294                                          -accesskey => "p", -title => "Alt-p"}, "prev");
5295                 } else {
5296                         $paging_nav .= "first";
5297                         $paging_nav .= " &sdot; prev";
5298                 }
5299                 my $next_link = '';
5300                 if ($#commitlist >= 100) {
5301                         $next_link =
5302                                 $cgi->a({-href => href(-replay=>1, page=>$page+1),
5303                                          -accesskey => "n", -title => "Alt-n"}, "next");
5304                         $paging_nav .= " &sdot; $next_link";
5305                 } else {
5306                         $paging_nav .= " &sdot; next";
5307                 }
5308
5309                 if ($#commitlist >= 100) {
5310                 }
5311
5312                 git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
5313                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5314                 git_search_grep_body(\@commitlist, 0, 99, $next_link);
5315         }
5316
5317         if ($searchtype eq 'pickaxe') {
5318                 git_print_page_nav('','', $hash,$co{'tree'},$hash);
5319                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5320
5321                 print "<table class=\"pickaxe search\">\n";
5322                 my $alternate = 1;
5323                 $/ = "\n";
5324                 open my $fd, '-|', git_cmd(), '--no-pager', 'log', @diff_opts,
5325                         '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5326                         ($search_use_regexp ? '--pickaxe-regex' : ());
5327                 undef %co;
5328                 my @files;
5329                 while (my $line = <$fd>) {
5330                         chomp $line;
5331                         next unless $line;
5332
5333                         my %set = parse_difftree_raw_line($line);
5334                         if (defined $set{'commit'}) {
5335                                 # finish previous commit
5336                                 if (%co) {
5337                                         print "</td>\n" .
5338                                               "<td class=\"link\">" .
5339                                               $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5340                                               " | " .
5341                                               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5342                                         print "</td>\n" .
5343                                               "</tr>\n";
5344                                 }
5345
5346                                 if ($alternate) {
5347                                         print "<tr class=\"dark\">\n";
5348                                 } else {
5349                                         print "<tr class=\"light\">\n";
5350                                 }
5351                                 $alternate ^= 1;
5352                                 %co = parse_commit($set{'commit'});
5353                                 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
5354                                 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5355                                       "<td><i>$author</i></td>\n" .
5356                                       "<td>" .
5357                                       $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
5358                                               -class => "list subject"},
5359                                               chop_and_escape_str($co{'title'}, 50) . "<br/>");
5360                         } elsif (defined $set{'to_id'}) {
5361                                 next if ($set{'to_id'} =~ m/^0{40}$/);
5362
5363                                 print $cgi->a({-href => href(action=>"blob", hash_base=>$co{'id'},
5364                                                              hash=>$set{'to_id'}, file_name=>$set{'to_file'}),
5365                                               -class => "list"},
5366                                               "<span class=\"match\">" . esc_path($set{'file'}) . "</span>") .
5367                                       "<br/>\n";
5368                         }
5369                 }
5370                 close $fd;
5371
5372                 # finish last commit (warning: repetition!)
5373                 if (%co) {
5374                         print "</td>\n" .
5375                               "<td class=\"link\">" .
5376                               $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5377                               " | " .
5378                               $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5379                         print "</td>\n" .
5380                               "</tr>\n";
5381                 }
5382
5383                 print "</table>\n";
5384         }
5385
5386         if ($searchtype eq 'grep') {
5387                 git_print_page_nav('','', $hash,$co{'tree'},$hash);
5388                 git_print_header_div('commit', esc_html($co{'title'}), $hash);
5389
5390                 print "<table class=\"grep_search\">\n";
5391                 my $alternate = 1;
5392                 my $matches = 0;
5393                 $/ = "\n";
5394                 open my $fd, "-|", git_cmd(), 'grep', '-n',
5395                         $search_use_regexp ? ('-E', '-i') : '-F',
5396                         $searchtext, $co{'tree'};
5397                 my $lastfile = '';
5398                 while (my $line = <$fd>) {
5399                         chomp $line;
5400                         my ($file, $lno, $ltext, $binary);
5401                         last if ($matches++ > 1000);
5402                         if ($line =~ /^Binary file (.+) matches$/) {
5403                                 $file = $1;
5404                                 $binary = 1;
5405                         } else {
5406                                 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5407                         }
5408                         if ($file ne $lastfile) {
5409                                 $lastfile and print "</td></tr>\n";
5410                                 if ($alternate++) {
5411                                         print "<tr class=\"dark\">\n";
5412                                 } else {
5413                                         print "<tr class=\"light\">\n";
5414                                 }
5415                                 print "<td class=\"list\">".
5416                                         $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5417                                                                file_name=>"$file"),
5418                                                 -class => "list"}, esc_path($file));
5419                                 print "</td><td>\n";
5420                                 $lastfile = $file;
5421                         }
5422                         if ($binary) {
5423                                 print "<div class=\"binary\">Binary file</div>\n";
5424                         } else {
5425                                 $ltext = untabify($ltext);
5426                                 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5427                                         $ltext = esc_html($1, -nbsp=>1);
5428                                         $ltext .= '<span class="match">';
5429                                         $ltext .= esc_html($2, -nbsp=>1);
5430                                         $ltext .= '</span>';
5431                                         $ltext .= esc_html($3, -nbsp=>1);
5432                                 } else {
5433                                         $ltext = esc_html($ltext, -nbsp=>1);
5434                                 }
5435                                 print "<div class=\"pre\">" .
5436                                         $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
5437                                                                file_name=>"$file").'#l'.$lno,
5438                                                 -class => "linenr"}, sprintf('%4i', $lno))
5439                                         . ' ' .  $ltext . "</div>\n";
5440                         }
5441                 }
5442                 if ($lastfile) {
5443                         print "</td></tr>\n";
5444                         if ($matches > 1000) {
5445                                 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5446                         }
5447                 } else {
5448                         print "<div class=\"diff nodifferences\">No matches found</div>\n";
5449                 }
5450                 close $fd;
5451
5452                 print "</table>\n";
5453         }
5454         git_footer_html();
5455 }
5456
5457 sub git_search_help {
5458         git_header_html();
5459         git_print_page_nav('','', $hash,$hash,$hash);
5460         print <<EOT;
5461 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
5462 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
5463 the pattern entered is recognized as the POSIX extended
5464 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
5465 insensitive).</p>
5466 <dl>
5467 <dt><b>commit</b></dt>
5468 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
5469 EOT
5470         my ($have_grep) = gitweb_check_feature('grep');
5471         if ($have_grep) {
5472                 print <<EOT;
5473 <dt><b>grep</b></dt>
5474 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
5475     a different one) are searched for the given pattern. On large trees, this search can take
5476 a while and put some strain on the server, so please use it with some consideration. Note that
5477 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
5478 case-sensitive.</dd>
5479 EOT
5480         }
5481         print <<EOT;
5482 <dt><b>author</b></dt>
5483 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
5484 <dt><b>committer</b></dt>
5485 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
5486 EOT
5487         my ($have_pickaxe) = gitweb_check_feature('pickaxe');
5488         if ($have_pickaxe) {
5489                 print <<EOT;
5490 <dt><b>pickaxe</b></dt>
5491 <dd>All commits that caused the string to appear or disappear from any file (changes that
5492 added, removed or "modified" the string) will be listed. This search can take a while and
5493 takes a lot of strain on the server, so please use it wisely. Note that since you may be
5494 interested even in changes just changing the case as well, this search is case sensitive.</dd>
5495 EOT
5496         }
5497         print "</dl>\n";
5498         git_footer_html();
5499 }
5500
5501 sub git_shortlog {
5502         my $head = git_get_head_hash($project);
5503         if (!defined $hash) {
5504                 $hash = $head;
5505         }
5506         if (!defined $page) {
5507                 $page = 0;
5508         }
5509         my $refs = git_get_references();
5510
5511         my @commitlist = parse_commits($hash, 101, (100 * $page));
5512
5513         my $paging_nav = format_paging_nav('shortlog', $hash, $head, $page, $#commitlist >= 100);
5514         my $next_link = '';
5515         if ($#commitlist >= 100) {
5516                 $next_link =
5517                         $cgi->a({-href => href(-replay=>1, page=>$page+1),
5518                                  -accesskey => "n", -title => "Alt-n"}, "next");
5519         }
5520
5521         git_header_html();
5522         git_print_page_nav('shortlog','', $hash,$hash,$hash, $paging_nav);
5523         git_print_header_div('summary', $project);
5524
5525         git_shortlog_body(\@commitlist, 0, 99, $refs, $next_link);
5526
5527         git_footer_html();
5528 }
5529
5530 ## ......................................................................
5531 ## feeds (RSS, Atom; OPML)
5532
5533 sub git_feed {
5534         my $format = shift || 'atom';
5535         my ($have_blame) = gitweb_check_feature('blame');
5536
5537         # Atom: http://www.atomenabled.org/developers/syndication/
5538         # RSS:  http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
5539         if ($format ne 'rss' && $format ne 'atom') {
5540                 die_error(undef, "Unknown web feed format");
5541         }
5542
5543         # log/feed of current (HEAD) branch, log of given branch, history of file/directory
5544         my $head = $hash || 'HEAD';
5545         my @commitlist = parse_commits($head, 150, 0, $file_name);
5546
5547         my %latest_commit;
5548         my %latest_date;
5549         my $content_type = "application/$format+xml";
5550         if (defined $cgi->http('HTTP_ACCEPT') &&
5551                  $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
5552                 # browser (feed reader) prefers text/xml
5553                 $content_type = 'text/xml';
5554         }
5555         if (defined($commitlist[0])) {
5556                 %latest_commit = %{$commitlist[0]};
5557                 %latest_date   = parse_date($latest_commit{'author_epoch'});
5558                 print $cgi->header(
5559                         -type => $content_type,
5560                         -charset => 'utf-8',
5561                         -last_modified => $latest_date{'rfc2822'});
5562         } else {
5563                 print $cgi->header(
5564                         -type => $content_type,
5565                         -charset => 'utf-8');
5566         }
5567
5568         # Optimization: skip generating the body if client asks only
5569         # for Last-Modified date.
5570         return if ($cgi->request_method() eq 'HEAD');
5571
5572         # header variables
5573         my $title = "$site_name - $project/$action";
5574         my $feed_type = 'log';
5575         if (defined $hash) {
5576                 $title .= " - '$hash'";
5577                 $feed_type = 'branch log';
5578                 if (defined $file_name) {
5579                         $title .= " :: $file_name";
5580                         $feed_type = 'history';
5581                 }
5582         } elsif (defined $file_name) {
5583                 $title .= " - $file_name";
5584                 $feed_type = 'history';
5585         }
5586         $title .= " $feed_type";
5587         my $descr = git_get_project_description($project);
5588         if (defined $descr) {
5589                 $descr = esc_html($descr);
5590         } else {
5591                 $descr = "$project " .
5592                          ($format eq 'rss' ? 'RSS' : 'Atom') .
5593                          " feed";
5594         }
5595         my $owner = git_get_project_owner($project);
5596         $owner = esc_html($owner);
5597
5598         #header
5599         my $alt_url;
5600         if (defined $file_name) {
5601                 $alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
5602         } elsif (defined $hash) {
5603                 $alt_url = href(-full=>1, action=>"log", hash=>$hash);
5604         } else {
5605                 $alt_url = href(-full=>1, action=>"summary");
5606         }
5607         print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
5608         if ($format eq 'rss') {
5609                 print <<XML;
5610 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
5611 <channel>
5612 XML
5613                 print "<title>$title</title>\n" .
5614                       "<link>$alt_url</link>\n" .
5615                       "<description>$descr</description>\n" .
5616                       "<language>en</language>\n";
5617         } elsif ($format eq 'atom') {
5618                 print <<XML;
5619 <feed xmlns="http://www.w3.org/2005/Atom">
5620 XML
5621                 print "<title>$title</title>\n" .
5622                       "<subtitle>$descr</subtitle>\n" .
5623                       '<link rel="alternate" type="text/html" href="' .
5624                       $alt_url . '" />' . "\n" .
5625                       '<link rel="self" type="' . $content_type . '" href="' .
5626                       $cgi->self_url() . '" />' . "\n" .
5627                       "<id>" . href(-full=>1) . "</id>\n" .
5628                       # use project owner for feed author
5629                       "<author><name>$owner</name></author>\n";
5630                 if (defined $favicon) {
5631                         print "<icon>" . esc_url($favicon) . "</icon>\n";
5632                 }
5633                 if (defined $logo_url) {
5634                         # not twice as wide as tall: 72 x 27 pixels
5635                         print "<logo>" . esc_url($logo) . "</logo>\n";
5636                 }
5637                 if (! %latest_date) {
5638                         # dummy date to keep the feed valid until commits trickle in:
5639                         print "<updated>1970-01-01T00:00:00Z</updated>\n";
5640                 } else {
5641                         print "<updated>$latest_date{'iso-8601'}</updated>\n";
5642                 }
5643         }
5644
5645         # contents
5646         for (my $i = 0; $i <= $#commitlist; $i++) {
5647                 my %co = %{$commitlist[$i]};
5648                 my $commit = $co{'id'};
5649                 # we read 150, we always show 30 and the ones more recent than 48 hours
5650                 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
5651                         last;
5652                 }
5653                 my %cd = parse_date($co{'author_epoch'});
5654
5655                 # get list of changed files
5656                 open my $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
5657                         $co{'parent'} || "--root",
5658                         $co{'id'}, "--", (defined $file_name ? $file_name : ())
5659                         or next;
5660                 my @difftree = map { chomp; $_ } <$fd>;
5661                 close $fd
5662                         or next;
5663
5664                 # print element (entry, item)
5665                 my $co_url = href(-full=>1, action=>"commitdiff", hash=>$commit);
5666                 if ($format eq 'rss') {
5667                         print "<item>\n" .
5668                               "<title>" . esc_html($co{'title'}) . "</title>\n" .
5669                               "<author>" . esc_html($co{'author'}) . "</author>\n" .
5670                               "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
5671                               "<guid isPermaLink=\"true\">$co_url</guid>\n" .
5672                               "<link>$co_url</link>\n" .
5673                               "<description>" . esc_html($co{'title'}) . "</description>\n" .
5674                               "<content:encoded>" .
5675                               "<![CDATA[\n";
5676                 } elsif ($format eq 'atom') {
5677                         print "<entry>\n" .
5678                               "<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
5679                               "<updated>$cd{'iso-8601'}</updated>\n" .
5680                               "<author>\n" .
5681                               "  <name>" . esc_html($co{'author_name'}) . "</name>\n";
5682                         if ($co{'author_email'}) {
5683                                 print "  <email>" . esc_html($co{'author_email'}) . "</email>\n";
5684                         }
5685                         print "</author>\n" .
5686                               # use committer for contributor
5687                               "<contributor>\n" .
5688                               "  <name>" . esc_html($co{'committer_name'}) . "</name>\n";
5689                         if ($co{'committer_email'}) {
5690                                 print "  <email>" . esc_html($co{'committer_email'}) . "</email>\n";
5691                         }
5692                         print "</contributor>\n" .
5693                               "<published>$cd{'iso-8601'}</published>\n" .
5694                               "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
5695                               "<id>$co_url</id>\n" .
5696                               "<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
5697                               "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
5698                 }
5699                 my $comment = $co{'comment'};
5700                 print "<pre>\n";
5701                 foreach my $line (@$comment) {
5702                         $line = esc_html($line);
5703                         print "$line\n";
5704                 }
5705                 print "</pre><ul>\n";
5706                 foreach my $difftree_line (@difftree) {
5707                         my %difftree = parse_difftree_raw_line($difftree_line);
5708                         next if !$difftree{'from_id'};
5709
5710                         my $file = $difftree{'file'} || $difftree{'to_file'};
5711
5712                         print "<li>" .
5713                               "[" .
5714                               $cgi->a({-href => href(-full=>1, action=>"blobdiff",
5715                                                      hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
5716                                                      hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
5717                                                      file_name=>$file, file_parent=>$difftree{'from_file'}),
5718                                       -title => "diff"}, 'D');
5719                         if ($have_blame) {
5720                                 print $cgi->a({-href => href(-full=>1, action=>"blame",
5721                                                              file_name=>$file, hash_base=>$commit),
5722                                               -title => "blame"}, 'B');
5723                         }
5724                         # if this is not a feed of a file history
5725                         if (!defined $file_name || $file_name ne $file) {
5726                                 print $cgi->a({-href => href(-full=>1, action=>"history",
5727                                                              file_name=>$file, hash=>$commit),
5728                                               -title => "history"}, 'H');
5729                         }
5730                         $file = esc_path($file);
5731                         print "] ".
5732                               "$file</li>\n";
5733                 }
5734                 if ($format eq 'rss') {
5735                         print "</ul>]]>\n" .
5736                               "</content:encoded>\n" .
5737                               "</item>\n";
5738                 } elsif ($format eq 'atom') {
5739                         print "</ul>\n</div>\n" .
5740                               "</content>\n" .
5741                               "</entry>\n";
5742                 }
5743         }
5744
5745         # end of feed
5746         if ($format eq 'rss') {
5747                 print "</channel>\n</rss>\n";
5748         }       elsif ($format eq 'atom') {
5749                 print "</feed>\n";
5750         }
5751 }
5752
5753 sub git_rss {
5754         git_feed('rss');
5755 }
5756
5757 sub git_atom {
5758         git_feed('atom');
5759 }
5760
5761 sub git_opml {
5762         my @list = git_get_projects_list();
5763
5764         print $cgi->header(-type => 'text/xml', -charset => 'utf-8');
5765         print <<XML;
5766 <?xml version="1.0" encoding="utf-8"?>
5767 <opml version="1.0">
5768 <head>
5769   <title>$site_name OPML Export</title>
5770 </head>
5771 <body>
5772 <outline text="git RSS feeds">
5773 XML
5774
5775         foreach my $pr (@list) {
5776                 my %proj = %$pr;
5777                 my $head = git_get_head_hash($proj{'path'});
5778                 if (!defined $head) {
5779                         next;
5780                 }
5781                 $git_dir = "$projectroot/$proj{'path'}";
5782                 my %co = parse_commit($head);
5783                 if (!%co) {
5784                         next;
5785                 }
5786
5787                 my $path = esc_html(chop_str($proj{'path'}, 25, 5));
5788                 my $rss  = "$my_url?p=$proj{'path'};a=rss";
5789                 my $html = "$my_url?p=$proj{'path'};a=summary";
5790                 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";
5791         }
5792         print <<XML;
5793 </outline>
5794 </body>
5795 </opml>
5796 XML
5797 }