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