3 # gitweb - simple web interface to track changes in git repositories
5 # (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
6 # (C) 2005, Christian Gierke
8 # This program is licensed under the GPLv2
12 use CGI
qw(:standard :escapeHTML -nosticky);
13 use CGI
::Util
qw(unescape);
14 use CGI
::Carp
qw(fatalsToBrowser);
18 use File
::Basename
qw(basename);
19 binmode STDOUT
, ':utf8';
22 CGI
->compile() if $ENV{'MOD_PERL'};
26 our $version = "++GIT_VERSION++";
27 our $my_url = $cgi->url();
28 our $my_uri = $cgi->url(-absolute
=> 1);
30 # if we're called with PATH_INFO, we have to strip that
31 # from the URL to find our real URL
32 if (my $path_info = $ENV{"PATH_INFO"}) {
33 $my_url =~ s
,\Q
$path_info\E
$,,;
34 $my_uri =~ s
,\Q
$path_info\E
$,,;
37 # core git executable to use
38 # this can just be "git" if your webserver has a sensible PATH
39 our $GIT = "++GIT_BINDIR++/git";
41 # absolute fs-path which will be prepended to the project path
42 #our $projectroot = "/pub/scm";
43 our $projectroot = "++GITWEB_PROJECTROOT++";
45 # fs traversing limit for getting project list
46 # the number is relative to the projectroot
47 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
49 # target of the home link on top of all pages
50 our $home_link = $my_uri || "/";
52 # string of the home link on top of all pages
53 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
55 # name of your site or organization to appear in page titles
56 # replace this with something more descriptive for clearer bookmarks
57 our $site_name = "++GITWEB_SITENAME++"
58 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
60 # filename of html text to include at top of each page
61 our $site_header = "++GITWEB_SITE_HEADER++";
62 # html text to include at home page
63 our $home_text = "++GITWEB_HOMETEXT++";
64 # filename of html text to include at bottom of each page
65 our $site_footer = "++GITWEB_SITE_FOOTER++";
68 our @stylesheets = ("++GITWEB_CSS++");
69 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
70 our $stylesheet = undef;
71 # URI of GIT logo (72x27 size)
72 our $logo = "++GITWEB_LOGO++";
73 # URI of GIT favicon, assumed to be image/png type
74 our $favicon = "++GITWEB_FAVICON++";
76 # URI and label (title) of GIT logo link
77 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
78 #our $logo_label = "git documentation";
79 our $logo_url = "http://git.or.cz/";
80 our $logo_label = "git homepage";
82 # source of projects list
83 our $projects_list = "++GITWEB_LIST++";
85 # the width (in characters) of the projects list "Description" column
86 our $projects_list_description_width = 25;
88 # default order of projects list
89 # valid values are none, project, descr, owner, and age
90 our $default_projects_order = "project";
92 # show repository only if this file exists
93 # (only effective if this variable evaluates to true)
94 our $export_ok = "++GITWEB_EXPORT_OK++";
96 # only allow viewing of repositories also shown on the overview page
97 our $strict_export = "++GITWEB_STRICT_EXPORT++";
99 # list of git base URLs used for URL to where fetch project from,
100 # i.e. full URL is "$git_base_url/$project"
101 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
103 # default blob_plain mimetype and default charset for text/plain blob
104 our $default_blob_plain_mimetype = 'text/plain';
105 our $default_text_plain_charset = undef;
107 # file to use for guessing MIME types before trying /etc/mime.types
108 # (relative to the current git repository)
109 our $mimetypes_file = undef;
111 # assume this charset if line contains non-UTF-8 characters;
112 # it should be valid encoding (see Encoding::Supported(3pm) for list),
113 # for which encoding all byte sequences are valid, for example
114 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
115 # could be even 'utf-8' for the old behavior)
116 our $fallback_encoding = 'latin1';
118 # rename detection options for git-diff and git-diff-tree
119 # - default is '-M', with the cost proportional to
120 # (number of removed files) * (number of new files).
121 # - more costly is '-C' (which implies '-M'), with the cost proportional to
122 # (number of changed files + number of removed files) * (number of new files)
123 # - even more costly is '-C', '--find-copies-harder' with cost
124 # (number of files in the original tree) * (number of new files)
125 # - one might want to include '-B' option, e.g. '-B', '-M'
126 our @diff_opts = ('-M'); # taken from git_commit
128 # information about snapshot formats that gitweb is capable of serving
129 our %known_snapshot_formats = (
131 # 'display' => display name,
132 # 'type' => mime type,
133 # 'suffix' => filename suffix,
134 # 'format' => --format for git-archive,
135 # 'compressor' => [compressor command and arguments]
136 # (array reference, optional)}
139 'display' => 'tar.gz',
140 'type' => 'application/x-gzip',
141 'suffix' => '.tar.gz',
143 'compressor' => ['gzip']},
146 'display' => 'tar.bz2',
147 'type' => 'application/x-bzip2',
148 'suffix' => '.tar.bz2',
150 'compressor' => ['bzip2']},
154 'type' => 'application/x-zip',
159 # Aliases so we understand old gitweb.snapshot values in repository
161 our %known_snapshot_format_aliases = (
165 # backward compatibility: legacy gitweb config support
166 'x-gzip' => undef, 'gz' => undef,
167 'x-bzip2' => undef, 'bz2' => undef,
168 'x-zip' => undef, '' => undef,
171 # You define site-wide feature defaults here; override them with
172 # $GITWEB_CONFIG as necessary.
175 # 'sub' => feature-sub (subroutine),
176 # 'override' => allow-override (boolean),
177 # 'default' => [ default options...] (array reference)}
179 # if feature is overridable (it means that allow-override has true value),
180 # then feature-sub will be called with default options as parameters;
181 # return value of feature-sub indicates if to enable specified feature
183 # if there is no 'sub' key (no feature-sub), then feature cannot be
186 # use gitweb_check_feature(<feature>) to check if <feature> is enabled
188 # Enable the 'blame' blob view, showing the last commit that modified
189 # each line in the file. This can be very CPU-intensive.
191 # To enable system wide have in $GITWEB_CONFIG
192 # $feature{'blame'}{'default'} = [1];
193 # To have project specific config enable override in $GITWEB_CONFIG
194 # $feature{'blame'}{'override'} = 1;
195 # and in project config gitweb.blame = 0|1;
197 'sub' => \
&feature_blame
,
201 # Enable the 'snapshot' link, providing a compressed archive of any
202 # tree. This can potentially generate high traffic if you have large
205 # Value is a list of formats defined in %known_snapshot_formats that
207 # To disable system wide have in $GITWEB_CONFIG
208 # $feature{'snapshot'}{'default'} = [];
209 # To have project specific config enable override in $GITWEB_CONFIG
210 # $feature{'snapshot'}{'override'} = 1;
211 # and in project config, a comma-separated list of formats or "none"
212 # to disable. Example: gitweb.snapshot = tbz2,zip;
214 'sub' => \
&feature_snapshot
,
216 'default' => ['tgz']},
218 # Enable text search, which will list the commits which match author,
219 # committer or commit text to a given string. Enabled by default.
220 # Project specific override is not supported.
225 # Enable grep search, which will list the files in currently selected
226 # tree containing the given string. Enabled by default. This can be
227 # potentially CPU-intensive, of course.
229 # To enable system wide have in $GITWEB_CONFIG
230 # $feature{'grep'}{'default'} = [1];
231 # To have project specific config enable override in $GITWEB_CONFIG
232 # $feature{'grep'}{'override'} = 1;
233 # and in project config gitweb.grep = 0|1;
238 # Enable the pickaxe search, which will list the commits that modified
239 # a given string in a file. This can be practical and quite faster
240 # alternative to 'blame', but still potentially CPU-intensive.
242 # To enable system wide have in $GITWEB_CONFIG
243 # $feature{'pickaxe'}{'default'} = [1];
244 # To have project specific config enable override in $GITWEB_CONFIG
245 # $feature{'pickaxe'}{'override'} = 1;
246 # and in project config gitweb.pickaxe = 0|1;
248 'sub' => \
&feature_pickaxe
,
252 # Make gitweb use an alternative format of the URLs which can be
253 # more readable and natural-looking: project name is embedded
254 # directly in the path and the query string contains other
255 # auxiliary information. All gitweb installations recognize
256 # URL in either format; this configures in which formats gitweb
259 # To enable system wide have in $GITWEB_CONFIG
260 # $feature{'pathinfo'}{'default'} = [1];
261 # Project specific override is not supported.
263 # Note that you will need to change the default location of CSS,
264 # favicon, logo and possibly other files to an absolute URL. Also,
265 # if gitweb.cgi serves as your indexfile, you will need to force
266 # $my_uri to contain the script name in your $GITWEB_CONFIG.
271 # Make gitweb consider projects in project root subdirectories
272 # to be forks of existing projects. Given project $projname.git,
273 # projects matching $projname/*.git will not be shown in the main
274 # projects list, instead a '+' mark will be added to $projname
275 # there and a 'forks' view will be enabled for the project, listing
276 # all the forks. If project list is taken from a file, forks have
277 # to be listed after the main project.
279 # To enable system wide have in $GITWEB_CONFIG
280 # $feature{'forks'}{'default'} = [1];
281 # Project specific override is not supported.
286 # Allow gitweb scan project content tags described in ctags/
287 # of project repository, and display the popular Web 2.0-ish
288 # "tag cloud" near the project list. Note that this is something
289 # COMPLETELY different from the normal Git tags.
291 # gitweb by itself can show existing tags, but it does not handle
292 # tagging itself; you need an external application for that.
293 # For an example script, check Girocco's cgi/tagproj.cgi.
294 # You may want to install the HTML::TagCloud Perl module to get
295 # a pretty tag cloud instead of just a list of tags.
297 # To enable system wide have in $GITWEB_CONFIG
298 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
299 # Project specific override is not supported.
305 sub gitweb_check_feature
{
307 return unless exists $feature{$name};
308 my ($sub, $override, @defaults) = (
309 $feature{$name}{'sub'},
310 $feature{$name}{'override'},
311 @
{$feature{$name}{'default'}});
312 if (!$override) { return @defaults; }
314 warn "feature $name is not overrideable";
317 return $sub->(@defaults);
321 my ($val) = git_get_project_config
('blame', '--bool');
323 if ($val eq 'true') {
325 } elsif ($val eq 'false') {
332 sub feature_snapshot
{
335 my ($val) = git_get_project_config
('snapshot');
338 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
345 my ($val) = git_get_project_config
('grep', '--bool');
347 if ($val eq 'true') {
349 } elsif ($val eq 'false') {
356 sub feature_pickaxe
{
357 my ($val) = git_get_project_config
('pickaxe', '--bool');
359 if ($val eq 'true') {
361 } elsif ($val eq 'false') {
368 # checking HEAD file with -e is fragile if the repository was
369 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
371 sub check_head_link
{
373 my $headfile = "$dir/HEAD";
374 return ((-e
$headfile) ||
375 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
378 sub check_export_ok
{
380 return (check_head_link
($dir) &&
381 (!$export_ok || -e
"$dir/$export_ok"));
384 # process alternate names for backward compatibility
385 # filter out unsupported (unknown) snapshot formats
386 sub filter_snapshot_fmts
{
390 exists $known_snapshot_format_aliases{$_} ?
391 $known_snapshot_format_aliases{$_} : $_} @fmts;
392 @fmts = grep(exists $known_snapshot_formats{$_}, @fmts);
396 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
397 if (-e
$GITWEB_CONFIG) {
400 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
401 do $GITWEB_CONFIG_SYSTEM if -e
$GITWEB_CONFIG_SYSTEM;
404 # version of the core git binary
405 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
407 $projects_list ||= $projectroot;
409 # ======================================================================
410 # input validation and dispatch
411 our $action = $cgi->param('a');
412 if (defined $action) {
413 if ($action =~ m/[^0-9a-zA-Z\.\-_]/) {
414 die_error
(400, "Invalid action parameter");
418 # parameters which are pathnames
419 our $project = $cgi->param('p');
420 if (defined $project) {
421 if (!validate_pathname
($project) ||
422 !(-d
"$projectroot/$project") ||
423 !check_head_link
("$projectroot/$project") ||
424 ($export_ok && !(-e
"$projectroot/$project/$export_ok")) ||
425 ($strict_export && !project_in_list
($project))) {
427 die_error
(404, "No such project");
431 our $file_name = $cgi->param('f');
432 if (defined $file_name) {
433 if (!validate_pathname
($file_name)) {
434 die_error
(400, "Invalid file parameter");
438 our $file_parent = $cgi->param('fp');
439 if (defined $file_parent) {
440 if (!validate_pathname
($file_parent)) {
441 die_error
(400, "Invalid file parent parameter");
445 # parameters which are refnames
446 our $hash = $cgi->param('h');
448 if (!validate_refname
($hash)) {
449 die_error
(400, "Invalid hash parameter");
453 our $hash_parent = $cgi->param('hp');
454 if (defined $hash_parent) {
455 if (!validate_refname
($hash_parent)) {
456 die_error
(400, "Invalid hash parent parameter");
460 our $hash_base = $cgi->param('hb');
461 if (defined $hash_base) {
462 if (!validate_refname
($hash_base)) {
463 die_error
(400, "Invalid hash base parameter");
467 my %allowed_options = (
468 "--no-merges" => [ qw(rss atom log shortlog history) ],
471 our @extra_options = $cgi->param('opt');
472 if (defined @extra_options) {
473 foreach my $opt (@extra_options) {
474 if (not exists $allowed_options{$opt}) {
475 die_error
(400, "Invalid option parameter");
477 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
478 die_error
(400, "Invalid option parameter for this action");
483 our $hash_parent_base = $cgi->param('hpb');
484 if (defined $hash_parent_base) {
485 if (!validate_refname
($hash_parent_base)) {
486 die_error
(400, "Invalid hash parent base parameter");
491 our $page = $cgi->param('pg');
493 if ($page =~ m/[^0-9]/) {
494 die_error
(400, "Invalid page parameter");
498 our $searchtype = $cgi->param('st');
499 if (defined $searchtype) {
500 if ($searchtype =~ m/[^a-z]/) {
501 die_error
(400, "Invalid searchtype parameter");
505 our $search_use_regexp = $cgi->param('sr');
507 our $searchtext = $cgi->param('s');
509 if (defined $searchtext) {
510 if (length($searchtext) < 2) {
511 die_error
(403, "At least two characters are required for search parameter");
513 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
516 # now read PATH_INFO and use it as alternative to parameters
517 sub evaluate_path_info
{
518 return if defined $project;
519 my $path_info = $ENV{"PATH_INFO"};
520 return if !$path_info;
521 $path_info =~ s
,^/+,,;
522 return if !$path_info;
523 # find which part of PATH_INFO is project
524 $project = $path_info;
526 while ($project && !check_head_link
("$projectroot/$project")) {
527 $project =~ s
,/*[^/]*$,,;
530 $project = validate_pathname
($project);
532 ($export_ok && !-e
"$projectroot/$project/$export_ok") ||
533 ($strict_export && !project_in_list
($project))) {
537 # do not change any parameters if an action is given using the query string
539 $path_info =~ s
,^\Q
$project\E
/*,,;
540 my ($refname, $pathname) = split(/:/, $path_info, 2);
541 if (defined $pathname) {
542 # we got "project.git/branch:filename" or "project.git/branch:dir/"
543 # we could use git_get_type(branch:pathname), but it needs $git_dir
544 $pathname =~ s
,^/+,,;
545 if (!$pathname || substr($pathname, -1) eq "/") {
549 $action ||= "blob_plain";
551 $hash_base ||= validate_refname
($refname);
552 $file_name ||= validate_pathname
($pathname);
553 } elsif (defined $refname) {
554 # we got "project.git/branch"
555 $action ||= "shortlog";
556 $hash ||= validate_refname
($refname);
559 evaluate_path_info
();
561 # path to the current git repository
563 $git_dir = "$projectroot/$project" if $project;
567 "blame" => \
&git_blame
,
568 "blobdiff" => \
&git_blobdiff
,
569 "blobdiff_plain" => \
&git_blobdiff_plain
,
570 "blob" => \
&git_blob
,
571 "blob_plain" => \
&git_blob_plain
,
572 "commitdiff" => \
&git_commitdiff
,
573 "commitdiff_plain" => \
&git_commitdiff_plain
,
574 "commit" => \
&git_commit
,
575 "forks" => \
&git_forks
,
576 "heads" => \
&git_heads
,
577 "history" => \
&git_history
,
580 "atom" => \
&git_atom
,
581 "search" => \
&git_search
,
582 "search_help" => \
&git_search_help
,
583 "shortlog" => \
&git_shortlog
,
584 "summary" => \
&git_summary
,
586 "tags" => \
&git_tags
,
587 "tree" => \
&git_tree
,
588 "snapshot" => \
&git_snapshot
,
589 "object" => \
&git_object
,
590 # those below don't need $project
591 "opml" => \
&git_opml
,
592 "project_list" => \
&git_project_list
,
593 "project_index" => \
&git_project_index
,
596 if (!defined $action) {
598 $action = git_get_type
($hash);
599 } elsif (defined $hash_base && defined $file_name) {
600 $action = git_get_type
("$hash_base:$file_name");
601 } elsif (defined $project) {
604 $action = 'project_list';
607 if (!defined($actions{$action})) {
608 die_error
(400, "Unknown action");
610 if ($action !~ m/^(opml|project_list|project_index)$/ &&
612 die_error
(400, "Project needed");
614 $actions{$action}->();
617 ## ======================================================================
622 # default is to use -absolute url() i.e. $my_uri
623 my $href = $params{-full
} ?
$my_url : $my_uri;
625 # XXX: Warning: If you touch this, check the search form for updating,
636 hash_parent_base
=> "hpb",
641 snapshot_format
=> "sf",
642 extra_options
=> "opt",
643 search_use_regexp
=> "sr",
645 my %mapping = @mapping;
647 $params{'project'} = $project unless exists $params{'project'};
649 if ($params{-replay
}) {
650 while (my ($name, $symbol) = each %mapping) {
651 if (!exists $params{$name}) {
652 # to allow for multivalued params we use arrayref form
653 $params{$name} = [ $cgi->param($symbol) ];
658 my ($use_pathinfo) = gitweb_check_feature
('pathinfo');
660 # use PATH_INFO for project name
661 $href .= "/".esc_url
($params{'project'}) if defined $params{'project'};
662 delete $params{'project'};
664 # Summary just uses the project path URL
665 if (defined $params{'action'} && $params{'action'} eq 'summary') {
666 delete $params{'action'};
670 # now encode the parameters explicitly
672 for (my $i = 0; $i < @mapping; $i += 2) {
673 my ($name, $symbol) = ($mapping[$i], $mapping[$i+1]);
674 if (defined $params{$name}) {
675 if (ref($params{$name}) eq "ARRAY") {
676 foreach my $par (@
{$params{$name}}) {
677 push @result, $symbol . "=" . esc_param
($par);
680 push @result, $symbol . "=" . esc_param
($params{$name});
684 $href .= "?" . join(';', @result) if scalar @result;
690 ## ======================================================================
691 ## validation, quoting/unquoting and escaping
693 sub validate_pathname
{
694 my $input = shift || return undef;
696 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
697 # at the beginning, at the end, and between slashes.
698 # also this catches doubled slashes
699 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
703 if ($input =~ m!\0!) {
709 sub validate_refname
{
710 my $input = shift || return undef;
712 # textual hashes are O.K.
713 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
716 # it must be correct pathname
717 $input = validate_pathname
($input)
719 # restrictions on ref name according to git-check-ref-format
720 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
726 # decode sequences of octets in utf8 into Perl's internal form,
727 # which is utf-8 with utf8 flag set if needed. gitweb writes out
728 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
731 if (utf8
::valid
($str)) {
735 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
739 # quote unsafe chars, but keep the slash, even when it's not
740 # correct, but quoted slashes look too horrible in bookmarks
743 $str =~ s/([^A-Za-z0-9\-_.~()\/:@])/sprintf
("%%%02X", ord($1))/eg
;
749 # quote unsafe chars in whole URL, so some charactrs cannot be quoted
752 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&=])/sprintf
("%%%02X", ord($1))/eg
;
758 # replace invalid utf8 character with SUBSTITUTION sequence
763 $str = to_utf8
($str);
764 $str = $cgi->escapeHTML($str);
765 if ($opts{'-nbsp'}) {
766 $str =~ s/ / /g;
768 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
772 # quote control characters and escape filename to HTML
777 $str = to_utf8
($str);
778 $str = $cgi->escapeHTML($str);
779 if ($opts{'-nbsp'}) {
780 $str =~ s/ / /g;
782 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
786 # Make control characters "printable", using character escape codes (CEC)
790 my %es = ( # character escape codes, aka escape sequences
791 "\t" => '\t', # tab (HT)
792 "\n" => '\n', # line feed (LF)
793 "\r" => '\r', # carrige return (CR)
794 "\f" => '\f', # form feed (FF)
795 "\b" => '\b', # backspace (BS)
796 "\a" => '\a', # alarm (bell) (BEL)
797 "\e" => '\e', # escape (ESC)
798 "\013" => '\v', # vertical tab (VT)
799 "\000" => '\0', # nul character (NUL)
801 my $chr = ( (exists $es{$cntrl})
803 : sprintf('\%2x', ord($cntrl)) );
804 if ($opts{-nohtml
}) {
807 return "<span class=\"cntrl\">$chr</span>";
811 # Alternatively use unicode control pictures codepoints,
812 # Unicode "printable representation" (PR)
817 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
818 if ($opts{-nohtml
}) {
821 return "<span class=\"cntrl\">$chr</span>";
825 # git may return quoted and escaped filenames
831 my %es = ( # character escape codes, aka escape sequences
832 't' => "\t", # tab (HT, TAB)
833 'n' => "\n", # newline (NL)
834 'r' => "\r", # return (CR)
835 'f' => "\f", # form feed (FF)
836 'b' => "\b", # backspace (BS)
837 'a' => "\a", # alarm (bell) (BEL)
838 'e' => "\e", # escape (ESC)
839 'v' => "\013", # vertical tab (VT)
842 if ($seq =~ m/^[0-7]{1,3}$/) {
843 # octal char sequence
844 return chr(oct($seq));
845 } elsif (exists $es{$seq}) {
846 # C escape sequence, aka character escape code
849 # quoted ordinary character
853 if ($str =~ m/^"(.*)"$/) {
856 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
861 # escape tabs (convert tabs to spaces)
865 while ((my $pos = index($line, "\t")) != -1) {
866 if (my $count = (8 - ($pos % 8))) {
867 my $spaces = ' ' x
$count;
868 $line =~ s/\t/$spaces/;
875 sub project_in_list
{
877 my @list = git_get_projects_list
();
878 return @list && scalar(grep { $_->{'path'} eq $project } @list);
881 ## ----------------------------------------------------------------------
882 ## HTML aware string manipulation
884 # Try to chop given string on a word boundary between position
885 # $len and $len+$add_len. If there is no word boundary there,
886 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
887 # (marking chopped part) would be longer than given string.
891 my $add_len = shift || 10;
892 my $where = shift || 'right'; # 'left' | 'center' | 'right'
894 # Make sure perl knows it is utf8 encoded so we don't
895 # cut in the middle of a utf8 multibyte char.
896 $str = to_utf8
($str);
898 # allow only $len chars, but don't cut a word if it would fit in $add_len
899 # if it doesn't fit, cut it if it's still longer than the dots we would add
900 # remove chopped character entities entirely
902 # when chopping in the middle, distribute $len into left and right part
903 # return early if chopping wouldn't make string shorter
904 if ($where eq 'center') {
905 return $str if ($len + 5 >= length($str)); # filler is length 5
908 return $str if ($len + 4 >= length($str)); # filler is length 4
911 # regexps: ending and beginning with word part up to $add_len
912 my $endre = qr/.{$len}\w{0,$add_len}/;
913 my $begre = qr/\w{0,$add_len}.{$len}/;
915 if ($where eq 'left') {
916 $str =~ m/^(.*?)($begre)$/;
917 my ($lead, $body) = ($1, $2);
918 if (length($lead) > 4) {
919 $body =~ s/^[^;]*;// if ($lead =~ m/&[^;]*$/);
924 } elsif ($where eq 'center') {
925 $str =~ m/^($endre)(.*)$/;
926 my ($left, $str) = ($1, $2);
927 $str =~ m/^(.*?)($begre)$/;
928 my ($mid, $right) = ($1, $2);
929 if (length($mid) > 5) {
930 $left =~ s/&[^;]*$//;
931 $right =~ s/^[^;]*;// if ($mid =~ m/&[^;]*$/);
934 return "$left$mid$right";
937 $str =~ m/^($endre)(.*)$/;
940 if (length($tail) > 4) {
941 $body =~ s/&[^;]*$//;
948 # takes the same arguments as chop_str, but also wraps a <span> around the
949 # result with a title attribute if it does get chopped. Additionally, the
950 # string is HTML-escaped.
951 sub chop_and_escape_str
{
954 my $chopped = chop_str
(@_);
955 if ($chopped eq $str) {
956 return esc_html
($chopped);
958 $str =~ s/([[:cntrl:]])/?/g;
959 return $cgi->span({-title
=>$str}, esc_html
($chopped));
963 ## ----------------------------------------------------------------------
964 ## functions returning short strings
966 # CSS class for given age value (in seconds)
972 } elsif ($age < 60*60*2) {
974 } elsif ($age < 60*60*24*2) {
981 # convert age in seconds to "nn units ago" string
986 if ($age > 60*60*24*365*2) {
987 $age_str = (int $age/60/60/24/365);
988 $age_str .= " years ago";
989 } elsif ($age > 60*60*24*(365/12)*2) {
990 $age_str = int $age/60/60/24/(365/12);
991 $age_str .= " months ago";
992 } elsif ($age > 60*60*24*7*2) {
993 $age_str = int $age/60/60/24/7;
994 $age_str .= " weeks ago";
995 } elsif ($age > 60*60*24*2) {
996 $age_str = int $age/60/60/24;
997 $age_str .= " days ago";
998 } elsif ($age > 60*60*2) {
999 $age_str = int $age/60/60;
1000 $age_str .= " hours ago";
1001 } elsif ($age > 60*2) {
1002 $age_str = int $age/60;
1003 $age_str .= " min ago";
1004 } elsif ($age > 2) {
1005 $age_str = int $age;
1006 $age_str .= " sec ago";
1008 $age_str .= " right now";
1014 S_IFINVALID
=> 0030000,
1015 S_IFGITLINK
=> 0160000,
1018 # submodule/subproject, a commit object reference
1019 sub S_ISGITLINK
($) {
1022 return (($mode & S_IFMT
) == S_IFGITLINK
)
1025 # convert file mode in octal to symbolic file mode string
1027 my $mode = oct shift;
1029 if (S_ISGITLINK
($mode)) {
1030 return 'm---------';
1031 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1032 return 'drwxr-xr-x';
1033 } elsif (S_ISLNK
($mode)) {
1034 return 'lrwxrwxrwx';
1035 } elsif (S_ISREG
($mode)) {
1036 # git cares only about the executable bit
1037 if ($mode & S_IXUSR
) {
1038 return '-rwxr-xr-x';
1040 return '-rw-r--r--';
1043 return '----------';
1047 # convert file mode in octal to file type string
1051 if ($mode !~ m/^[0-7]+$/) {
1057 if (S_ISGITLINK
($mode)) {
1059 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1061 } elsif (S_ISLNK
($mode)) {
1063 } elsif (S_ISREG
($mode)) {
1070 # convert file mode in octal to file type description string
1071 sub file_type_long
{
1074 if ($mode !~ m/^[0-7]+$/) {
1080 if (S_ISGITLINK
($mode)) {
1082 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1084 } elsif (S_ISLNK
($mode)) {
1086 } elsif (S_ISREG
($mode)) {
1087 if ($mode & S_IXUSR
) {
1088 return "executable";
1098 ## ----------------------------------------------------------------------
1099 ## functions returning short HTML fragments, or transforming HTML fragments
1100 ## which don't belong to other sections
1102 # format line of commit message.
1103 sub format_log_line_html
{
1106 $line = esc_html
($line, -nbsp
=>1);
1107 if ($line =~ m/([0-9a-fA-F]{8,40})/) {
1110 $cgi->a({-href
=> href
(action
=>"object", hash
=>$hash_text),
1111 -class => "text"}, $hash_text);
1112 $line =~ s/$hash_text/$link/;
1117 # format marker of refs pointing to given object
1119 # the destination action is chosen based on object type and current context:
1120 # - for annotated tags, we choose the tag view unless it's the current view
1121 # already, in which case we go to shortlog view
1122 # - for other refs, we keep the current view if we're in history, shortlog or
1123 # log view, and select shortlog otherwise
1124 sub format_ref_marker
{
1125 my ($refs, $id) = @_;
1128 if (defined $refs->{$id}) {
1129 foreach my $ref (@
{$refs->{$id}}) {
1130 # this code exploits the fact that non-lightweight tags are the
1131 # only indirect objects, and that they are the only objects for which
1132 # we want to use tag instead of shortlog as action
1133 my ($type, $name) = qw();
1134 my $indirect = ($ref =~ s/\^\{\}$//);
1135 # e.g. tags/v2.6.11 or heads/next
1136 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1145 $class .= " indirect" if $indirect;
1147 my $dest_action = "shortlog";
1150 $dest_action = "tag" unless $action eq "tag";
1151 } elsif ($action =~ /^(history|(short)?log)$/) {
1152 $dest_action = $action;
1156 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1159 my $link = $cgi->a({
1161 action
=>$dest_action,
1165 $markers .= " <span class=\"$class\" title=\"$ref\">" .
1171 return ' <span class="refs">'. $markers . '</span>';
1177 # format, perhaps shortened and with markers, title line
1178 sub format_subject_html
{
1179 my ($long, $short, $href, $extra) = @_;
1180 $extra = '' unless defined($extra);
1182 if (length($short) < length($long)) {
1183 return $cgi->a({-href
=> $href, -class => "list subject",
1184 -title
=> to_utf8
($long)},
1185 esc_html
($short) . $extra);
1187 return $cgi->a({-href
=> $href, -class => "list subject"},
1188 esc_html
($long) . $extra);
1192 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1193 sub format_git_diff_header_line
{
1195 my $diffinfo = shift;
1196 my ($from, $to) = @_;
1198 if ($diffinfo->{'nparents'}) {
1200 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1201 if ($to->{'href'}) {
1202 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1203 esc_path
($to->{'file'}));
1204 } else { # file was deleted (no href)
1205 $line .= esc_path
($to->{'file'});
1209 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1210 if ($from->{'href'}) {
1211 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
1212 'a/' . esc_path
($from->{'file'}));
1213 } else { # file was added (no href)
1214 $line .= 'a/' . esc_path
($from->{'file'});
1217 if ($to->{'href'}) {
1218 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1219 'b/' . esc_path
($to->{'file'}));
1220 } else { # file was deleted
1221 $line .= 'b/' . esc_path
($to->{'file'});
1225 return "<div class=\"diff header\">$line</div>\n";
1228 # format extended diff header line, before patch itself
1229 sub format_extended_diff_header_line
{
1231 my $diffinfo = shift;
1232 my ($from, $to) = @_;
1235 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1236 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1237 esc_path
($from->{'file'}));
1239 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1240 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1241 esc_path
($to->{'file'}));
1243 # match single <mode>
1244 if ($line =~ m/\s(\d{6})$/) {
1245 $line .= '<span class="info"> (' .
1246 file_type_long
($1) .
1250 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1251 # can match only for combined diff
1253 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1254 if ($from->{'href'}[$i]) {
1255 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
1257 substr($diffinfo->{'from_id'}[$i],0,7));
1262 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1265 if ($to->{'href'}) {
1266 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1267 substr($diffinfo->{'to_id'},0,7));
1272 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
1273 # can match only for ordinary diff
1274 my ($from_link, $to_link);
1275 if ($from->{'href'}) {
1276 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
1277 substr($diffinfo->{'from_id'},0,7));
1279 $from_link = '0' x
7;
1281 if ($to->{'href'}) {
1282 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1283 substr($diffinfo->{'to_id'},0,7));
1287 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
1288 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
1291 return $line . "<br/>\n";
1294 # format from-file/to-file diff header
1295 sub format_diff_from_to_header
{
1296 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
1301 #assert($line =~ m/^---/) if DEBUG;
1302 # no extra formatting for "^--- /dev/null"
1303 if (! $diffinfo->{'nparents'}) {
1304 # ordinary (single parent) diff
1305 if ($line =~ m!^--- "?a/!) {
1306 if ($from->{'href'}) {
1308 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1309 esc_path
($from->{'file'}));
1312 esc_path
($from->{'file'});
1315 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1318 # combined diff (merge commit)
1319 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1320 if ($from->{'href'}[$i]) {
1322 $cgi->a({-href
=>href
(action
=>"blobdiff",
1323 hash_parent
=>$diffinfo->{'from_id'}[$i],
1324 hash_parent_base
=>$parents[$i],
1325 file_parent
=>$from->{'file'}[$i],
1326 hash
=>$diffinfo->{'to_id'},
1328 file_name
=>$to->{'file'}),
1330 -title
=>"diff" . ($i+1)},
1333 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
1334 esc_path
($from->{'file'}[$i]));
1336 $line = '--- /dev/null';
1338 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1343 #assert($line =~ m/^\+\+\+/) if DEBUG;
1344 # no extra formatting for "^+++ /dev/null"
1345 if ($line =~ m!^\+\+\+ "?b/!) {
1346 if ($to->{'href'}) {
1348 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1349 esc_path
($to->{'file'}));
1352 esc_path
($to->{'file'});
1355 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
1360 # create note for patch simplified by combined diff
1361 sub format_diff_cc_simplified
{
1362 my ($diffinfo, @parents) = @_;
1365 $result .= "<div class=\"diff header\">" .
1367 if (!is_deleted
($diffinfo)) {
1368 $result .= $cgi->a({-href
=> href
(action
=>"blob",
1370 hash
=>$diffinfo->{'to_id'},
1371 file_name
=>$diffinfo->{'to_file'}),
1373 esc_path
($diffinfo->{'to_file'}));
1375 $result .= esc_path
($diffinfo->{'to_file'});
1377 $result .= "</div>\n" . # class="diff header"
1378 "<div class=\"diff nodifferences\">" .
1380 "</div>\n"; # class="diff nodifferences"
1385 # format patch (diff) line (not to be used for diff headers)
1386 sub format_diff_line
{
1388 my ($from, $to) = @_;
1389 my $diff_class = "";
1393 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
1395 my $prefix = substr($line, 0, scalar @
{$from->{'href'}});
1396 if ($line =~ m/^\@{3}/) {
1397 $diff_class = " chunk_header";
1398 } elsif ($line =~ m/^\\/) {
1399 $diff_class = " incomplete";
1400 } elsif ($prefix =~ tr/+/+/) {
1401 $diff_class = " add";
1402 } elsif ($prefix =~ tr/-/-/) {
1403 $diff_class = " rem";
1406 # assume ordinary diff
1407 my $char = substr($line, 0, 1);
1409 $diff_class = " add";
1410 } elsif ($char eq '-') {
1411 $diff_class = " rem";
1412 } elsif ($char eq '@') {
1413 $diff_class = " chunk_header";
1414 } elsif ($char eq "\\") {
1415 $diff_class = " incomplete";
1418 $line = untabify
($line);
1419 if ($from && $to && $line =~ m/^\@{2} /) {
1420 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
1421 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
1423 $from_lines = 0 unless defined $from_lines;
1424 $to_lines = 0 unless defined $to_lines;
1426 if ($from->{'href'}) {
1427 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
1428 -class=>"list"}, $from_text);
1430 if ($to->{'href'}) {
1431 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1432 -class=>"list"}, $to_text);
1434 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
1435 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1436 return "<div class=\"diff$diff_class\">$line</div>\n";
1437 } elsif ($from && $to && $line =~ m/^\@{3}/) {
1438 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
1439 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
1441 @from_text = split(' ', $ranges);
1442 for (my $i = 0; $i < @from_text; ++$i) {
1443 ($from_start[$i], $from_nlines[$i]) =
1444 (split(',', substr($from_text[$i], 1)), 0);
1447 $to_text = pop @from_text;
1448 $to_start = pop @from_start;
1449 $to_nlines = pop @from_nlines;
1451 $line = "<span class=\"chunk_info\">$prefix ";
1452 for (my $i = 0; $i < @from_text; ++$i) {
1453 if ($from->{'href'}[$i]) {
1454 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
1455 -class=>"list"}, $from_text[$i]);
1457 $line .= $from_text[$i];
1461 if ($to->{'href'}) {
1462 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1463 -class=>"list"}, $to_text);
1467 $line .= " $prefix</span>" .
1468 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1469 return "<div class=\"diff$diff_class\">$line</div>\n";
1471 return "<div class=\"diff$diff_class\">" . esc_html
($line, -nbsp
=>1) . "</div>\n";
1474 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
1475 # linked. Pass the hash of the tree/commit to snapshot.
1476 sub format_snapshot_links
{
1478 my @snapshot_fmts = gitweb_check_feature
('snapshot');
1479 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1480 my $num_fmts = @snapshot_fmts;
1481 if ($num_fmts > 1) {
1482 # A parenthesized list of links bearing format names.
1483 # e.g. "snapshot (_tar.gz_ _zip_)"
1484 return "snapshot (" . join(' ', map
1491 }, $known_snapshot_formats{$_}{'display'})
1492 , @snapshot_fmts) . ")";
1493 } elsif ($num_fmts == 1) {
1494 # A single "snapshot" link whose tooltip bears the format name.
1496 my ($fmt) = @snapshot_fmts;
1502 snapshot_format
=>$fmt
1504 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
1506 } else { # $num_fmts == 0
1511 ## ......................................................................
1512 ## functions returning values to be passed, perhaps after some
1513 ## transformation, to other functions; e.g. returning arguments to href()
1515 # returns hash to be passed to href to generate gitweb URL
1516 # in -title key it returns description of link
1518 my $format = shift || 'Atom';
1519 my %res = (action
=> lc($format));
1521 # feed links are possible only for project views
1522 return unless (defined $project);
1523 # some views should link to OPML, or to generic project feed,
1524 # or don't have specific feed yet (so they should use generic)
1525 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
1528 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
1529 # from tag links; this also makes possible to detect branch links
1530 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
1531 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
1534 # find log type for feed description (title)
1536 if (defined $file_name) {
1537 $type = "history of $file_name";
1538 $type .= "/" if ($action eq 'tree');
1539 $type .= " on '$branch'" if (defined $branch);
1541 $type = "log of $branch" if (defined $branch);
1544 $res{-title
} = $type;
1545 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
1546 $res{'file_name'} = $file_name;
1551 ## ----------------------------------------------------------------------
1552 ## git utility subroutines, invoking git commands
1554 # returns path to the core git executable and the --git-dir parameter as list
1556 return $GIT, '--git-dir='.$git_dir;
1559 # quote the given arguments for passing them to the shell
1560 # quote_command("command", "arg 1", "arg with ' and ! characters")
1561 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
1562 # Try to avoid using this function wherever possible.
1565 map( { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ ));
1568 # get HEAD ref of given project as hash
1569 sub git_get_head_hash
{
1570 my $project = shift;
1571 my $o_git_dir = $git_dir;
1573 $git_dir = "$projectroot/$project";
1574 if (open my $fd, "-|", git_cmd
(), "rev-parse", "--verify", "HEAD") {
1577 if (defined $head && $head =~ /^([0-9a-fA-F]{40})$/) {
1581 if (defined $o_git_dir) {
1582 $git_dir = $o_git_dir;
1587 # get type of given object
1591 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
1593 close $fd or return;
1598 # repository configuration
1599 our $config_file = '';
1602 # store multiple values for single key as anonymous array reference
1603 # single values stored directly in the hash, not as [ <value> ]
1604 sub hash_set_multi
{
1605 my ($hash, $key, $value) = @_;
1607 if (!exists $hash->{$key}) {
1608 $hash->{$key} = $value;
1609 } elsif (!ref $hash->{$key}) {
1610 $hash->{$key} = [ $hash->{$key}, $value ];
1612 push @
{$hash->{$key}}, $value;
1616 # return hash of git project configuration
1617 # optionally limited to some section, e.g. 'gitweb'
1618 sub git_parse_project_config
{
1619 my $section_regexp = shift;
1624 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
1627 while (my $keyval = <$fh>) {
1629 my ($key, $value) = split(/\n/, $keyval, 2);
1631 hash_set_multi
(\
%config, $key, $value)
1632 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
1639 # convert config value to boolean, 'true' or 'false'
1640 # no value, number > 0, 'true' and 'yes' values are true
1641 # rest of values are treated as false (never as error)
1642 sub config_to_bool
{
1645 # strip leading and trailing whitespace
1649 return (!defined $val || # section.key
1650 ($val =~ /^\d+$/ && $val) || # section.key = 1
1651 ($val =~ /^(?:true|yes)$/i)); # section.key = true
1654 # convert config value to simple decimal number
1655 # an optional value suffix of 'k', 'm', or 'g' will cause the value
1656 # to be multiplied by 1024, 1048576, or 1073741824
1660 # strip leading and trailing whitespace
1664 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
1666 # unknown unit is treated as 1
1667 return $num * ($unit eq 'g' ?
1073741824 :
1668 $unit eq 'm' ?
1048576 :
1669 $unit eq 'k' ?
1024 : 1);
1674 # convert config value to array reference, if needed
1675 sub config_to_multi
{
1678 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
1681 sub git_get_project_config
{
1682 my ($key, $type) = @_;
1685 return unless ($key);
1686 $key =~ s/^gitweb\.//;
1687 return if ($key =~ m/\W/);
1690 if (defined $type) {
1693 unless ($type eq 'bool' || $type eq 'int');
1697 if (!defined $config_file ||
1698 $config_file ne "$git_dir/config") {
1699 %config = git_parse_project_config
('gitweb');
1700 $config_file = "$git_dir/config";
1704 if (!defined $type) {
1705 return $config{"gitweb.$key"};
1706 } elsif ($type eq 'bool') {
1707 # backward compatibility: 'git config --bool' returns true/false
1708 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
1709 } elsif ($type eq 'int') {
1710 return config_to_int
($config{"gitweb.$key"});
1712 return $config{"gitweb.$key"};
1715 # get hash of given path at given ref
1716 sub git_get_hash_by_path
{
1718 my $path = shift || return undef;
1723 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
1724 or die_error
(500, "Open git-ls-tree failed");
1726 close $fd or return undef;
1728 if (!defined $line) {
1729 # there is no tree or hash given by $path at $base
1733 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
1734 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
1735 if (defined $type && $type ne $2) {
1736 # type doesn't match
1742 # get path of entry with given hash at given tree-ish (ref)
1743 # used to get 'from' filename for combined diff (merge commit) for renames
1744 sub git_get_path_by_hash
{
1745 my $base = shift || return;
1746 my $hash = shift || return;
1750 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
1752 while (my $line = <$fd>) {
1755 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
1756 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
1757 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
1766 ## ......................................................................
1767 ## git utility functions, directly accessing git repository
1769 sub git_get_project_description
{
1772 $git_dir = "$projectroot/$path";
1773 open my $fd, "$git_dir/description"
1774 or return git_get_project_config
('description');
1777 if (defined $descr) {
1783 sub git_get_project_ctags
{
1787 $git_dir = "$projectroot/$path";
1788 foreach (<$git_dir/ctags/*>) {
1789 open CT
, $_ or next;
1793 my $ctag = $_; $ctag =~ s
#.*/##;
1794 $ctags->{$ctag} = $val;
1799 sub git_populate_project_tagcloud
{
1802 # First, merge different-cased tags; tags vote on casing
1804 foreach (keys %$ctags) {
1805 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
1806 if (not $ctags_lc{lc $_}->{topcount
}
1807 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
1808 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
1809 $ctags_lc{lc $_}->{topname
} = $_;
1814 if (eval { require HTML
::TagCloud
; 1; }) {
1815 $cloud = HTML
::TagCloud
->new;
1816 foreach (sort keys %ctags_lc) {
1817 # Pad the title with spaces so that the cloud looks
1819 my $title = $ctags_lc{$_}->{topname
};
1820 $title =~ s/ / /g;
1821 $title =~ s/^/ /g;
1822 $title =~ s/$/ /g;
1823 $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count
});
1826 $cloud = \
%ctags_lc;
1831 sub git_show_project_tagcloud
{
1832 my ($cloud, $count) = @_;
1833 print STDERR
ref($cloud)."..\n";
1834 if (ref $cloud eq 'HTML::TagCloud') {
1835 return $cloud->html_and_css($count);
1837 my @tags = sort { $cloud->{$a}->{count
} <=> $cloud->{$b}->{count
} } keys %$cloud;
1838 return '<p align="center">' . join (', ', map {
1839 "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
1840 } splice(@tags, 0, $count)) . '</p>';
1844 sub git_get_project_url_list
{
1847 $git_dir = "$projectroot/$path";
1848 open my $fd, "$git_dir/cloneurl"
1849 or return wantarray ?
1850 @
{ config_to_multi
(git_get_project_config
('url')) } :
1851 config_to_multi
(git_get_project_config
('url'));
1852 my @git_project_url_list = map { chomp; $_ } <$fd>;
1855 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
1858 sub git_get_projects_list
{
1863 $filter =~ s/\.git$//;
1865 my ($check_forks) = gitweb_check_feature
('forks');
1867 if (-d
$projects_list) {
1868 # search in directory
1869 my $dir = $projects_list . ($filter ?
"/$filter" : '');
1870 # remove the trailing "/"
1872 my $pfxlen = length("$dir");
1873 my $pfxdepth = ($dir =~ tr!/!!);
1876 follow_fast
=> 1, # follow symbolic links
1877 follow_skip
=> 2, # ignore duplicates
1878 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
1880 # skip project-list toplevel, if we get it.
1881 return if (m!^[/.]$!);
1882 # only directories can be git repositories
1883 return unless (-d
$_);
1884 # don't traverse too deep (Find is super slow on os x)
1885 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
1886 $File::Find
::prune
= 1;
1890 my $subdir = substr($File::Find
::name
, $pfxlen + 1);
1891 # we check related file in $projectroot
1892 if (check_export_ok
("$projectroot/$filter/$subdir")) {
1893 push @list, { path
=> ($filter ?
"$filter/" : '') . $subdir };
1894 $File::Find
::prune
= 1;
1899 } elsif (-f
$projects_list) {
1900 # read from file(url-encoded):
1901 # 'git%2Fgit.git Linus+Torvalds'
1902 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
1903 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
1905 open my ($fd), $projects_list or return;
1907 while (my $line = <$fd>) {
1909 my ($path, $owner) = split ' ', $line;
1910 $path = unescape
($path);
1911 $owner = unescape
($owner);
1912 if (!defined $path) {
1915 if ($filter ne '') {
1916 # looking for forks;
1917 my $pfx = substr($path, 0, length($filter));
1918 if ($pfx ne $filter) {
1921 my $sfx = substr($path, length($filter));
1922 if ($sfx !~ /^\/.*\
.git
$/) {
1925 } elsif ($check_forks) {
1927 foreach my $filter (keys %paths) {
1928 # looking for forks;
1929 my $pfx = substr($path, 0, length($filter));
1930 if ($pfx ne $filter) {
1933 my $sfx = substr($path, length($filter));
1934 if ($sfx !~ /^\/.*\
.git
$/) {
1937 # is a fork, don't include it in
1942 if (check_export_ok
("$projectroot/$path")) {
1945 owner
=> to_utf8
($owner),
1948 (my $forks_path = $path) =~ s/\.git$//;
1949 $paths{$forks_path}++;
1957 our $gitweb_project_owner = undef;
1958 sub git_get_project_list_from_file
{
1960 return if (defined $gitweb_project_owner);
1962 $gitweb_project_owner = {};
1963 # read from file (url-encoded):
1964 # 'git%2Fgit.git Linus+Torvalds'
1965 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
1966 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
1967 if (-f
$projects_list) {
1968 open (my $fd , $projects_list);
1969 while (my $line = <$fd>) {
1971 my ($pr, $ow) = split ' ', $line;
1972 $pr = unescape
($pr);
1973 $ow = unescape
($ow);
1974 $gitweb_project_owner->{$pr} = to_utf8
($ow);
1980 sub git_get_project_owner
{
1981 my $project = shift;
1984 return undef unless $project;
1985 $git_dir = "$projectroot/$project";
1987 if (!defined $gitweb_project_owner) {
1988 git_get_project_list_from_file
();
1991 if (exists $gitweb_project_owner->{$project}) {
1992 $owner = $gitweb_project_owner->{$project};
1994 if (!defined $owner){
1995 $owner = git_get_project_config
('owner');
1997 if (!defined $owner) {
1998 $owner = get_file_owner
("$git_dir");
2004 sub git_get_last_activity
{
2008 $git_dir = "$projectroot/$path";
2009 open($fd, "-|", git_cmd
(), 'for-each-ref',
2010 '--format=%(committer)',
2011 '--sort=-committerdate',
2013 'refs/heads') or return;
2014 my $most_recent = <$fd>;
2015 close $fd or return;
2016 if (defined $most_recent &&
2017 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2019 my $age = time - $timestamp;
2020 return ($age, age_string
($age));
2022 return (undef, undef);
2025 sub git_get_references
{
2026 my $type = shift || "";
2028 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2029 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2030 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
2031 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
2034 while (my $line = <$fd>) {
2036 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2037 if (defined $refs{$1}) {
2038 push @
{$refs{$1}}, $2;
2044 close $fd or return;
2048 sub git_get_rev_name_tags
{
2049 my $hash = shift || return undef;
2051 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
2053 my $name_rev = <$fd>;
2056 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
2059 # catches also '$hash undefined' output
2064 ## ----------------------------------------------------------------------
2065 ## parse to hash functions
2069 my $tz = shift || "-0000";
2072 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2073 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2074 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2075 $date{'hour'} = $hour;
2076 $date{'minute'} = $min;
2077 $date{'mday'} = $mday;
2078 $date{'day'} = $days[$wday];
2079 $date{'month'} = $months[$mon];
2080 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2081 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2082 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2083 $mday, $months[$mon], $hour ,$min;
2084 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2085 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2087 $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2088 my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2089 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2090 $date{'hour_local'} = $hour;
2091 $date{'minute_local'} = $min;
2092 $date{'tz_local'} = $tz;
2093 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2094 1900+$year, $mon+1, $mday,
2095 $hour, $min, $sec, $tz);
2104 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
2105 $tag{'id'} = $tag_id;
2106 while (my $line = <$fd>) {
2108 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2109 $tag{'object'} = $1;
2110 } elsif ($line =~ m/^type (.+)$/) {
2112 } elsif ($line =~ m/^tag (.+)$/) {
2114 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2115 $tag{'author'} = $1;
2118 } elsif ($line =~ m/--BEGIN/) {
2119 push @comment, $line;
2121 } elsif ($line eq "") {
2125 push @comment, <$fd>;
2126 $tag{'comment'} = \
@comment;
2127 close $fd or return;
2128 if (!defined $tag{'name'}) {
2134 sub parse_commit_text
{
2135 my ($commit_text, $withparents) = @_;
2136 my @commit_lines = split '\n', $commit_text;
2139 pop @commit_lines; # Remove '\0'
2141 if (! @commit_lines) {
2145 my $header = shift @commit_lines;
2146 if ($header !~ m/^[0-9a-fA-F]{40}/) {
2149 ($co{'id'}, my @parents) = split ' ', $header;
2150 while (my $line = shift @commit_lines) {
2151 last if $line eq "\n";
2152 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2154 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2156 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2158 $co{'author_epoch'} = $2;
2159 $co{'author_tz'} = $3;
2160 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2161 $co{'author_name'} = $1;
2162 $co{'author_email'} = $2;
2164 $co{'author_name'} = $co{'author'};
2166 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2167 $co{'committer'} = $1;
2168 $co{'committer_epoch'} = $2;
2169 $co{'committer_tz'} = $3;
2170 $co{'committer_name'} = $co{'committer'};
2171 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2172 $co{'committer_name'} = $1;
2173 $co{'committer_email'} = $2;
2175 $co{'committer_name'} = $co{'committer'};
2179 if (!defined $co{'tree'}) {
2182 $co{'parents'} = \
@parents;
2183 $co{'parent'} = $parents[0];
2185 foreach my $title (@commit_lines) {
2188 $co{'title'} = chop_str
($title, 80, 5);
2189 # remove leading stuff of merges to make the interesting part visible
2190 if (length($title) > 50) {
2191 $title =~ s/^Automatic //;
2192 $title =~ s/^merge (of|with) /Merge ... /i;
2193 if (length($title) > 50) {
2194 $title =~ s/(http|rsync):\/\///;
2196 if (length($title) > 50) {
2197 $title =~ s/(master|www|rsync)\.//;
2199 if (length($title) > 50) {
2200 $title =~ s/kernel.org:?//;
2202 if (length($title) > 50) {
2203 $title =~ s/\/pub\/scm//;
2206 $co{'title_short'} = chop_str
($title, 50, 5);
2210 if (! defined $co{'title'} || $co{'title'} eq "") {
2211 $co{'title'} = $co{'title_short'} = '(no commit message)';
2213 # remove added spaces
2214 foreach my $line (@commit_lines) {
2217 $co{'comment'} = \
@commit_lines;
2219 my $age = time - $co{'committer_epoch'};
2221 $co{'age_string'} = age_string
($age);
2222 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2223 if ($age > 60*60*24*7*2) {
2224 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2225 $co{'age_string_age'} = $co{'age_string'};
2227 $co{'age_string_date'} = $co{'age_string'};
2228 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2234 my ($commit_id) = @_;
2239 open my $fd, "-|", git_cmd
(), "rev-list",
2245 or die_error
(500, "Open git-rev-list failed");
2246 %co = parse_commit_text
(<$fd>, 1);
2253 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
2261 open my $fd, "-|", git_cmd
(), "rev-list",
2264 ("--max-count=" . $maxcount),
2265 ("--skip=" . $skip),
2269 ($filename ?
($filename) : ())
2270 or die_error
(500, "Open git-rev-list failed");
2271 while (my $line = <$fd>) {
2272 my %co = parse_commit_text
($line);
2277 return wantarray ?
@cos : \
@cos;
2280 # parse line of git-diff-tree "raw" output
2281 sub parse_difftree_raw_line
{
2285 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
2286 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
2287 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
2288 $res{'from_mode'} = $1;
2289 $res{'to_mode'} = $2;
2290 $res{'from_id'} = $3;
2292 $res{'status'} = $5;
2293 $res{'similarity'} = $6;
2294 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
2295 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
2297 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
2300 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
2301 # combined diff (for merge commit)
2302 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
2303 $res{'nparents'} = length($1);
2304 $res{'from_mode'} = [ split(' ', $2) ];
2305 $res{'to_mode'} = pop @
{$res{'from_mode'}};
2306 $res{'from_id'} = [ split(' ', $3) ];
2307 $res{'to_id'} = pop @
{$res{'from_id'}};
2308 $res{'status'} = [ split('', $4) ];
2309 $res{'to_file'} = unquote
($5);
2311 # 'c512b523472485aef4fff9e57b229d9d243c967f'
2312 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
2313 $res{'commit'} = $1;
2316 return wantarray ?
%res : \
%res;
2319 # wrapper: return parsed line of git-diff-tree "raw" output
2320 # (the argument might be raw line, or parsed info)
2321 sub parsed_difftree_line
{
2322 my $line_or_ref = shift;
2324 if (ref($line_or_ref) eq "HASH") {
2325 # pre-parsed (or generated by hand)
2326 return $line_or_ref;
2328 return parse_difftree_raw_line
($line_or_ref);
2332 # parse line of git-ls-tree output
2333 sub parse_ls_tree_line
($;%) {
2338 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2339 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
2347 $res{'name'} = unquote
($4);
2350 return wantarray ?
%res : \
%res;
2353 # generates _two_ hashes, references to which are passed as 2 and 3 argument
2354 sub parse_from_to_diffinfo
{
2355 my ($diffinfo, $from, $to, @parents) = @_;
2357 if ($diffinfo->{'nparents'}) {
2359 $from->{'file'} = [];
2360 $from->{'href'} = [];
2361 fill_from_file_info
($diffinfo, @parents)
2362 unless exists $diffinfo->{'from_file'};
2363 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2364 $from->{'file'}[$i] =
2365 defined $diffinfo->{'from_file'}[$i] ?
2366 $diffinfo->{'from_file'}[$i] :
2367 $diffinfo->{'to_file'};
2368 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
2369 $from->{'href'}[$i] = href
(action
=>"blob",
2370 hash_base
=>$parents[$i],
2371 hash
=>$diffinfo->{'from_id'}[$i],
2372 file_name
=>$from->{'file'}[$i]);
2374 $from->{'href'}[$i] = undef;
2378 # ordinary (not combined) diff
2379 $from->{'file'} = $diffinfo->{'from_file'};
2380 if ($diffinfo->{'status'} ne "A") { # not new (added) file
2381 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
2382 hash
=>$diffinfo->{'from_id'},
2383 file_name
=>$from->{'file'});
2385 delete $from->{'href'};
2389 $to->{'file'} = $diffinfo->{'to_file'};
2390 if (!is_deleted
($diffinfo)) { # file exists in result
2391 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
2392 hash
=>$diffinfo->{'to_id'},
2393 file_name
=>$to->{'file'});
2395 delete $to->{'href'};
2399 ## ......................................................................
2400 ## parse to array of hashes functions
2402 sub git_get_heads_list
{
2406 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2407 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
2408 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
2411 while (my $line = <$fd>) {
2415 my ($refinfo, $committerinfo) = split(/\0/, $line);
2416 my ($hash, $name, $title) = split(' ', $refinfo, 3);
2417 my ($committer, $epoch, $tz) =
2418 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
2419 $ref_item{'fullname'} = $name;
2420 $name =~ s!^refs/heads/!!;
2422 $ref_item{'name'} = $name;
2423 $ref_item{'id'} = $hash;
2424 $ref_item{'title'} = $title || '(no commit message)';
2425 $ref_item{'epoch'} = $epoch;
2427 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2429 $ref_item{'age'} = "unknown";
2432 push @headslist, \
%ref_item;
2436 return wantarray ?
@headslist : \
@headslist;
2439 sub git_get_tags_list
{
2443 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2444 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
2445 '--format=%(objectname) %(objecttype) %(refname) '.
2446 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
2449 while (my $line = <$fd>) {
2453 my ($refinfo, $creatorinfo) = split(/\0/, $line);
2454 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
2455 my ($creator, $epoch, $tz) =
2456 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
2457 $ref_item{'fullname'} = $name;
2458 $name =~ s!^refs/tags/!!;
2460 $ref_item{'type'} = $type;
2461 $ref_item{'id'} = $id;
2462 $ref_item{'name'} = $name;
2463 if ($type eq "tag") {
2464 $ref_item{'subject'} = $title;
2465 $ref_item{'reftype'} = $reftype;
2466 $ref_item{'refid'} = $refid;
2468 $ref_item{'reftype'} = $type;
2469 $ref_item{'refid'} = $id;
2472 if ($type eq "tag" || $type eq "commit") {
2473 $ref_item{'epoch'} = $epoch;
2475 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2477 $ref_item{'age'} = "unknown";
2481 push @tagslist, \
%ref_item;
2485 return wantarray ?
@tagslist : \
@tagslist;
2488 ## ----------------------------------------------------------------------
2489 ## filesystem-related functions
2491 sub get_file_owner
{
2494 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
2495 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
2496 if (!defined $gcos) {
2500 $owner =~ s/[,;].*$//;
2501 return to_utf8
($owner);
2504 ## ......................................................................
2505 ## mimetype related functions
2507 sub mimetype_guess_file
{
2508 my $filename = shift;
2509 my $mimemap = shift;
2510 -r
$mimemap or return undef;
2513 open(MIME
, $mimemap) or return undef;
2515 next if m/^#/; # skip comments
2516 my ($mime, $exts) = split(/\t+/);
2517 if (defined $exts) {
2518 my @exts = split(/\s+/, $exts);
2519 foreach my $ext (@exts) {
2520 $mimemap{$ext} = $mime;
2526 $filename =~ /\.([^.]*)$/;
2527 return $mimemap{$1};
2530 sub mimetype_guess
{
2531 my $filename = shift;
2533 $filename =~ /\./ or return undef;
2535 if ($mimetypes_file) {
2536 my $file = $mimetypes_file;
2537 if ($file !~ m!^/!) { # if it is relative path
2538 # it is relative to project
2539 $file = "$projectroot/$project/$file";
2541 $mime = mimetype_guess_file
($filename, $file);
2543 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
2549 my $filename = shift;
2552 my $mime = mimetype_guess
($filename);
2553 $mime and return $mime;
2557 return $default_blob_plain_mimetype unless $fd;
2560 return 'text/plain';
2561 } elsif (! $filename) {
2562 return 'application/octet-stream';
2563 } elsif ($filename =~ m/\.png$/i) {
2565 } elsif ($filename =~ m/\.gif$/i) {
2567 } elsif ($filename =~ m/\.jpe?g$/i) {
2568 return 'image/jpeg';
2570 return 'application/octet-stream';
2574 sub blob_contenttype
{
2575 my ($fd, $file_name, $type) = @_;
2577 $type ||= blob_mimetype
($fd, $file_name);
2578 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
2579 $type .= "; charset=$default_text_plain_charset";
2585 ## ======================================================================
2586 ## functions printing HTML: header, footer, error page
2588 sub git_header_html
{
2589 my $status = shift || "200 OK";
2590 my $expires = shift;
2592 my $title = "$site_name";
2593 if (defined $project) {
2594 $title .= " - " . to_utf8
($project);
2595 if (defined $action) {
2596 $title .= "/$action";
2597 if (defined $file_name) {
2598 $title .= " - " . esc_path
($file_name);
2599 if ($action eq "tree" && $file_name !~ m
|/$|) {
2606 # require explicit support from the UA if we are to send the page as
2607 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
2608 # we have to do this because MSIE sometimes globs '*/*', pretending to
2609 # support xhtml+xml but choking when it gets what it asked for.
2610 if (defined $cgi->http('HTTP_ACCEPT') &&
2611 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
2612 $cgi->Accept('application/xhtml+xml') != 0) {
2613 $content_type = 'application/xhtml+xml';
2615 $content_type = 'text/html';
2617 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
2618 -status
=> $status, -expires
=> $expires);
2619 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
2621 <?xml version="1.0" encoding="utf-8"?>
2622 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2623 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
2624 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
2625 <!-- git core binaries version $git_version -->
2627 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
2628 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
2629 <meta name="robots" content="index, nofollow"/>
2630 <title>$title</title>
2632 # print out each stylesheet that exist
2633 if (defined $stylesheet) {
2634 #provides backwards capability for those people who define style sheet in a config file
2635 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2637 foreach my $stylesheet (@stylesheets) {
2638 next unless $stylesheet;
2639 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2642 if (defined $project) {
2643 my %href_params = get_feed_info
();
2644 if (!exists $href_params{'-title'}) {
2645 $href_params{'-title'} = 'log';
2648 foreach my $format qw(RSS Atom) {
2649 my $type = lc($format);
2651 '-rel' => 'alternate',
2652 '-title' => "$project - $href_params{'-title'} - $format feed",
2653 '-type' => "application/$type+xml"
2656 $href_params{'action'} = $type;
2657 $link_attr{'-href'} = href
(%href_params);
2659 "rel=\"$link_attr{'-rel'}\" ".
2660 "title=\"$link_attr{'-title'}\" ".
2661 "href=\"$link_attr{'-href'}\" ".
2662 "type=\"$link_attr{'-type'}\" ".
2665 $href_params{'extra_options'} = '--no-merges';
2666 $link_attr{'-href'} = href
(%href_params);
2667 $link_attr{'-title'} .= ' (no merges)';
2669 "rel=\"$link_attr{'-rel'}\" ".
2670 "title=\"$link_attr{'-title'}\" ".
2671 "href=\"$link_attr{'-href'}\" ".
2672 "type=\"$link_attr{'-type'}\" ".
2677 printf('<link rel="alternate" title="%s projects list" '.
2678 'href="%s" type="text/plain; charset=utf-8" />'."\n",
2679 $site_name, href
(project
=>undef, action
=>"project_index"));
2680 printf('<link rel="alternate" title="%s projects feeds" '.
2681 'href="%s" type="text/x-opml" />'."\n",
2682 $site_name, href
(project
=>undef, action
=>"opml"));
2684 if (defined $favicon) {
2685 print qq(<link rel
="shortcut icon" href
="$favicon" type
="image/png" />\n);
2691 if (-f
$site_header) {
2692 open (my $fd, $site_header);
2697 print "<div class=\"page_header\">\n" .
2698 $cgi->a({-href
=> esc_url
($logo_url),
2699 -title
=> $logo_label},
2700 qq(<img src
="$logo" width
="72" height
="27" alt
="git" class="logo"/>));
2701 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
2702 if (defined $project) {
2703 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
2704 if (defined $action) {
2711 my ($have_search) = gitweb_check_feature
('search');
2712 if (defined $project && $have_search) {
2713 if (!defined $searchtext) {
2717 if (defined $hash_base) {
2718 $search_hash = $hash_base;
2719 } elsif (defined $hash) {
2720 $search_hash = $hash;
2722 $search_hash = "HEAD";
2724 my $action = $my_uri;
2725 my ($use_pathinfo) = gitweb_check_feature
('pathinfo');
2726 if ($use_pathinfo) {
2727 $action .= "/".esc_url
($project);
2729 print $cgi->startform(-method
=> "get", -action
=> $action) .
2730 "<div class=\"search\">\n" .
2732 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
2733 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
2734 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
2735 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
2736 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
2737 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
2739 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
2740 "<span title=\"Extended regular expression\">" .
2741 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
2742 -checked
=> $search_use_regexp) .
2745 $cgi->end_form() . "\n";
2749 sub git_footer_html
{
2750 my $feed_class = 'rss_logo';
2752 print "<div class=\"page_footer\">\n";
2753 if (defined $project) {
2754 my $descr = git_get_project_description
($project);
2755 if (defined $descr) {
2756 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
2759 my %href_params = get_feed_info
();
2760 if (!%href_params) {
2761 $feed_class .= ' generic';
2763 $href_params{'-title'} ||= 'log';
2765 foreach my $format qw(RSS Atom) {
2766 $href_params{'action'} = lc($format);
2767 print $cgi->a({-href
=> href
(%href_params),
2768 -title
=> "$href_params{'-title'} $format feed",
2769 -class => $feed_class}, $format)."\n";
2773 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
2774 -class => $feed_class}, "OPML") . " ";
2775 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
2776 -class => $feed_class}, "TXT") . "\n";
2778 print "</div>\n"; # class="page_footer"
2780 if (-f
$site_footer) {
2781 open (my $fd, $site_footer);
2790 # die_error(<http_status_code>, <error_message>)
2791 # Example: die_error(404, 'Hash not found')
2792 # By convention, use the following status codes (as defined in RFC 2616):
2793 # 400: Invalid or missing CGI parameters, or
2794 # requested object exists but has wrong type.
2795 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
2796 # this server or project.
2797 # 404: Requested object/revision/project doesn't exist.
2798 # 500: The server isn't configured properly, or
2799 # an internal error occurred (e.g. failed assertions caused by bugs), or
2800 # an unknown error occurred (e.g. the git binary died unexpectedly).
2802 my $status = shift || 500;
2803 my $error = shift || "Internal server error";
2805 my %http_responses = (400 => '400 Bad Request',
2806 403 => '403 Forbidden',
2807 404 => '404 Not Found',
2808 500 => '500 Internal Server Error');
2809 git_header_html
($http_responses{$status});
2811 <div class="page_body">
2821 ## ----------------------------------------------------------------------
2822 ## functions printing or outputting HTML: navigation
2824 sub git_print_page_nav
{
2825 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
2826 $extra = '' if !defined $extra; # pager or formats
2828 my @navs = qw(summary shortlog log commit commitdiff tree);
2830 @navs = grep { $_ ne $suppress } @navs;
2833 my %arg = map { $_ => {action
=>$_} } @navs;
2834 if (defined $head) {
2835 for (qw(commit commitdiff)) {
2836 $arg{$_}{'hash'} = $head;
2838 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
2839 for (qw(shortlog log)) {
2840 $arg{$_}{'hash'} = $head;
2844 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
2845 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
2847 print "<div class=\"page_nav\">\n" .
2849 map { $_ eq $current ?
2850 $_ : $cgi->a({-href
=> href
(%{$arg{$_}})}, "$_")
2852 print "<br/>\n$extra<br/>\n" .
2856 sub format_paging_nav
{
2857 my ($action, $hash, $head, $page, $has_next_link) = @_;
2861 if ($hash ne $head || $page) {
2862 $paging_nav .= $cgi->a({-href
=> href
(action
=>$action)}, "HEAD");
2864 $paging_nav .= "HEAD";
2868 $paging_nav .= " ⋅ " .
2869 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
2870 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
2872 $paging_nav .= " ⋅ prev";
2875 if ($has_next_link) {
2876 $paging_nav .= " ⋅ " .
2877 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
2878 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
2880 $paging_nav .= " ⋅ next";
2886 ## ......................................................................
2887 ## functions printing or outputting HTML: div
2889 sub git_print_header_div
{
2890 my ($action, $title, $hash, $hash_base) = @_;
2893 $args{'action'} = $action;
2894 $args{'hash'} = $hash if $hash;
2895 $args{'hash_base'} = $hash_base if $hash_base;
2897 print "<div class=\"header\">\n" .
2898 $cgi->a({-href
=> href
(%args), -class => "title"},
2899 $title ?
$title : $action) .
2903 #sub git_print_authorship (\%) {
2904 sub git_print_authorship
{
2907 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
2908 print "<div class=\"author_date\">" .
2909 esc_html
($co->{'author_name'}) .
2911 if ($ad{'hour_local'} < 6) {
2912 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
2913 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
2915 printf(" (%02d:%02d %s)",
2916 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
2921 sub git_print_page_path
{
2927 print "<div class=\"page_path\">";
2928 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
2929 -title
=> 'tree root'}, to_utf8
("[$project]"));
2931 if (defined $name) {
2932 my @dirname = split '/', $name;
2933 my $basename = pop @dirname;
2936 foreach my $dir (@dirname) {
2937 $fullname .= ($fullname ?
'/' : '') . $dir;
2938 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
2940 -title
=> $fullname}, esc_path
($dir));
2943 if (defined $type && $type eq 'blob') {
2944 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
2946 -title
=> $name}, esc_path
($basename));
2947 } elsif (defined $type && $type eq 'tree') {
2948 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
2950 -title
=> $name}, esc_path
($basename));
2953 print esc_path
($basename);
2956 print "<br/></div>\n";
2959 # sub git_print_log (\@;%) {
2960 sub git_print_log
($;%) {
2964 if ($opts{'-remove_title'}) {
2965 # remove title, i.e. first line of log
2968 # remove leading empty lines
2969 while (defined $log->[0] && $log->[0] eq "") {
2976 foreach my $line (@
$log) {
2977 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
2980 if (! $opts{'-remove_signoff'}) {
2981 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
2984 # remove signoff lines
2991 # print only one empty line
2992 # do not print empty line after signoff
2994 next if ($empty || $signoff);
3000 print format_log_line_html
($line) . "<br/>\n";
3003 if ($opts{'-final_empty_line'}) {
3004 # end with single empty line
3005 print "<br/>\n" unless $empty;
3009 # return link target (what link points to)
3010 sub git_get_link_target
{
3015 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
3019 $link_target = <$fd>;
3024 return $link_target;
3027 # given link target, and the directory (basedir) the link is in,
3028 # return target of link relative to top directory (top tree);
3029 # return undef if it is not possible (including absolute links).
3030 sub normalize_link_target
{
3031 my ($link_target, $basedir, $hash_base) = @_;
3033 # we can normalize symlink target only if $hash_base is provided
3034 return unless $hash_base;
3036 # absolute symlinks (beginning with '/') cannot be normalized
3037 return if (substr($link_target, 0, 1) eq '/');
3039 # normalize link target to path from top (root) tree (dir)
3042 $path = $basedir . '/' . $link_target;
3044 # we are in top (root) tree (dir)
3045 $path = $link_target;
3048 # remove //, /./, and /../
3050 foreach my $part (split('/', $path)) {
3051 # discard '.' and ''
3052 next if (!$part || $part eq '.');
3054 if ($part eq '..') {
3058 # link leads outside repository (outside top dir)
3062 push @path_parts, $part;
3065 $path = join('/', @path_parts);
3070 # print tree entry (row of git_tree), but without encompassing <tr> element
3071 sub git_print_tree_entry
{
3072 my ($t, $basedir, $hash_base, $have_blame) = @_;
3075 $base_key{'hash_base'} = $hash_base if defined $hash_base;
3077 # The format of a table row is: mode list link. Where mode is
3078 # the mode of the entry, list is the name of the entry, an href,
3079 # and link is the action links of the entry.
3081 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
3082 if ($t->{'type'} eq "blob") {
3083 print "<td class=\"list\">" .
3084 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3085 file_name
=>"$basedir$t->{'name'}", %base_key),
3086 -class => "list"}, esc_path
($t->{'name'}));
3087 if (S_ISLNK
(oct $t->{'mode'})) {
3088 my $link_target = git_get_link_target
($t->{'hash'});
3090 my $norm_target = normalize_link_target
($link_target, $basedir, $hash_base);
3091 if (defined $norm_target) {
3093 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
3094 file_name
=>$norm_target),
3095 -title
=> $norm_target}, esc_path
($link_target));
3097 print " -> " . esc_path
($link_target);
3102 print "<td class=\"link\">";
3103 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3104 file_name
=>"$basedir$t->{'name'}", %base_key)},
3108 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
3109 file_name
=>"$basedir$t->{'name'}", %base_key)},
3112 if (defined $hash_base) {
3114 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3115 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
3119 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
3120 file_name
=>"$basedir$t->{'name'}")},
3124 } elsif ($t->{'type'} eq "tree") {
3125 print "<td class=\"list\">";
3126 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3127 file_name
=>"$basedir$t->{'name'}", %base_key)},
3128 esc_path
($t->{'name'}));
3130 print "<td class=\"link\">";
3131 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3132 file_name
=>"$basedir$t->{'name'}", %base_key)},
3134 if (defined $hash_base) {
3136 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3137 file_name
=>"$basedir$t->{'name'}")},
3142 # unknown object: we can only present history for it
3143 # (this includes 'commit' object, i.e. submodule support)
3144 print "<td class=\"list\">" .
3145 esc_path
($t->{'name'}) .
3147 print "<td class=\"link\">";
3148 if (defined $hash_base) {
3149 print $cgi->a({-href
=> href
(action
=>"history",
3150 hash_base
=>$hash_base,
3151 file_name
=>"$basedir$t->{'name'}")},
3158 ## ......................................................................
3159 ## functions printing large fragments of HTML
3161 # get pre-image filenames for merge (combined) diff
3162 sub fill_from_file_info
{
3163 my ($diff, @parents) = @_;
3165 $diff->{'from_file'} = [ ];
3166 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
3167 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3168 if ($diff->{'status'}[$i] eq 'R' ||
3169 $diff->{'status'}[$i] eq 'C') {
3170 $diff->{'from_file'}[$i] =
3171 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
3178 # is current raw difftree line of file deletion
3180 my $diffinfo = shift;
3182 return $diffinfo->{'to_id'} eq ('0' x
40);
3185 # does patch correspond to [previous] difftree raw line
3186 # $diffinfo - hashref of parsed raw diff format
3187 # $patchinfo - hashref of parsed patch diff format
3188 # (the same keys as in $diffinfo)
3189 sub is_patch_split
{
3190 my ($diffinfo, $patchinfo) = @_;
3192 return defined $diffinfo && defined $patchinfo
3193 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
3197 sub git_difftree_body
{
3198 my ($difftree, $hash, @parents) = @_;
3199 my ($parent) = $parents[0];
3200 my ($have_blame) = gitweb_check_feature
('blame');
3201 print "<div class=\"list_head\">\n";
3202 if ($#{$difftree} > 10) {
3203 print(($#{$difftree} + 1) . " files changed:\n");
3207 print "<table class=\"" .
3208 (@parents > 1 ?
"combined " : "") .
3211 # header only for combined diff in 'commitdiff' view
3212 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
3215 print "<thead><tr>\n" .
3216 "<th></th><th></th>\n"; # filename, patchN link
3217 for (my $i = 0; $i < @parents; $i++) {
3218 my $par = $parents[$i];
3220 $cgi->a({-href
=> href
(action
=>"commitdiff",
3221 hash
=>$hash, hash_parent
=>$par),
3222 -title
=> 'commitdiff to parent number ' .
3223 ($i+1) . ': ' . substr($par,0,7)},
3227 print "</tr></thead>\n<tbody>\n";
3232 foreach my $line (@
{$difftree}) {
3233 my $diff = parsed_difftree_line
($line);
3236 print "<tr class=\"dark\">\n";
3238 print "<tr class=\"light\">\n";
3242 if (exists $diff->{'nparents'}) { # combined diff
3244 fill_from_file_info
($diff, @parents)
3245 unless exists $diff->{'from_file'};
3247 if (!is_deleted
($diff)) {
3248 # file exists in the result (child) commit
3250 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3251 file_name
=>$diff->{'to_file'},
3253 -class => "list"}, esc_path
($diff->{'to_file'})) .
3257 esc_path
($diff->{'to_file'}) .
3261 if ($action eq 'commitdiff') {
3264 print "<td class=\"link\">" .
3265 $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3270 my $has_history = 0;
3271 my $not_deleted = 0;
3272 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3273 my $hash_parent = $parents[$i];
3274 my $from_hash = $diff->{'from_id'}[$i];
3275 my $from_path = $diff->{'from_file'}[$i];
3276 my $status = $diff->{'status'}[$i];
3278 $has_history ||= ($status ne 'A');
3279 $not_deleted ||= ($status ne 'D');
3281 if ($status eq 'A') {
3282 print "<td class=\"link\" align=\"right\"> | </td>\n";
3283 } elsif ($status eq 'D') {
3284 print "<td class=\"link\">" .
3285 $cgi->a({-href
=> href
(action
=>"blob",
3288 file_name
=>$from_path)},
3292 if ($diff->{'to_id'} eq $from_hash) {
3293 print "<td class=\"link nochange\">";
3295 print "<td class=\"link\">";
3297 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3298 hash
=>$diff->{'to_id'},
3299 hash_parent
=>$from_hash,
3301 hash_parent_base
=>$hash_parent,
3302 file_name
=>$diff->{'to_file'},
3303 file_parent
=>$from_path)},
3309 print "<td class=\"link\">";
3311 print $cgi->a({-href
=> href
(action
=>"blob",
3312 hash
=>$diff->{'to_id'},
3313 file_name
=>$diff->{'to_file'},
3316 print " | " if ($has_history);
3319 print $cgi->a({-href
=> href
(action
=>"history",
3320 file_name
=>$diff->{'to_file'},
3327 next; # instead of 'else' clause, to avoid extra indent
3329 # else ordinary diff
3331 my ($to_mode_oct, $to_mode_str, $to_file_type);
3332 my ($from_mode_oct, $from_mode_str, $from_file_type);
3333 if ($diff->{'to_mode'} ne ('0' x
6)) {
3334 $to_mode_oct = oct $diff->{'to_mode'};
3335 if (S_ISREG
($to_mode_oct)) { # only for regular file
3336 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
3338 $to_file_type = file_type
($diff->{'to_mode'});
3340 if ($diff->{'from_mode'} ne ('0' x
6)) {
3341 $from_mode_oct = oct $diff->{'from_mode'};
3342 if (S_ISREG
($to_mode_oct)) { # only for regular file
3343 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
3345 $from_file_type = file_type
($diff->{'from_mode'});
3348 if ($diff->{'status'} eq "A") { # created
3349 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
3350 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
3351 $mode_chng .= "]</span>";
3353 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3354 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3355 -class => "list"}, esc_path
($diff->{'file'}));
3357 print "<td>$mode_chng</td>\n";
3358 print "<td class=\"link\">";
3359 if ($action eq 'commitdiff') {
3362 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3365 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3366 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3370 } elsif ($diff->{'status'} eq "D") { # deleted
3371 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
3373 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3374 hash_base
=>$parent, file_name
=>$diff->{'file'}),
3375 -class => "list"}, esc_path
($diff->{'file'}));
3377 print "<td>$mode_chng</td>\n";
3378 print "<td class=\"link\">";
3379 if ($action eq 'commitdiff') {
3382 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3385 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3386 hash_base
=>$parent, file_name
=>$diff->{'file'})},
3389 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
3390 file_name
=>$diff->{'file'})},
3393 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
3394 file_name
=>$diff->{'file'})},
3398 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
3399 my $mode_chnge = "";
3400 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3401 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
3402 if ($from_file_type ne $to_file_type) {
3403 $mode_chnge .= " from $from_file_type to $to_file_type";
3405 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
3406 if ($from_mode_str && $to_mode_str) {
3407 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
3408 } elsif ($to_mode_str) {
3409 $mode_chnge .= " mode: $to_mode_str";
3412 $mode_chnge .= "]</span>\n";
3415 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3416 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3417 -class => "list"}, esc_path
($diff->{'file'}));
3419 print "<td>$mode_chnge</td>\n";
3420 print "<td class=\"link\">";
3421 if ($action eq 'commitdiff') {
3424 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3426 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3427 # "commit" view and modified file (not onlu mode changed)
3428 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3429 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3430 hash_base
=>$hash, hash_parent_base
=>$parent,
3431 file_name
=>$diff->{'file'})},
3435 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3436 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3439 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3440 file_name
=>$diff->{'file'})},
3443 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3444 file_name
=>$diff->{'file'})},
3448 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
3449 my %status_name = ('R' => 'moved', 'C' => 'copied');
3450 my $nstatus = $status_name{$diff->{'status'}};
3452 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3453 # mode also for directories, so we cannot use $to_mode_str
3454 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
3457 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
3458 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
3459 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
3460 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
3461 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
3462 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
3463 -class => "list"}, esc_path
($diff->{'from_file'})) .
3464 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
3465 "<td class=\"link\">";
3466 if ($action eq 'commitdiff') {
3469 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3471 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3472 # "commit" view and modified file (not only pure rename or copy)
3473 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3474 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3475 hash_base
=>$hash, hash_parent_base
=>$parent,
3476 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
3480 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3481 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
3484 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3485 file_name
=>$diff->{'to_file'})},
3488 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3489 file_name
=>$diff->{'to_file'})},
3493 } # we should not encounter Unmerged (U) or Unknown (X) status
3496 print "</tbody>" if $has_header;
3500 sub git_patchset_body
{
3501 my ($fd, $difftree, $hash, @hash_parents) = @_;
3502 my ($hash_parent) = $hash_parents[0];
3504 my $is_combined = (@hash_parents > 1);
3506 my $patch_number = 0;
3512 print "<div class=\"patchset\">\n";
3514 # skip to first patch
3515 while ($patch_line = <$fd>) {
3518 last if ($patch_line =~ m/^diff /);
3522 while ($patch_line) {
3524 # parse "git diff" header line
3525 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
3526 # $1 is from_name, which we do not use
3527 $to_name = unquote
($2);
3528 $to_name =~ s!^b/!!;
3529 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
3530 # $1 is 'cc' or 'combined', which we do not use
3531 $to_name = unquote
($2);
3536 # check if current patch belong to current raw line
3537 # and parse raw git-diff line if needed
3538 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
3539 # this is continuation of a split patch
3540 print "<div class=\"patch cont\">\n";
3542 # advance raw git-diff output if needed
3543 $patch_idx++ if defined $diffinfo;
3545 # read and prepare patch information
3546 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3548 # compact combined diff output can have some patches skipped
3549 # find which patch (using pathname of result) we are at now;
3551 while ($to_name ne $diffinfo->{'to_file'}) {
3552 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3553 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3554 "</div>\n"; # class="patch"
3559 last if $patch_idx > $#$difftree;
3560 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3564 # modifies %from, %to hashes
3565 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
3567 # this is first patch for raw difftree line with $patch_idx index
3568 # we index @$difftree array from 0, but number patches from 1
3569 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
3573 #assert($patch_line =~ m/^diff /) if DEBUG;
3574 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
3576 # print "git diff" header
3577 print format_git_diff_header_line
($patch_line, $diffinfo,
3580 # print extended diff header
3581 print "<div class=\"diff extended_header\">\n";
3583 while ($patch_line = <$fd>) {
3586 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
3588 print format_extended_diff_header_line
($patch_line, $diffinfo,
3591 print "</div>\n"; # class="diff extended_header"
3593 # from-file/to-file diff header
3594 if (! $patch_line) {
3595 print "</div>\n"; # class="patch"
3598 next PATCH
if ($patch_line =~ m/^diff /);
3599 #assert($patch_line =~ m/^---/) if DEBUG;
3601 my $last_patch_line = $patch_line;
3602 $patch_line = <$fd>;
3604 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
3606 print format_diff_from_to_header
($last_patch_line, $patch_line,
3607 $diffinfo, \
%from, \
%to,
3612 while ($patch_line = <$fd>) {
3615 next PATCH
if ($patch_line =~ m/^diff /);
3617 print format_diff_line
($patch_line, \
%from, \
%to);
3621 print "</div>\n"; # class="patch"
3624 # for compact combined (--cc) format, with chunk and patch simpliciaction
3625 # patchset might be empty, but there might be unprocessed raw lines
3626 for (++$patch_idx if $patch_number > 0;
3627 $patch_idx < @
$difftree;
3629 # read and prepare patch information
3630 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3632 # generate anchor for "patch" links in difftree / whatchanged part
3633 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3634 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3635 "</div>\n"; # class="patch"
3640 if ($patch_number == 0) {
3641 if (@hash_parents > 1) {
3642 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
3644 print "<div class=\"diff nodifferences\">No differences found</div>\n";
3648 print "</div>\n"; # class="patchset"
3651 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3653 # fills project list info (age, description, owner, forks) for each
3654 # project in the list, removing invalid projects from returned list
3655 # NOTE: modifies $projlist, but does not remove entries from it
3656 sub fill_project_list_info
{
3657 my ($projlist, $check_forks) = @_;
3660 my $show_ctags = gitweb_check_feature
('ctags');
3662 foreach my $pr (@
$projlist) {
3663 my (@activity) = git_get_last_activity
($pr->{'path'});
3664 unless (@activity) {
3667 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
3668 if (!defined $pr->{'descr'}) {
3669 my $descr = git_get_project_description
($pr->{'path'}) || "";
3670 $descr = to_utf8
($descr);
3671 $pr->{'descr_long'} = $descr;
3672 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
3674 if (!defined $pr->{'owner'}) {
3675 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
3678 my $pname = $pr->{'path'};
3679 if (($pname =~ s/\.git$//) &&
3680 ($pname !~ /\/$/) &&
3681 (-d
"$projectroot/$pname")) {
3682 $pr->{'forks'} = "-d $projectroot/$pname";
3687 $show_ctags and $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
3688 push @projects, $pr;
3694 # print 'sort by' <th> element, either sorting by $key if $name eq $order
3695 # (changing $list), or generating 'sort by $name' replay link otherwise
3697 my ($str_sort, $name, $order, $key, $header, $list) = @_;
3699 $header ||= ucfirst($name);
3701 if ($order eq $name) {
3703 @
$list = sort {$a->{$key} cmp $b->{$key}} @
$list;
3705 @
$list = sort {$a->{$key} <=> $b->{$key}} @
$list;
3707 print "<th>$header</th>\n";
3710 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
3711 -class => "header"}, $header) .
3716 sub print_sort_th_str
{
3717 print_sort_th
(1, @_);
3720 sub print_sort_th_num
{
3721 print_sort_th
(0, @_);
3724 sub git_project_list_body
{
3725 # actually uses global variable $project
3726 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
3728 my ($check_forks) = gitweb_check_feature
('forks');
3729 my @projects = fill_project_list_info
($projlist, $check_forks);
3731 $order ||= $default_projects_order;
3732 $from = 0 unless defined $from;
3733 $to = $#projects if (!defined $to || $#projects < $to);
3735 my $show_ctags = gitweb_check_feature
('ctags');
3738 foreach my $p (@projects) {
3739 foreach my $ct (keys %{$p->{'ctags'}}) {
3740 $ctags{$ct} += $p->{'ctags'}->{$ct};
3743 my $cloud = git_populate_project_tagcloud
(\
%ctags);
3744 print git_show_project_tagcloud
($cloud, 64);
3747 print "<table class=\"project_list\">\n";
3748 unless ($no_header) {
3751 print "<th></th>\n";
3753 print_sort_th_str
('project', $order, 'path',
3754 'Project', \
@projects);
3755 print_sort_th_str
('descr', $order, 'descr_long',
3756 'Description', \
@projects);
3757 print_sort_th_str
('owner', $order, 'owner',
3758 'Owner', \
@projects);
3759 print_sort_th_num
('age', $order, 'age',
3760 'Last Change', \
@projects);
3761 print "<th></th>\n" . # for links
3765 my $tagfilter = $cgi->param('by_tag');
3766 for (my $i = $from; $i <= $to; $i++) {
3767 my $pr = $projects[$i];
3769 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
3772 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s
#\.git$#/#;
3773 $forkbase="^$forkbase" if $forkbase;
3774 next if not $tagfilter and $pr->{'path'} =~ m
#$forkbase.*/.*#; # regexp-safe
3778 print "<tr class=\"dark\">\n";
3780 print "<tr class=\"light\">\n";
3785 if ($pr->{'forks'}) {
3786 print "<!-- $pr->{'forks'} -->\n";
3787 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "+");
3791 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
3792 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
3793 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
3794 -class => "list", -title
=> $pr->{'descr_long'}},
3795 esc_html
($pr->{'descr'})) . "</td>\n" .
3796 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
3797 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
3798 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
3799 "<td class=\"link\">" .
3800 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
3801 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
3802 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
3803 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
3804 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
3808 if (defined $extra) {
3811 print "<td></td>\n";
3813 print "<td colspan=\"5\">$extra</td>\n" .
3819 sub git_shortlog_body
{
3820 # uses global variable $project
3821 my ($commitlist, $from, $to, $refs, $extra) = @_;
3823 $from = 0 unless defined $from;
3824 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
3826 print "<table class=\"shortlog\">\n";
3828 for (my $i = $from; $i <= $to; $i++) {
3829 my %co = %{$commitlist->[$i]};
3830 my $commit = $co{'id'};
3831 my $ref = format_ref_marker
($refs, $commit);
3833 print "<tr class=\"dark\">\n";
3835 print "<tr class=\"light\">\n";
3838 my $author = chop_and_escape_str
($co{'author_name'}, 10);
3839 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
3840 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
3841 "<td><i>" . $author . "</i></td>\n" .
3843 print format_subject_html
($co{'title'}, $co{'title_short'},
3844 href
(action
=>"commit", hash
=>$commit), $ref);
3846 "<td class=\"link\">" .
3847 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
3848 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
3849 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
3850 my $snapshot_links = format_snapshot_links
($commit);
3851 if (defined $snapshot_links) {
3852 print " | " . $snapshot_links;
3857 if (defined $extra) {
3859 "<td colspan=\"4\">$extra</td>\n" .
3865 sub git_history_body
{
3866 # Warning: assumes constant type (blob or tree) during history
3867 my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
3869 $from = 0 unless defined $from;
3870 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
3872 print "<table class=\"history\">\n";
3874 for (my $i = $from; $i <= $to; $i++) {
3875 my %co = %{$commitlist->[$i]};
3879 my $commit = $co{'id'};
3881 my $ref = format_ref_marker
($refs, $commit);
3884 print "<tr class=\"dark\">\n";
3886 print "<tr class=\"light\">\n";
3889 # shortlog uses chop_str($co{'author_name'}, 10)
3890 my $author = chop_and_escape_str
($co{'author_name'}, 15, 3);
3891 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
3892 "<td><i>" . $author . "</i></td>\n" .
3894 # originally git_history used chop_str($co{'title'}, 50)
3895 print format_subject_html
($co{'title'}, $co{'title_short'},
3896 href
(action
=>"commit", hash
=>$commit), $ref);
3898 "<td class=\"link\">" .
3899 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
3900 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
3902 if ($ftype eq 'blob') {
3903 my $blob_current = git_get_hash_by_path
($hash_base, $file_name);
3904 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
3905 if (defined $blob_current && defined $blob_parent &&
3906 $blob_current ne $blob_parent) {
3908 $cgi->a({-href
=> href
(action
=>"blobdiff",
3909 hash
=>$blob_current, hash_parent
=>$blob_parent,
3910 hash_base
=>$hash_base, hash_parent_base
=>$commit,
3911 file_name
=>$file_name)},
3918 if (defined $extra) {
3920 "<td colspan=\"4\">$extra</td>\n" .
3927 # uses global variable $project
3928 my ($taglist, $from, $to, $extra) = @_;
3929 $from = 0 unless defined $from;
3930 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
3932 print "<table class=\"tags\">\n";
3934 for (my $i = $from; $i <= $to; $i++) {
3935 my $entry = $taglist->[$i];
3937 my $comment = $tag{'subject'};
3939 if (defined $comment) {
3940 $comment_short = chop_str
($comment, 30, 5);
3943 print "<tr class=\"dark\">\n";
3945 print "<tr class=\"light\">\n";
3948 if (defined $tag{'age'}) {
3949 print "<td><i>$tag{'age'}</i></td>\n";
3951 print "<td></td>\n";
3954 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
3955 -class => "list name"}, esc_html
($tag{'name'})) .
3958 if (defined $comment) {
3959 print format_subject_html
($comment, $comment_short,
3960 href
(action
=>"tag", hash
=>$tag{'id'}));
3963 "<td class=\"selflink\">";
3964 if ($tag{'type'} eq "tag") {
3965 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
3970 "<td class=\"link\">" . " | " .
3971 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
3972 if ($tag{'reftype'} eq "commit") {
3973 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
3974 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
3975 } elsif ($tag{'reftype'} eq "blob") {
3976 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
3981 if (defined $extra) {
3983 "<td colspan=\"5\">$extra</td>\n" .
3989 sub git_heads_body
{
3990 # uses global variable $project
3991 my ($headlist, $head, $from, $to, $extra) = @_;
3992 $from = 0 unless defined $from;
3993 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
3995 print "<table class=\"heads\">\n";
3997 for (my $i = $from; $i <= $to; $i++) {
3998 my $entry = $headlist->[$i];
4000 my $curr = $ref{'id'} eq $head;
4002 print "<tr class=\"dark\">\n";
4004 print "<tr class=\"light\">\n";
4007 print "<td><i>$ref{'age'}</i></td>\n" .
4008 ($curr ?
"<td class=\"current_head\">" : "<td>") .
4009 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
4010 -class => "list name"},esc_html
($ref{'name'})) .
4012 "<td class=\"link\">" .
4013 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
4014 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
4015 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'name'})}, "tree") .
4019 if (defined $extra) {
4021 "<td colspan=\"3\">$extra</td>\n" .
4027 sub git_search_grep_body
{
4028 my ($commitlist, $from, $to, $extra) = @_;
4029 $from = 0 unless defined $from;
4030 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4032 print "<table class=\"commit_search\">\n";
4034 for (my $i = $from; $i <= $to; $i++) {
4035 my %co = %{$commitlist->[$i]};
4039 my $commit = $co{'id'};
4041 print "<tr class=\"dark\">\n";
4043 print "<tr class=\"light\">\n";
4046 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
4047 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4048 "<td><i>" . $author . "</i></td>\n" .
4050 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
4051 -class => "list subject"},
4052 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
4053 my $comment = $co{'comment'};
4054 foreach my $line (@
$comment) {
4055 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
4056 my ($lead, $match, $trail) = ($1, $2, $3);
4057 $match = chop_str
($match, 70, 5, 'center');
4058 my $contextlen = int((80 - length($match))/2);
4059 $contextlen = 30 if ($contextlen > 30);
4060 $lead = chop_str
($lead, $contextlen, 10, 'left');
4061 $trail = chop_str
($trail, $contextlen, 10, 'right');
4063 $lead = esc_html
($lead);
4064 $match = esc_html
($match);
4065 $trail = esc_html
($trail);
4067 print "$lead<span class=\"match\">$match</span>$trail<br />";
4071 "<td class=\"link\">" .
4072 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
4074 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
4076 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
4080 if (defined $extra) {
4082 "<td colspan=\"3\">$extra</td>\n" .
4088 ## ======================================================================
4089 ## ======================================================================
4092 sub git_project_list
{
4093 my $order = $cgi->param('o');
4094 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4095 die_error
(400, "Unknown order parameter");
4098 my @list = git_get_projects_list
();
4100 die_error
(404, "No projects found");
4104 if (-f
$home_text) {
4105 print "<div class=\"index_include\">\n";
4106 open (my $fd, $home_text);
4111 git_project_list_body
(\
@list, $order);
4116 my $order = $cgi->param('o');
4117 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4118 die_error
(400, "Unknown order parameter");
4121 my @list = git_get_projects_list
($project);
4123 die_error
(404, "No forks found");
4127 git_print_page_nav
('','');
4128 git_print_header_div
('summary', "$project forks");
4129 git_project_list_body
(\
@list, $order);
4133 sub git_project_index
{
4134 my @projects = git_get_projects_list
($project);
4137 -type
=> 'text/plain',
4138 -charset
=> 'utf-8',
4139 -content_disposition
=> 'inline; filename="index.aux"');
4141 foreach my $pr (@projects) {
4142 if (!exists $pr->{'owner'}) {
4143 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
4146 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
4147 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
4148 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4149 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4153 print "$path $owner\n";
4158 my $descr = git_get_project_description
($project) || "none";
4159 my %co = parse_commit
("HEAD");
4160 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
4161 my $head = $co{'id'};
4163 my $owner = git_get_project_owner
($project);
4165 my $refs = git_get_references
();
4166 # These get_*_list functions return one more to allow us to see if
4167 # there are more ...
4168 my @taglist = git_get_tags_list
(16);
4169 my @headlist = git_get_heads_list
(16);
4171 my ($check_forks) = gitweb_check_feature
('forks');
4174 @forklist = git_get_projects_list
($project);
4178 git_print_page_nav
('summary','', $head);
4180 print "<div class=\"title\"> </div>\n";
4181 print "<table class=\"projects_list\">\n" .
4182 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
4183 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
4184 if (defined $cd{'rfc2822'}) {
4185 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
4188 # use per project git URL list in $projectroot/$project/cloneurl
4189 # or make project git URL from git base URL and project name
4190 my $url_tag = "URL";
4191 my @url_list = git_get_project_url_list
($project);
4192 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
4193 foreach my $git_url (@url_list) {
4194 next unless $git_url;
4195 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
4200 my $show_ctags = (gitweb_check_feature
('ctags'))[0];
4202 my $ctags = git_get_project_ctags
($project);
4203 my $cloud = git_populate_project_tagcloud
($ctags);
4204 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
4205 print "</td>\n<td>" unless %$ctags;
4206 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
4207 print "</td>\n<td>" if %$ctags;
4208 print git_show_project_tagcloud
($cloud, 48);
4214 if (-s
"$projectroot/$project/README.html") {
4215 if (open my $fd, "$projectroot/$project/README.html") {
4216 print "<div class=\"title\">readme</div>\n" .
4217 "<div class=\"readme\">\n";
4218 print $_ while (<$fd>);
4219 print "\n</div>\n"; # class="readme"
4224 # we need to request one more than 16 (0..15) to check if
4226 my @commitlist = $head ? parse_commits
($head, 17) : ();
4228 git_print_header_div
('shortlog');
4229 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
4230 $#commitlist <= 15 ?
undef :
4231 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
4235 git_print_header_div
('tags');
4236 git_tags_body
(\
@taglist, 0, 15,
4237 $#taglist <= 15 ?
undef :
4238 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
4242 git_print_header_div
('heads');
4243 git_heads_body
(\
@headlist, $head, 0, 15,
4244 $#headlist <= 15 ?
undef :
4245 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
4249 git_print_header_div
('forks');
4250 git_project_list_body
(\
@forklist, undef, 0, 15,
4251 $#forklist <= 15 ?
undef :
4252 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
4260 my $head = git_get_head_hash
($project);
4262 git_print_page_nav
('','', $head,undef,$head);
4263 my %tag = parse_tag
($hash);
4266 die_error
(404, "Unknown tag object");
4269 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
4270 print "<div class=\"title_text\">\n" .
4271 "<table class=\"object_header\">\n" .
4273 "<td>object</td>\n" .
4274 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4275 $tag{'object'}) . "</td>\n" .
4276 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4277 $tag{'type'}) . "</td>\n" .
4279 if (defined($tag{'author'})) {
4280 my %ad = parse_date
($tag{'epoch'}, $tag{'tz'});
4281 print "<tr><td>author</td><td>" . esc_html
($tag{'author'}) . "</td></tr>\n";
4282 print "<tr><td></td><td>" . $ad{'rfc2822'} .
4283 sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
4286 print "</table>\n\n" .
4288 print "<div class=\"page_body\">";
4289 my $comment = $tag{'comment'};
4290 foreach my $line (@
$comment) {
4292 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
4302 gitweb_check_feature
('blame')
4303 or die_error
(403, "Blame view not allowed");
4305 die_error
(400, "No file name given") unless $file_name;
4306 $hash_base ||= git_get_head_hash
($project);
4307 die_error
(404, "Couldn't find base commit") unless ($hash_base);
4308 my %co = parse_commit
($hash_base)
4309 or die_error
(404, "Commit not found");
4310 if (!defined $hash) {
4311 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
4312 or die_error
(404, "Error looking up file");
4314 $ftype = git_get_type
($hash);
4315 if ($ftype !~ "blob") {
4316 die_error
(400, "Object is not a blob");
4318 open ($fd, "-|", git_cmd
(), "blame", '-p', '--',
4319 $file_name, $hash_base)
4320 or die_error
(500, "Open git-blame failed");
4323 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
4326 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4329 $cgi->a({-href
=> href
(action
=>"blame", file_name
=>$file_name)},
4331 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4332 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4333 git_print_page_path
($file_name, $ftype, $hash_base);
4334 my @rev_color = (qw(light2 dark2));
4335 my $num_colors = scalar(@rev_color);
4336 my $current_color = 0;
4339 <div class="page_body">
4340 <table class="blame">
4341 <tr><th>Commit</th><th>Line</th><th>Data</th></tr>
4346 last unless defined $_;
4347 my ($full_rev, $orig_lineno, $lineno, $group_size) =
4348 /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/;
4349 if (!exists $metainfo{$full_rev}) {
4350 $metainfo{$full_rev} = {};
4352 my $meta = $metainfo{$full_rev};
4355 if (/^(\S+) (.*)$/) {
4361 my $rev = substr($full_rev, 0, 8);
4362 my $author = $meta->{'author'};
4363 my %date = parse_date
($meta->{'author-time'},
4364 $meta->{'author-tz'});
4365 my $date = $date{'iso-tz'};
4367 $current_color = ++$current_color % $num_colors;
4369 print "<tr class=\"$rev_color[$current_color]\">\n";
4371 print "<td class=\"sha1\"";
4372 print " title=\"". esc_html
($author) . ", $date\"";
4373 print " rowspan=\"$group_size\"" if ($group_size > 1);
4375 print $cgi->a({-href
=> href
(action
=>"commit",
4377 file_name
=>$file_name)},
4381 open (my $dd, "-|", git_cmd
(), "rev-parse", "$full_rev^")
4382 or die_error
(500, "Open git-rev-parse failed");
4383 my $parent_commit = <$dd>;
4385 chomp($parent_commit);
4386 my $blamed = href
(action
=> 'blame',
4387 file_name
=> $meta->{'filename'},
4388 hash_base
=> $parent_commit);
4389 print "<td class=\"linenr\">";
4390 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
4392 -class => "linenr" },
4395 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
4401 or print "Reading blob failed\n";
4406 my $head = git_get_head_hash
($project);
4408 git_print_page_nav
('','', $head,undef,$head);
4409 git_print_header_div
('summary', $project);
4411 my @tagslist = git_get_tags_list
();
4413 git_tags_body
(\
@tagslist);
4419 my $head = git_get_head_hash
($project);
4421 git_print_page_nav
('','', $head,undef,$head);
4422 git_print_header_div
('summary', $project);
4424 my @headslist = git_get_heads_list
();
4426 git_heads_body
(\
@headslist, $head);
4431 sub git_blob_plain
{
4435 if (!defined $hash) {
4436 if (defined $file_name) {
4437 my $base = $hash_base || git_get_head_hash
($project);
4438 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4439 or die_error
(404, "Cannot find file");
4441 die_error
(400, "No file name defined");
4443 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4444 # blobs defined by non-textual hash id's can be cached
4448 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4449 or die_error
(500, "Open git-cat-file blob '$hash' failed");
4451 # content-type (can include charset)
4452 $type = blob_contenttype
($fd, $file_name, $type);
4454 # "save as" filename, even when no $file_name is given
4455 my $save_as = "$hash";
4456 if (defined $file_name) {
4457 $save_as = $file_name;
4458 } elsif ($type =~ m/^text\//) {
4464 -expires
=> $expires,
4465 -content_disposition
=> 'inline; filename="' . $save_as . '"');
4467 binmode STDOUT
, ':raw';
4469 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
4477 if (!defined $hash) {
4478 if (defined $file_name) {
4479 my $base = $hash_base || git_get_head_hash
($project);
4480 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4481 or die_error
(404, "Cannot find file");
4483 die_error
(400, "No file name defined");
4485 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4486 # blobs defined by non-textual hash id's can be cached
4490 my ($have_blame) = gitweb_check_feature
('blame');
4491 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4492 or die_error
(500, "Couldn't cat $file_name, $hash");
4493 my $mimetype = blob_mimetype
($fd, $file_name);
4494 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
4496 return git_blob_plain
($mimetype);
4498 # we can have blame only for text/* mimetype
4499 $have_blame &&= ($mimetype =~ m!^text/!);
4501 git_header_html
(undef, $expires);
4502 my $formats_nav = '';
4503 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4504 if (defined $file_name) {
4507 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
4512 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4515 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4518 $cgi->a({-href
=> href
(action
=>"blob",
4519 hash_base
=>"HEAD", file_name
=>$file_name)},
4523 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4526 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4527 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4529 print "<div class=\"page_nav\">\n" .
4530 "<br/><br/></div>\n" .
4531 "<div class=\"title\">$hash</div>\n";
4533 git_print_page_path
($file_name, "blob", $hash_base);
4534 print "<div class=\"page_body\">\n";
4535 if ($mimetype =~ m!^image/!) {
4536 print qq!<img type
="$mimetype"!;
4538 print qq! alt
="$file_name" title
="$file_name"!;
4541 href(action=>"blob_plain
", hash=>$hash,
4542 hash_base=>$hash_base, file_name=>$file_name) .
4546 while (my $line = <$fd>) {
4549 $line = untabify
($line);
4550 printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
4551 $nr, $nr, $nr, esc_html
($line, -nbsp
=>1);
4555 or print "Reading blob failed.\n";
4561 if (!defined $hash_base) {
4562 $hash_base = "HEAD";
4564 if (!defined $hash) {
4565 if (defined $file_name) {
4566 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
4571 die_error
(404, "No such tree") unless defined($hash);
4573 open my $fd, "-|", git_cmd
(), "ls-tree", '-z', $hash
4574 or die_error
(500, "Open git-ls-tree failed");
4575 my @entries = map { chomp; $_ } <$fd>;
4576 close $fd or die_error
(404, "Reading tree failed");
4579 my $refs = git_get_references
();
4580 my $ref = format_ref_marker
($refs, $hash_base);
4583 my ($have_blame) = gitweb_check_feature
('blame');
4584 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4586 if (defined $file_name) {
4588 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4590 $cgi->a({-href
=> href
(action
=>"tree",
4591 hash_base
=>"HEAD", file_name
=>$file_name)},
4594 my $snapshot_links = format_snapshot_links
($hash);
4595 if (defined $snapshot_links) {
4596 # FIXME: Should be available when we have no hash base as well.
4597 push @views_nav, $snapshot_links;
4599 git_print_page_nav
('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
4600 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
4603 print "<div class=\"page_nav\">\n";
4604 print "<br/><br/></div>\n";
4605 print "<div class=\"title\">$hash</div>\n";
4607 if (defined $file_name) {
4608 $basedir = $file_name;
4609 if ($basedir ne '' && substr($basedir, -1) ne '/') {
4612 git_print_page_path
($file_name, 'tree', $hash_base);
4614 print "<div class=\"page_body\">\n";
4615 print "<table class=\"tree\">\n";
4617 # '..' (top directory) link if possible
4618 if (defined $hash_base &&
4619 defined $file_name && $file_name =~ m![^/]+$!) {
4621 print "<tr class=\"dark\">\n";
4623 print "<tr class=\"light\">\n";
4627 my $up = $file_name;
4628 $up =~ s!/?[^/]+$!!;
4629 undef $up unless $up;
4630 # based on git_print_tree_entry
4631 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
4632 print '<td class="list">';
4633 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hash_base,
4637 print "<td class=\"link\"></td>\n";
4641 foreach my $line (@entries) {
4642 my %t = parse_ls_tree_line
($line, -z
=> 1);
4645 print "<tr class=\"dark\">\n";
4647 print "<tr class=\"light\">\n";
4651 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
4655 print "</table>\n" .
4661 my @supported_fmts = gitweb_check_feature
('snapshot');
4662 @supported_fmts = filter_snapshot_fmts
(@supported_fmts);
4664 my $format = $cgi->param('sf');
4665 if (!@supported_fmts) {
4666 die_error
(403, "Snapshots not allowed");
4668 # default to first supported snapshot format
4669 $format ||= $supported_fmts[0];
4670 if ($format !~ m/^[a-z0-9]+$/) {
4671 die_error
(400, "Invalid snapshot format parameter");
4672 } elsif (!exists($known_snapshot_formats{$format})) {
4673 die_error
(400, "Unknown snapshot format");
4674 } elsif (!grep($_ eq $format, @supported_fmts)) {
4675 die_error
(403, "Unsupported snapshot format");
4678 if (!defined $hash) {
4679 $hash = git_get_head_hash
($project);
4682 my $name = $project;
4683 $name =~ s
,([^/])/*\
.git
$,$1,;
4684 $name = basename
($name);
4685 my $filename = to_utf8
($name);
4686 $name =~ s/\047/\047\\\047\047/g;
4688 $filename .= "-$hash$known_snapshot_formats{$format}{'suffix'}";
4689 $cmd = quote_command
(
4690 git_cmd
(), 'archive',
4691 "--format=$known_snapshot_formats{$format}{'format'}",
4692 "--prefix=$name/", $hash);
4693 if (exists $known_snapshot_formats{$format}{'compressor'}) {
4694 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
4698 -type
=> $known_snapshot_formats{$format}{'type'},
4699 -content_disposition
=> 'inline; filename="' . "$filename" . '"',
4700 -status
=> '200 OK');
4702 open my $fd, "-|", $cmd
4703 or die_error
(500, "Execute git-archive failed");
4704 binmode STDOUT
, ':raw';
4706 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
4711 my $head = git_get_head_hash
($project);
4712 if (!defined $hash) {
4715 if (!defined $page) {
4718 my $refs = git_get_references
();
4720 my @commitlist = parse_commits
($hash, 101, (100 * $page));
4722 my $paging_nav = format_paging_nav
('log', $hash, $head, $page, $#commitlist >= 100);
4725 git_print_page_nav
('log','', $hash,undef,undef, $paging_nav);
4728 my %co = parse_commit
($hash);
4730 git_print_header_div
('summary', $project);
4731 print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
4733 my $to = ($#commitlist >= 99) ?
(99) : ($#commitlist);
4734 for (my $i = 0; $i <= $to; $i++) {
4735 my %co = %{$commitlist[$i]};
4737 my $commit = $co{'id'};
4738 my $ref = format_ref_marker
($refs, $commit);
4739 my %ad = parse_date
($co{'author_epoch'});
4740 git_print_header_div
('commit',
4741 "<span class=\"age\">$co{'age_string'}</span>" .
4742 esc_html
($co{'title'}) . $ref,
4744 print "<div class=\"title_text\">\n" .
4745 "<div class=\"log_link\">\n" .
4746 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
4748 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
4750 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
4753 "<i>" . esc_html
($co{'author_name'}) . " [$ad{'rfc2822'}]</i><br/>\n" .
4756 print "<div class=\"log_body\">\n";
4757 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
4760 if ($#commitlist >= 100) {
4761 print "<div class=\"page_nav\">\n";
4762 print $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
4763 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
4770 $hash ||= $hash_base || "HEAD";
4771 my %co = parse_commit
($hash)
4772 or die_error
(404, "Unknown commit object");
4773 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
4774 my %cd = parse_date
($co{'committer_epoch'}, $co{'committer_tz'});
4776 my $parent = $co{'parent'};
4777 my $parents = $co{'parents'}; # listref
4779 # we need to prepare $formats_nav before any parameter munging
4781 if (!defined $parent) {
4783 $formats_nav .= '(initial)';
4784 } elsif (@
$parents == 1) {
4785 # single parent commit
4788 $cgi->a({-href
=> href
(action
=>"commit",
4790 esc_html
(substr($parent, 0, 7))) .
4797 $cgi->a({-href
=> href
(action
=>"commit",
4799 esc_html
(substr($_, 0, 7)));
4804 if (!defined $parent) {
4808 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
4810 (@
$parents <= 1 ?
$parent : '-c'),
4812 or die_error
(500, "Open git-diff-tree failed");
4813 @difftree = map { chomp; $_ } <$fd>;
4814 close $fd or die_error
(404, "Reading git-diff-tree failed");
4816 # non-textual hash id's can be cached
4818 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4821 my $refs = git_get_references
();
4822 my $ref = format_ref_marker
($refs, $co{'id'});
4824 git_header_html
(undef, $expires);
4825 git_print_page_nav
('commit', '',
4826 $hash, $co{'tree'}, $hash,
4829 if (defined $co{'parent'}) {
4830 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
4832 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
4834 print "<div class=\"title_text\">\n" .
4835 "<table class=\"object_header\">\n";
4836 print "<tr><td>author</td><td>" . esc_html
($co{'author'}) . "</td></tr>\n".
4838 "<td></td><td> $ad{'rfc2822'}";
4839 if ($ad{'hour_local'} < 6) {
4840 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
4841 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
4843 printf(" (%02d:%02d %s)",
4844 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
4848 print "<tr><td>committer</td><td>" . esc_html
($co{'committer'}) . "</td></tr>\n";
4849 print "<tr><td></td><td> $cd{'rfc2822'}" .
4850 sprintf(" (%02d:%02d %s)", $cd{'hour_local'}, $cd{'minute_local'}, $cd{'tz_local'}) .
4852 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
4855 "<td class=\"sha1\">" .
4856 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
4857 class => "list"}, $co{'tree'}) .
4859 "<td class=\"link\">" .
4860 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
4862 my $snapshot_links = format_snapshot_links
($hash);
4863 if (defined $snapshot_links) {
4864 print " | " . $snapshot_links;
4869 foreach my $par (@
$parents) {
4872 "<td class=\"sha1\">" .
4873 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
4874 class => "list"}, $par) .
4876 "<td class=\"link\">" .
4877 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
4879 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
4886 print "<div class=\"page_body\">\n";
4887 git_print_log
($co{'comment'});
4890 git_difftree_body
(\
@difftree, $hash, @
$parents);
4896 # object is defined by:
4897 # - hash or hash_base alone
4898 # - hash_base and file_name
4901 # - hash or hash_base alone
4902 if ($hash || ($hash_base && !defined $file_name)) {
4903 my $object_id = $hash || $hash_base;
4905 open my $fd, "-|", quote_command
(
4906 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
4907 or die_error
(404, "Object does not exist");
4911 or die_error
(404, "Object does not exist");
4913 # - hash_base and file_name
4914 } elsif ($hash_base && defined $file_name) {
4915 $file_name =~ s
,/+$,,;
4917 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
4918 or die_error
(404, "Base object does not exist");
4920 # here errors should not hapen
4921 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
4922 or die_error
(500, "Open git-ls-tree failed");
4926 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
4927 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
4928 die_error
(404, "File or directory for given base does not exist");
4933 die_error
(400, "Not enough information to find object");
4936 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
4937 hash
=>$hash, hash_base
=>$hash_base,
4938 file_name
=>$file_name),
4939 -status
=> '302 Found');
4943 my $format = shift || 'html';
4950 # preparing $fd and %diffinfo for git_patchset_body
4952 if (defined $hash_base && defined $hash_parent_base) {
4953 if (defined $file_name) {
4955 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
4956 $hash_parent_base, $hash_base,
4957 "--", (defined $file_parent ?
$file_parent : ()), $file_name
4958 or die_error
(500, "Open git-diff-tree failed");
4959 @difftree = map { chomp; $_ } <$fd>;
4961 or die_error
(404, "Reading git-diff-tree failed");
4963 or die_error
(404, "Blob diff not found");
4965 } elsif (defined $hash &&
4966 $hash =~ /[0-9a-fA-F]{40}/) {
4967 # try to find filename from $hash
4969 # read filtered raw output
4970 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
4971 $hash_parent_base, $hash_base, "--"
4972 or die_error
(500, "Open git-diff-tree failed");
4974 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
4976 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
4977 map { chomp; $_ } <$fd>;
4979 or die_error
(404, "Reading git-diff-tree failed");
4981 or die_error
(404, "Blob diff not found");
4984 die_error
(400, "Missing one of the blob diff parameters");
4987 if (@difftree > 1) {
4988 die_error
(400, "Ambiguous blob diff specification");
4991 %diffinfo = parse_difftree_raw_line
($difftree[0]);
4992 $file_parent ||= $diffinfo{'from_file'} || $file_name;
4993 $file_name ||= $diffinfo{'to_file'};
4995 $hash_parent ||= $diffinfo{'from_id'};
4996 $hash ||= $diffinfo{'to_id'};
4998 # non-textual hash id's can be cached
4999 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
5000 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
5005 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5006 '-p', ($format eq 'html' ?
"--full-index" : ()),
5007 $hash_parent_base, $hash_base,
5008 "--", (defined $file_parent ?
$file_parent : ()), $file_name
5009 or die_error
(500, "Open git-diff-tree failed");
5012 # old/legacy style URI
5013 if (!%diffinfo && # if new style URI failed
5014 defined $hash && defined $hash_parent) {
5015 # fake git-diff-tree raw output
5016 $diffinfo{'from_mode'} = $diffinfo{'to_mode'} = "blob";
5017 $diffinfo{'from_id'} = $hash_parent;
5018 $diffinfo{'to_id'} = $hash;
5019 if (defined $file_name) {
5020 if (defined $file_parent) {
5021 $diffinfo{'status'} = '2';
5022 $diffinfo{'from_file'} = $file_parent;
5023 $diffinfo{'to_file'} = $file_name;
5024 } else { # assume not renamed
5025 $diffinfo{'status'} = '1';
5026 $diffinfo{'from_file'} = $file_name;
5027 $diffinfo{'to_file'} = $file_name;
5029 } else { # no filename given
5030 $diffinfo{'status'} = '2';
5031 $diffinfo{'from_file'} = $hash_parent;
5032 $diffinfo{'to_file'} = $hash;
5035 # non-textual hash id's can be cached
5036 if ($hash =~ m/^[0-9a-fA-F]{40}$/ &&
5037 $hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5042 open $fd, "-|", git_cmd
(), "diff", @diff_opts,
5043 '-p', ($format eq 'html' ?
"--full-index" : ()),
5044 $hash_parent, $hash, "--"
5045 or die_error
(500, "Open git-diff failed");
5047 die_error
(400, "Missing one of the blob diff parameters")
5052 if ($format eq 'html') {
5054 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
5056 git_header_html
(undef, $expires);
5057 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5058 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5059 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5061 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
5062 print "<div class=\"title\">$hash vs $hash_parent</div>\n";
5064 if (defined $file_name) {
5065 git_print_page_path
($file_name, "blob", $hash_base);
5067 print "<div class=\"page_path\"></div>\n";
5070 } elsif ($format eq 'plain') {
5072 -type
=> 'text/plain',
5073 -charset
=> 'utf-8',
5074 -expires
=> $expires,
5075 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
5077 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5080 die_error
(400, "Unknown blobdiff format");
5084 if ($format eq 'html') {
5085 print "<div class=\"page_body\">\n";
5087 git_patchset_body
($fd, [ \
%diffinfo ], $hash_base, $hash_parent_base);
5090 print "</div>\n"; # class="page_body"
5094 while (my $line = <$fd>) {
5095 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
5096 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
5100 last if $line =~ m!^\+\+\+!;
5108 sub git_blobdiff_plain
{
5109 git_blobdiff
('plain');
5112 sub git_commitdiff
{
5113 my $format = shift || 'html';
5114 $hash ||= $hash_base || "HEAD";
5115 my %co = parse_commit
($hash)
5116 or die_error
(404, "Unknown commit object");
5118 # choose format for commitdiff for merge
5119 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
5120 $hash_parent = '--cc';
5122 # we need to prepare $formats_nav before almost any parameter munging
5124 if ($format eq 'html') {
5126 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
5129 if (defined $hash_parent &&
5130 $hash_parent ne '-c' && $hash_parent ne '--cc') {
5131 # commitdiff with two commits given
5132 my $hash_parent_short = $hash_parent;
5133 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5134 $hash_parent_short = substr($hash_parent, 0, 7);
5138 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
5139 if ($co{'parents'}[$i] eq $hash_parent) {
5140 $formats_nav .= ' parent ' . ($i+1);
5144 $formats_nav .= ': ' .
5145 $cgi->a({-href
=> href
(action
=>"commitdiff",
5146 hash
=>$hash_parent)},
5147 esc_html
($hash_parent_short)) .
5149 } elsif (!$co{'parent'}) {
5151 $formats_nav .= ' (initial)';
5152 } elsif (scalar @
{$co{'parents'}} == 1) {
5153 # single parent commit
5156 $cgi->a({-href
=> href
(action
=>"commitdiff",
5157 hash
=>$co{'parent'})},
5158 esc_html
(substr($co{'parent'}, 0, 7))) .
5162 if ($hash_parent eq '--cc') {
5163 $formats_nav .= ' | ' .
5164 $cgi->a({-href
=> href
(action
=>"commitdiff",
5165 hash
=>$hash, hash_parent
=>'-c')},
5167 } else { # $hash_parent eq '-c'
5168 $formats_nav .= ' | ' .
5169 $cgi->a({-href
=> href
(action
=>"commitdiff",
5170 hash
=>$hash, hash_parent
=>'--cc')},
5176 $cgi->a({-href
=> href
(action
=>"commitdiff",
5178 esc_html
(substr($_, 0, 7)));
5179 } @
{$co{'parents'}} ) .
5184 my $hash_parent_param = $hash_parent;
5185 if (!defined $hash_parent_param) {
5186 # --cc for multiple parents, --root for parentless
5187 $hash_parent_param =
5188 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
5194 if ($format eq 'html') {
5195 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5196 "--no-commit-id", "--patch-with-raw", "--full-index",
5197 $hash_parent_param, $hash, "--"
5198 or die_error
(500, "Open git-diff-tree failed");
5200 while (my $line = <$fd>) {
5202 # empty line ends raw part of diff-tree output
5204 push @difftree, scalar parse_difftree_raw_line
($line);
5207 } elsif ($format eq 'plain') {
5208 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5209 '-p', $hash_parent_param, $hash, "--"
5210 or die_error
(500, "Open git-diff-tree failed");
5213 die_error
(400, "Unknown commitdiff format");
5216 # non-textual hash id's can be cached
5218 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5222 # write commit message
5223 if ($format eq 'html') {
5224 my $refs = git_get_references
();
5225 my $ref = format_ref_marker
($refs, $co{'id'});
5227 git_header_html
(undef, $expires);
5228 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
5229 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
5230 git_print_authorship
(\
%co);
5231 print "<div class=\"page_body\">\n";
5232 if (@
{$co{'comment'}} > 1) {
5233 print "<div class=\"log\">\n";
5234 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
5235 print "</div>\n"; # class="log"
5238 } elsif ($format eq 'plain') {
5239 my $refs = git_get_references
("tags");
5240 my $tagname = git_get_rev_name_tags
($hash);
5241 my $filename = basename
($project) . "-$hash.patch";
5244 -type
=> 'text/plain',
5245 -charset
=> 'utf-8',
5246 -expires
=> $expires,
5247 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
5248 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
5249 print "From: " . to_utf8
($co{'author'}) . "\n";
5250 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
5251 print "Subject: " . to_utf8
($co{'title'}) . "\n";
5253 print "X-Git-Tag: $tagname\n" if $tagname;
5254 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5256 foreach my $line (@
{$co{'comment'}}) {
5257 print to_utf8
($line) . "\n";
5263 if ($format eq 'html') {
5264 my $use_parents = !defined $hash_parent ||
5265 $hash_parent eq '-c' || $hash_parent eq '--cc';
5266 git_difftree_body
(\
@difftree, $hash,
5267 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5270 git_patchset_body
($fd, \
@difftree, $hash,
5271 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5273 print "</div>\n"; # class="page_body"
5276 } elsif ($format eq 'plain') {
5280 or print "Reading git-diff-tree failed\n";
5284 sub git_commitdiff_plain
{
5285 git_commitdiff
('plain');
5289 if (!defined $hash_base) {
5290 $hash_base = git_get_head_hash
($project);
5292 if (!defined $page) {
5296 my %co = parse_commit
($hash_base)
5297 or die_error
(404, "Unknown commit object");
5299 my $refs = git_get_references
();
5300 my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
5302 my @commitlist = parse_commits
($hash_base, 101, (100 * $page),
5303 $file_name, "--full-history")
5304 or die_error
(404, "No such file or directory on given branch");
5306 if (!defined $hash && defined $file_name) {
5307 # some commits could have deleted file in question,
5308 # and not have it in tree, but one of them has to have it
5309 for (my $i = 0; $i <= @commitlist; $i++) {
5310 $hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
5311 last if defined $hash;
5314 if (defined $hash) {
5315 $ftype = git_get_type
($hash);
5317 if (!defined $ftype) {
5318 die_error
(500, "Unknown type of object");
5321 my $paging_nav = '';
5324 $cgi->a({-href
=> href
(action
=>"history", hash
=>$hash, hash_base
=>$hash_base,
5325 file_name
=>$file_name)},
5327 $paging_nav .= " ⋅ " .
5328 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5329 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5331 $paging_nav .= "first";
5332 $paging_nav .= " ⋅ prev";
5335 if ($#commitlist >= 100) {
5337 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5338 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5339 $paging_nav .= " ⋅ $next_link";
5341 $paging_nav .= " ⋅ next";
5345 git_print_page_nav
('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
5346 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5347 git_print_page_path
($file_name, $ftype, $hash_base);
5349 git_history_body
(\
@commitlist, 0, 99,
5350 $refs, $hash_base, $ftype, $next_link);
5356 gitweb_check_feature
('search') or die_error
(403, "Search is disabled");
5357 if (!defined $searchtext) {
5358 die_error
(400, "Text field is empty");
5360 if (!defined $hash) {
5361 $hash = git_get_head_hash
($project);
5363 my %co = parse_commit
($hash);
5365 die_error
(404, "Unknown commit object");
5367 if (!defined $page) {
5371 $searchtype ||= 'commit';
5372 if ($searchtype eq 'pickaxe') {
5373 # pickaxe may take all resources of your box and run for several minutes
5374 # with every query - so decide by yourself how public you make this feature
5375 gitweb_check_feature
('pickaxe')
5376 or die_error
(403, "Pickaxe is disabled");
5378 if ($searchtype eq 'grep') {
5379 gitweb_check_feature
('grep')
5380 or die_error
(403, "Grep is disabled");
5385 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
5387 if ($searchtype eq 'commit') {
5388 $greptype = "--grep=";
5389 } elsif ($searchtype eq 'author') {
5390 $greptype = "--author=";
5391 } elsif ($searchtype eq 'committer') {
5392 $greptype = "--committer=";
5394 $greptype .= $searchtext;
5395 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5396 $greptype, '--regexp-ignore-case',
5397 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5399 my $paging_nav = '';
5402 $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
5403 searchtext
=>$searchtext,
5404 searchtype
=>$searchtype)},
5406 $paging_nav .= " ⋅ " .
5407 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5408 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5410 $paging_nav .= "first";
5411 $paging_nav .= " ⋅ prev";
5414 if ($#commitlist >= 100) {
5416 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5417 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5418 $paging_nav .= " ⋅ $next_link";
5420 $paging_nav .= " ⋅ next";
5423 if ($#commitlist >= 100) {
5426 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5427 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5428 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5431 if ($searchtype eq 'pickaxe') {
5432 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5433 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5435 print "<table class=\"pickaxe search\">\n";
5438 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5439 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5440 ($search_use_regexp ?
'--pickaxe-regex' : ());
5443 while (my $line = <$fd>) {
5447 my %set = parse_difftree_raw_line
($line);
5448 if (defined $set{'commit'}) {
5449 # finish previous commit
5452 "<td class=\"link\">" .
5453 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5455 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5461 print "<tr class=\"dark\">\n";
5463 print "<tr class=\"light\">\n";
5466 %co = parse_commit
($set{'commit'});
5467 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5468 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5469 "<td><i>$author</i></td>\n" .
5471 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5472 -class => "list subject"},
5473 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5474 } elsif (defined $set{'to_id'}) {
5475 next if ($set{'to_id'} =~ m/^0{40}$/);
5477 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5478 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5480 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5486 # finish last commit (warning: repetition!)
5489 "<td class=\"link\">" .
5490 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5492 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5500 if ($searchtype eq 'grep') {
5501 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5502 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5504 print "<table class=\"grep_search\">\n";
5508 open my $fd, "-|", git_cmd
(), 'grep', '-n',
5509 $search_use_regexp ?
('-E', '-i') : '-F',
5510 $searchtext, $co{'tree'};
5512 while (my $line = <$fd>) {
5514 my ($file, $lno, $ltext, $binary);
5515 last if ($matches++ > 1000);
5516 if ($line =~ /^Binary file (.+) matches$/) {
5520 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5522 if ($file ne $lastfile) {
5523 $lastfile and print "</td></tr>\n";
5525 print "<tr class=\"dark\">\n";
5527 print "<tr class=\"light\">\n";
5529 print "<td class=\"list\">".
5530 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5531 file_name
=>"$file"),
5532 -class => "list"}, esc_path
($file));
5533 print "</td><td>\n";
5537 print "<div class=\"binary\">Binary file</div>\n";
5539 $ltext = untabify
($ltext);
5540 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5541 $ltext = esc_html
($1, -nbsp
=>1);
5542 $ltext .= '<span class="match">';
5543 $ltext .= esc_html
($2, -nbsp
=>1);
5544 $ltext .= '</span>';
5545 $ltext .= esc_html
($3, -nbsp
=>1);
5547 $ltext = esc_html
($ltext, -nbsp
=>1);
5549 print "<div class=\"pre\">" .
5550 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5551 file_name
=>"$file").'#l'.$lno,
5552 -class => "linenr"}, sprintf('%4i', $lno))
5553 . ' ' . $ltext . "</div>\n";
5557 print "</td></tr>\n";
5558 if ($matches > 1000) {
5559 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5562 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5571 sub git_search_help
{
5573 git_print_page_nav
('','', $hash,$hash,$hash);
5575 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
5576 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
5577 the pattern entered is recognized as the POSIX extended
5578 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
5581 <dt><b>commit</b></dt>
5582 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
5584 my ($have_grep) = gitweb_check_feature
('grep');
5587 <dt><b>grep</b></dt>
5588 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
5589 a different one) are searched for the given pattern. On large trees, this search can take
5590 a while and put some strain on the server, so please use it with some consideration. Note that
5591 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
5592 case-sensitive.</dd>
5596 <dt><b>author</b></dt>
5597 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
5598 <dt><b>committer</b></dt>
5599 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
5601 my ($have_pickaxe) = gitweb_check_feature
('pickaxe');
5602 if ($have_pickaxe) {
5604 <dt><b>pickaxe</b></dt>
5605 <dd>All commits that caused the string to appear or disappear from any file (changes that
5606 added, removed or "modified" the string) will be listed. This search can take a while and
5607 takes a lot of strain on the server, so please use it wisely. Note that since you may be
5608 interested even in changes just changing the case as well, this search is case sensitive.</dd>
5616 my $head = git_get_head_hash
($project);
5617 if (!defined $hash) {
5620 if (!defined $page) {
5623 my $refs = git_get_references
();
5625 my $commit_hash = $hash;
5626 if (defined $hash_parent) {
5627 $commit_hash = "$hash_parent..$hash";
5629 my @commitlist = parse_commits
($commit_hash, 101, (100 * $page));
5631 my $paging_nav = format_paging_nav
('shortlog', $hash, $head, $page, $#commitlist >= 100);
5633 if ($#commitlist >= 100) {
5635 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5636 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5640 git_print_page_nav
('shortlog','', $hash,$hash,$hash, $paging_nav);
5641 git_print_header_div
('summary', $project);
5643 git_shortlog_body
(\
@commitlist, 0, 99, $refs, $next_link);
5648 ## ......................................................................
5649 ## feeds (RSS, Atom; OPML)
5652 my $format = shift || 'atom';
5653 my ($have_blame) = gitweb_check_feature
('blame');
5655 # Atom: http://www.atomenabled.org/developers/syndication/
5656 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
5657 if ($format ne 'rss' && $format ne 'atom') {
5658 die_error
(400, "Unknown web feed format");
5661 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
5662 my $head = $hash || 'HEAD';
5663 my @commitlist = parse_commits
($head, 150, 0, $file_name);
5667 my $content_type = "application/$format+xml";
5668 if (defined $cgi->http('HTTP_ACCEPT') &&
5669 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
5670 # browser (feed reader) prefers text/xml
5671 $content_type = 'text/xml';
5673 if (defined($commitlist[0])) {
5674 %latest_commit = %{$commitlist[0]};
5675 %latest_date = parse_date
($latest_commit{'author_epoch'});
5677 -type
=> $content_type,
5678 -charset
=> 'utf-8',
5679 -last_modified
=> $latest_date{'rfc2822'});
5682 -type
=> $content_type,
5683 -charset
=> 'utf-8');
5686 # Optimization: skip generating the body if client asks only
5687 # for Last-Modified date.
5688 return if ($cgi->request_method() eq 'HEAD');
5691 my $title = "$site_name - $project/$action";
5692 my $feed_type = 'log';
5693 if (defined $hash) {
5694 $title .= " - '$hash'";
5695 $feed_type = 'branch log';
5696 if (defined $file_name) {
5697 $title .= " :: $file_name";
5698 $feed_type = 'history';
5700 } elsif (defined $file_name) {
5701 $title .= " - $file_name";
5702 $feed_type = 'history';
5704 $title .= " $feed_type";
5705 my $descr = git_get_project_description
($project);
5706 if (defined $descr) {
5707 $descr = esc_html
($descr);
5709 $descr = "$project " .
5710 ($format eq 'rss' ?
'RSS' : 'Atom') .
5713 my $owner = git_get_project_owner
($project);
5714 $owner = esc_html
($owner);
5718 if (defined $file_name) {
5719 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
5720 } elsif (defined $hash) {
5721 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
5723 $alt_url = href
(-full
=>1, action
=>"summary");
5725 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
5726 if ($format eq 'rss') {
5728 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
5731 print "<title>$title</title>\n" .
5732 "<link>$alt_url</link>\n" .
5733 "<description>$descr</description>\n" .
5734 "<language>en</language>\n";
5735 } elsif ($format eq 'atom') {
5737 <feed xmlns="http://www.w3.org/2005/Atom">
5739 print "<title>$title</title>\n" .
5740 "<subtitle>$descr</subtitle>\n" .
5741 '<link rel="alternate" type="text/html" href="' .
5742 $alt_url . '" />' . "\n" .
5743 '<link rel="self" type="' . $content_type . '" href="' .
5744 $cgi->self_url() . '" />' . "\n" .
5745 "<id>" . href
(-full
=>1) . "</id>\n" .
5746 # use project owner for feed author
5747 "<author><name>$owner</name></author>\n";
5748 if (defined $favicon) {
5749 print "<icon>" . esc_url
($favicon) . "</icon>\n";
5751 if (defined $logo_url) {
5752 # not twice as wide as tall: 72 x 27 pixels
5753 print "<logo>" . esc_url
($logo) . "</logo>\n";
5755 if (! %latest_date) {
5756 # dummy date to keep the feed valid until commits trickle in:
5757 print "<updated>1970-01-01T00:00:00Z</updated>\n";
5759 print "<updated>$latest_date{'iso-8601'}</updated>\n";
5764 for (my $i = 0; $i <= $#commitlist; $i++) {
5765 my %co = %{$commitlist[$i]};
5766 my $commit = $co{'id'};
5767 # we read 150, we always show 30 and the ones more recent than 48 hours
5768 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
5771 my %cd = parse_date
($co{'author_epoch'});
5773 # get list of changed files
5774 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5775 $co{'parent'} || "--root",
5776 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
5778 my @difftree = map { chomp; $_ } <$fd>;
5782 # print element (entry, item)
5783 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
5784 if ($format eq 'rss') {
5786 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
5787 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
5788 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
5789 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
5790 "<link>$co_url</link>\n" .
5791 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
5792 "<content:encoded>" .
5794 } elsif ($format eq 'atom') {
5796 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
5797 "<updated>$cd{'iso-8601'}</updated>\n" .
5799 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
5800 if ($co{'author_email'}) {
5801 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
5803 print "</author>\n" .
5804 # use committer for contributor
5806 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
5807 if ($co{'committer_email'}) {
5808 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
5810 print "</contributor>\n" .
5811 "<published>$cd{'iso-8601'}</published>\n" .
5812 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
5813 "<id>$co_url</id>\n" .
5814 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
5815 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
5817 my $comment = $co{'comment'};
5819 foreach my $line (@
$comment) {
5820 $line = esc_html
($line);
5823 print "</pre><ul>\n";
5824 foreach my $difftree_line (@difftree) {
5825 my %difftree = parse_difftree_raw_line
($difftree_line);
5826 next if !$difftree{'from_id'};
5828 my $file = $difftree{'file'} || $difftree{'to_file'};
5832 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
5833 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
5834 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
5835 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
5836 -title
=> "diff"}, 'D');
5838 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
5839 file_name
=>$file, hash_base
=>$commit),
5840 -title
=> "blame"}, 'B');
5842 # if this is not a feed of a file history
5843 if (!defined $file_name || $file_name ne $file) {
5844 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
5845 file_name
=>$file, hash
=>$commit),
5846 -title
=> "history"}, 'H');
5848 $file = esc_path
($file);
5852 if ($format eq 'rss') {
5853 print "</ul>]]>\n" .
5854 "</content:encoded>\n" .
5856 } elsif ($format eq 'atom') {
5857 print "</ul>\n</div>\n" .
5864 if ($format eq 'rss') {
5865 print "</channel>\n</rss>\n";
5866 } elsif ($format eq 'atom') {
5880 my @list = git_get_projects_list
();
5882 print $cgi->header(-type
=> 'text/xml', -charset
=> 'utf-8');
5884 <?xml version="1.0" encoding="utf-8"?>
5885 <opml version="1.0">
5887 <title>$site_name OPML Export</title>
5890 <outline text="git RSS feeds">
5893 foreach my $pr (@list) {
5895 my $head = git_get_head_hash
($proj{'path'});
5896 if (!defined $head) {
5899 $git_dir = "$projectroot/$proj{'path'}";
5900 my %co = parse_commit
($head);
5905 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
5906 my $rss = "$my_url?p=$proj{'path'};a=rss";
5907 my $html = "$my_url?p=$proj{'path'};a=summary";
5908 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";