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 # we make $path_info global because it's also used later on
33 our $path_info = $ENV{"PATH_INFO"};
35 $my_url =~ s
,\Q
$path_info\E
$,,;
36 $my_uri =~ s
,\Q
$path_info\E
$,,;
39 # core git executable to use
40 # this can just be "git" if your webserver has a sensible PATH
41 our $GIT = "++GIT_BINDIR++/git";
43 # absolute fs-path which will be prepended to the project path
44 #our $projectroot = "/pub/scm";
45 our $projectroot = "++GITWEB_PROJECTROOT++";
47 # fs traversing limit for getting project list
48 # the number is relative to the projectroot
49 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
51 # target of the home link on top of all pages
52 our $home_link = $my_uri || "/";
54 # string of the home link on top of all pages
55 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
57 # name of your site or organization to appear in page titles
58 # replace this with something more descriptive for clearer bookmarks
59 our $site_name = "++GITWEB_SITENAME++"
60 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
62 # filename of html text to include at top of each page
63 our $site_header = "++GITWEB_SITE_HEADER++";
64 # html text to include at home page
65 our $home_text = "++GITWEB_HOMETEXT++";
66 # filename of html text to include at bottom of each page
67 our $site_footer = "++GITWEB_SITE_FOOTER++";
70 our @stylesheets = ("++GITWEB_CSS++");
71 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
72 our $stylesheet = undef;
73 # URI of GIT logo (72x27 size)
74 our $logo = "++GITWEB_LOGO++";
75 # URI of GIT favicon, assumed to be image/png type
76 our $favicon = "++GITWEB_FAVICON++";
78 # URI and label (title) of GIT logo link
79 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
80 #our $logo_label = "git documentation";
81 our $logo_url = "http://git.or.cz/";
82 our $logo_label = "git homepage";
84 # source of projects list
85 our $projects_list = "++GITWEB_LIST++";
87 # the width (in characters) of the projects list "Description" column
88 our $projects_list_description_width = 25;
90 # default order of projects list
91 # valid values are none, project, descr, owner, and age
92 our $default_projects_order = "project";
94 # show repository only if this file exists
95 # (only effective if this variable evaluates to true)
96 our $export_ok = "++GITWEB_EXPORT_OK++";
98 # show repository only if this subroutine returns true
99 # when given the path to the project, for example:
100 # sub { return -e "$_[0]/git-daemon-export-ok"; }
101 our $export_auth_hook = undef;
103 # only allow viewing of repositories also shown on the overview page
104 our $strict_export = "++GITWEB_STRICT_EXPORT++";
106 # list of git base URLs used for URL to where fetch project from,
107 # i.e. full URL is "$git_base_url/$project"
108 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
110 # default blob_plain mimetype and default charset for text/plain blob
111 our $default_blob_plain_mimetype = 'text/plain';
112 our $default_text_plain_charset = undef;
114 # file to use for guessing MIME types before trying /etc/mime.types
115 # (relative to the current git repository)
116 our $mimetypes_file = undef;
118 # assume this charset if line contains non-UTF-8 characters;
119 # it should be valid encoding (see Encoding::Supported(3pm) for list),
120 # for which encoding all byte sequences are valid, for example
121 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
122 # could be even 'utf-8' for the old behavior)
123 our $fallback_encoding = 'latin1';
125 # rename detection options for git-diff and git-diff-tree
126 # - default is '-M', with the cost proportional to
127 # (number of removed files) * (number of new files).
128 # - more costly is '-C' (which implies '-M'), with the cost proportional to
129 # (number of changed files + number of removed files) * (number of new files)
130 # - even more costly is '-C', '--find-copies-harder' with cost
131 # (number of files in the original tree) * (number of new files)
132 # - one might want to include '-B' option, e.g. '-B', '-M'
133 our @diff_opts = ('-M'); # taken from git_commit
135 # information about snapshot formats that gitweb is capable of serving
136 our %known_snapshot_formats = (
138 # 'display' => display name,
139 # 'type' => mime type,
140 # 'suffix' => filename suffix,
141 # 'format' => --format for git-archive,
142 # 'compressor' => [compressor command and arguments]
143 # (array reference, optional)}
146 'display' => 'tar.gz',
147 'type' => 'application/x-gzip',
148 'suffix' => '.tar.gz',
150 'compressor' => ['gzip']},
153 'display' => 'tar.bz2',
154 'type' => 'application/x-bzip2',
155 'suffix' => '.tar.bz2',
157 'compressor' => ['bzip2']},
161 'type' => 'application/x-zip',
166 # Aliases so we understand old gitweb.snapshot values in repository
168 our %known_snapshot_format_aliases = (
172 # backward compatibility: legacy gitweb config support
173 'x-gzip' => undef, 'gz' => undef,
174 'x-bzip2' => undef, 'bz2' => undef,
175 'x-zip' => undef, '' => undef,
178 # You define site-wide feature defaults here; override them with
179 # $GITWEB_CONFIG as necessary.
182 # 'sub' => feature-sub (subroutine),
183 # 'override' => allow-override (boolean),
184 # 'default' => [ default options...] (array reference)}
186 # if feature is overridable (it means that allow-override has true value),
187 # then feature-sub will be called with default options as parameters;
188 # return value of feature-sub indicates if to enable specified feature
190 # if there is no 'sub' key (no feature-sub), then feature cannot be
193 # use gitweb_check_feature(<feature>) to check if <feature> is enabled
195 # Enable the 'blame' blob view, showing the last commit that modified
196 # each line in the file. This can be very CPU-intensive.
198 # To enable system wide have in $GITWEB_CONFIG
199 # $feature{'blame'}{'default'} = [1];
200 # To have project specific config enable override in $GITWEB_CONFIG
201 # $feature{'blame'}{'override'} = 1;
202 # and in project config gitweb.blame = 0|1;
204 'sub' => \
&feature_blame
,
208 # Enable the 'snapshot' link, providing a compressed archive of any
209 # tree. This can potentially generate high traffic if you have large
212 # Value is a list of formats defined in %known_snapshot_formats that
214 # To disable system wide have in $GITWEB_CONFIG
215 # $feature{'snapshot'}{'default'} = [];
216 # To have project specific config enable override in $GITWEB_CONFIG
217 # $feature{'snapshot'}{'override'} = 1;
218 # and in project config, a comma-separated list of formats or "none"
219 # to disable. Example: gitweb.snapshot = tbz2,zip;
221 'sub' => \
&feature_snapshot
,
223 'default' => ['tgz']},
225 # Enable text search, which will list the commits which match author,
226 # committer or commit text to a given string. Enabled by default.
227 # Project specific override is not supported.
232 # Enable grep search, which will list the files in currently selected
233 # tree containing the given string. Enabled by default. This can be
234 # potentially CPU-intensive, of course.
236 # To enable system wide have in $GITWEB_CONFIG
237 # $feature{'grep'}{'default'} = [1];
238 # To have project specific config enable override in $GITWEB_CONFIG
239 # $feature{'grep'}{'override'} = 1;
240 # and in project config gitweb.grep = 0|1;
245 # Enable the pickaxe search, which will list the commits that modified
246 # a given string in a file. This can be practical and quite faster
247 # alternative to 'blame', but still potentially CPU-intensive.
249 # To enable system wide have in $GITWEB_CONFIG
250 # $feature{'pickaxe'}{'default'} = [1];
251 # To have project specific config enable override in $GITWEB_CONFIG
252 # $feature{'pickaxe'}{'override'} = 1;
253 # and in project config gitweb.pickaxe = 0|1;
255 'sub' => \
&feature_pickaxe
,
259 # Make gitweb use an alternative format of the URLs which can be
260 # more readable and natural-looking: project name is embedded
261 # directly in the path and the query string contains other
262 # auxiliary information. All gitweb installations recognize
263 # URL in either format; this configures in which formats gitweb
266 # To enable system wide have in $GITWEB_CONFIG
267 # $feature{'pathinfo'}{'default'} = [1];
268 # Project specific override is not supported.
270 # Note that you will need to change the default location of CSS,
271 # favicon, logo and possibly other files to an absolute URL. Also,
272 # if gitweb.cgi serves as your indexfile, you will need to force
273 # $my_uri to contain the script name in your $GITWEB_CONFIG.
278 # Make gitweb consider projects in project root subdirectories
279 # to be forks of existing projects. Given project $projname.git,
280 # projects matching $projname/*.git will not be shown in the main
281 # projects list, instead a '+' mark will be added to $projname
282 # there and a 'forks' view will be enabled for the project, listing
283 # all the forks. If project list is taken from a file, forks have
284 # to be listed after the main project.
286 # To enable system wide have in $GITWEB_CONFIG
287 # $feature{'forks'}{'default'} = [1];
288 # Project specific override is not supported.
293 # Insert custom links to the action bar of all project pages.
294 # This enables you mainly to link to third-party scripts integrating
295 # into gitweb; e.g. git-browser for graphical history representation
296 # or custom web-based repository administration interface.
298 # The 'default' value consists of a list of triplets in the form
299 # (label, link, position) where position is the label after which
300 # to inster the link and link is a format string where %n expands
301 # to the project name, %f to the project path within the filesystem,
302 # %h to the current hash (h gitweb parameter) and %b to the current
303 # hash base (hb gitweb parameter).
305 # To enable system wide have in $GITWEB_CONFIG e.g.
306 # $feature{'actions'}{'default'} = [('graphiclog',
307 # '/git-browser/by-commit.html?r=%n', 'summary')];
308 # Project specific override is not supported.
313 # Allow gitweb scan project content tags described in ctags/
314 # of project repository, and display the popular Web 2.0-ish
315 # "tag cloud" near the project list. Note that this is something
316 # COMPLETELY different from the normal Git tags.
318 # gitweb by itself can show existing tags, but it does not handle
319 # tagging itself; you need an external application for that.
320 # For an example script, check Girocco's cgi/tagproj.cgi.
321 # You may want to install the HTML::TagCloud Perl module to get
322 # a pretty tag cloud instead of just a list of tags.
324 # To enable system wide have in $GITWEB_CONFIG
325 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
326 # Project specific override is not supported.
332 sub gitweb_check_feature
{
334 return unless exists $feature{$name};
335 my ($sub, $override, @defaults) = (
336 $feature{$name}{'sub'},
337 $feature{$name}{'override'},
338 @
{$feature{$name}{'default'}});
339 if (!$override) { return @defaults; }
341 warn "feature $name is not overrideable";
344 return $sub->(@defaults);
348 my ($val) = git_get_project_config
('blame', '--bool');
350 if ($val eq 'true') {
352 } elsif ($val eq 'false') {
359 sub feature_snapshot
{
362 my ($val) = git_get_project_config
('snapshot');
365 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
372 my ($val) = git_get_project_config
('grep', '--bool');
374 if ($val eq 'true') {
376 } elsif ($val eq 'false') {
383 sub feature_pickaxe
{
384 my ($val) = git_get_project_config
('pickaxe', '--bool');
386 if ($val eq 'true') {
388 } elsif ($val eq 'false') {
395 # checking HEAD file with -e is fragile if the repository was
396 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
398 sub check_head_link
{
400 my $headfile = "$dir/HEAD";
401 return ((-e
$headfile) ||
402 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
405 sub check_export_ok
{
407 return (check_head_link
($dir) &&
408 (!$export_ok || -e
"$dir/$export_ok") &&
409 (!$export_auth_hook || $export_auth_hook->($dir)));
412 # process alternate names for backward compatibility
413 # filter out unsupported (unknown) snapshot formats
414 sub filter_snapshot_fmts
{
418 exists $known_snapshot_format_aliases{$_} ?
419 $known_snapshot_format_aliases{$_} : $_} @fmts;
420 @fmts = grep(exists $known_snapshot_formats{$_}, @fmts);
424 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
425 if (-e
$GITWEB_CONFIG) {
428 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
429 do $GITWEB_CONFIG_SYSTEM if -e
$GITWEB_CONFIG_SYSTEM;
432 # version of the core git binary
433 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
435 $projects_list ||= $projectroot;
437 # ======================================================================
438 # input validation and dispatch
440 # input parameters can be collected from a variety of sources (presently, CGI
441 # and PATH_INFO), so we define an %input_params hash that collects them all
442 # together during validation: this allows subsequent uses (e.g. href()) to be
443 # agnostic of the parameter origin
445 our %input_params = ();
447 # input parameters are stored with the long parameter name as key. This will
448 # also be used in the href subroutine to convert parameters to their CGI
449 # equivalent, and since the href() usage is the most frequent one, we store
450 # the name -> CGI key mapping here, instead of the reverse.
452 # XXX: Warning: If you touch this, check the search form for updating,
455 our @cgi_param_mapping = (
463 hash_parent_base
=> "hpb",
468 snapshot_format
=> "sf",
469 extra_options
=> "opt",
470 search_use_regexp
=> "sr",
472 our %cgi_param_mapping = @cgi_param_mapping;
474 # we will also need to know the possible actions, for validation
476 "blame" => \
&git_blame
,
477 "blobdiff" => \
&git_blobdiff
,
478 "blobdiff_plain" => \
&git_blobdiff_plain
,
479 "blob" => \
&git_blob
,
480 "blob_plain" => \
&git_blob_plain
,
481 "commitdiff" => \
&git_commitdiff
,
482 "commitdiff_plain" => \
&git_commitdiff_plain
,
483 "commit" => \
&git_commit
,
484 "forks" => \
&git_forks
,
485 "heads" => \
&git_heads
,
486 "history" => \
&git_history
,
489 "atom" => \
&git_atom
,
490 "search" => \
&git_search
,
491 "search_help" => \
&git_search_help
,
492 "shortlog" => \
&git_shortlog
,
493 "summary" => \
&git_summary
,
495 "tags" => \
&git_tags
,
496 "tree" => \
&git_tree
,
497 "snapshot" => \
&git_snapshot
,
498 "object" => \
&git_object
,
499 # those below don't need $project
500 "opml" => \
&git_opml
,
501 "project_list" => \
&git_project_list
,
502 "project_index" => \
&git_project_index
,
505 # finally, we have the hash of allowed extra_options for the commands that
507 our %allowed_options = (
508 "--no-merges" => [ qw(rss atom log shortlog history) ],
511 # fill %input_params with the CGI parameters. All values except for 'opt'
512 # should be single values, but opt can be an array. We should probably
513 # build an array of parameters that can be multi-valued, but since for the time
514 # being it's only this one, we just single it out
515 while (my ($name, $symbol) = each %cgi_param_mapping) {
516 if ($symbol eq 'opt') {
517 $input_params{$name} = [ $cgi->param($symbol) ];
519 $input_params{$name} = $cgi->param($symbol);
523 # now read PATH_INFO and update the parameter list for missing parameters
524 sub evaluate_path_info
{
525 return if defined $input_params{'project'};
526 return if !$path_info;
527 $path_info =~ s
,^/+,,;
528 return if !$path_info;
530 # find which part of PATH_INFO is project
531 my $project = $path_info;
533 while ($project && !check_head_link
("$projectroot/$project")) {
534 $project =~ s
,/*[^/]*$,,;
536 return unless $project;
537 $input_params{'project'} = $project;
539 # do not change any parameters if an action is given using the query string
540 return if $input_params{'action'};
541 $path_info =~ s
,^\Q
$project\E
/*,,;
543 # next, check if we have an action
544 my $action = $path_info;
546 if (exists $actions{$action}) {
547 $path_info =~ s
,^$action/*,,;
548 $input_params{'action'} = $action;
551 # list of actions that want hash_base instead of hash, but can have no
552 # pathname (f) parameter
559 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
560 my ($parentrefname, $parentpathname, $refname, $pathname) =
561 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?(.+?)(?::(.+))?$/);
563 # first, analyze the 'current' part
564 if (defined $pathname) {
565 # we got "branch:filename" or "branch:dir/"
566 # we could use git_get_type(branch:pathname), but:
567 # - it needs $git_dir
568 # - it does a git() call
569 # - the convention of terminating directories with a slash
570 # makes it superfluous
571 # - embedding the action in the PATH_INFO would make it even
573 $pathname =~ s
,^/+,,;
574 if (!$pathname || substr($pathname, -1) eq "/") {
575 $input_params{'action'} ||= "tree";
578 # the default action depends on whether we had parent info
580 if ($parentrefname) {
581 $input_params{'action'} ||= "blobdiff_plain";
583 $input_params{'action'} ||= "blob_plain";
586 $input_params{'hash_base'} ||= $refname;
587 $input_params{'file_name'} ||= $pathname;
588 } elsif (defined $refname) {
589 # we got "branch". In this case we have to choose if we have to
590 # set hash or hash_base.
592 # Most of the actions without a pathname only want hash to be
593 # set, except for the ones specified in @wants_base that want
594 # hash_base instead. It should also be noted that hand-crafted
595 # links having 'history' as an action and no pathname or hash
596 # set will fail, but that happens regardless of PATH_INFO.
597 $input_params{'action'} ||= "shortlog";
598 if (grep { $_ eq $input_params{'action'} } @wants_base) {
599 $input_params{'hash_base'} ||= $refname;
601 $input_params{'hash'} ||= $refname;
605 # next, handle the 'parent' part, if present
606 if (defined $parentrefname) {
607 # a missing pathspec defaults to the 'current' filename, allowing e.g.
608 # someproject/blobdiff/oldrev..newrev:/filename
609 if ($parentpathname) {
610 $parentpathname =~ s
,^/+,,;
611 $parentpathname =~ s
,/$,,;
612 $input_params{'file_parent'} ||= $parentpathname;
614 $input_params{'file_parent'} ||= $input_params{'file_name'};
616 # we assume that hash_parent_base is wanted if a path was specified,
617 # or if the action wants hash_base instead of hash
618 if (defined $input_params{'file_parent'} ||
619 grep { $_ eq $input_params{'action'} } @wants_base) {
620 $input_params{'hash_parent_base'} ||= $parentrefname;
622 $input_params{'hash_parent'} ||= $parentrefname;
626 # for the snapshot action, we allow URLs in the form
627 # $project/snapshot/$hash.ext
628 # where .ext determines the snapshot and gets removed from the
629 # passed $refname to provide the $hash.
631 # To be able to tell that $refname includes the format extension, we
632 # require the following two conditions to be satisfied:
633 # - the hash input parameter MUST have been set from the $refname part
634 # of the URL (i.e. they must be equal)
635 # - the snapshot format MUST NOT have been defined already (e.g. from
637 # It's also useless to try any matching unless $refname has a dot,
638 # so we check for that too
639 if (defined $input_params{'action'} &&
640 $input_params{'action'} eq 'snapshot' &&
641 defined $refname && index($refname, '.') != -1 &&
642 $refname eq $input_params{'hash'} &&
643 !defined $input_params{'snapshot_format'}) {
644 # We loop over the known snapshot formats, checking for
645 # extensions. Allowed extensions are both the defined suffix
646 # (which includes the initial dot already) and the snapshot
647 # format key itself, with a prepended dot
648 while (my ($fmt, %opt) = each %known_snapshot_formats) {
651 $hash =~ s/(\Q$opt{'suffix'}\E|\Q.$fmt\E)$//;
652 next unless $sfx = $1;
653 # a valid suffix was found, so set the snapshot format
654 # and reset the hash parameter
655 $input_params{'snapshot_format'} = $fmt;
656 $input_params{'hash'} = $hash;
657 # we also set the format suffix to the one requested
658 # in the URL: this way a request for e.g. .tgz returns
659 # a .tgz instead of a .tar.gz
660 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
665 evaluate_path_info
();
667 our $action = $input_params{'action'};
668 if (defined $action) {
669 if (!validate_action
($action)) {
670 die_error
(400, "Invalid action parameter");
674 # parameters which are pathnames
675 our $project = $input_params{'project'};
676 if (defined $project) {
677 if (!validate_project
($project)) {
679 die_error
(404, "No such project");
683 our $file_name = $input_params{'file_name'};
684 if (defined $file_name) {
685 if (!validate_pathname
($file_name)) {
686 die_error
(400, "Invalid file parameter");
690 our $file_parent = $input_params{'file_parent'};
691 if (defined $file_parent) {
692 if (!validate_pathname
($file_parent)) {
693 die_error
(400, "Invalid file parent parameter");
697 # parameters which are refnames
698 our $hash = $input_params{'hash'};
700 if (!validate_refname
($hash)) {
701 die_error
(400, "Invalid hash parameter");
705 our $hash_parent = $input_params{'hash_parent'};
706 if (defined $hash_parent) {
707 if (!validate_refname
($hash_parent)) {
708 die_error
(400, "Invalid hash parent parameter");
712 our $hash_base = $input_params{'hash_base'};
713 if (defined $hash_base) {
714 if (!validate_refname
($hash_base)) {
715 die_error
(400, "Invalid hash base parameter");
719 our @extra_options = @
{$input_params{'extra_options'}};
720 # @extra_options is always defined, since it can only be (currently) set from
721 # CGI, and $cgi->param() returns the empty array in array context if the param
723 foreach my $opt (@extra_options) {
724 if (not exists $allowed_options{$opt}) {
725 die_error
(400, "Invalid option parameter");
727 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
728 die_error
(400, "Invalid option parameter for this action");
732 our $hash_parent_base = $input_params{'hash_parent_base'};
733 if (defined $hash_parent_base) {
734 if (!validate_refname
($hash_parent_base)) {
735 die_error
(400, "Invalid hash parent base parameter");
740 our $page = $input_params{'page'};
742 if ($page =~ m/[^0-9]/) {
743 die_error
(400, "Invalid page parameter");
747 our $searchtype = $input_params{'searchtype'};
748 if (defined $searchtype) {
749 if ($searchtype =~ m/[^a-z]/) {
750 die_error
(400, "Invalid searchtype parameter");
754 our $search_use_regexp = $input_params{'search_use_regexp'};
756 our $searchtext = $input_params{'searchtext'};
758 if (defined $searchtext) {
759 if (length($searchtext) < 2) {
760 die_error
(403, "At least two characters are required for search parameter");
762 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
765 # path to the current git repository
767 $git_dir = "$projectroot/$project" if $project;
769 # list of supported snapshot formats
770 our @snapshot_fmts = gitweb_check_feature
('snapshot');
771 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
774 if (!defined $action) {
776 $action = git_get_type
($hash);
777 } elsif (defined $hash_base && defined $file_name) {
778 $action = git_get_type
("$hash_base:$file_name");
779 } elsif (defined $project) {
782 $action = 'project_list';
785 if (!defined($actions{$action})) {
786 die_error
(400, "Unknown action");
788 if ($action !~ m/^(opml|project_list|project_index)$/ &&
790 die_error
(400, "Project needed");
792 $actions{$action}->();
795 ## ======================================================================
800 # default is to use -absolute url() i.e. $my_uri
801 my $href = $params{-full
} ?
$my_url : $my_uri;
803 $params{'project'} = $project unless exists $params{'project'};
805 if ($params{-replay
}) {
806 while (my ($name, $symbol) = each %cgi_param_mapping) {
807 if (!exists $params{$name}) {
808 $params{$name} = $input_params{$name};
813 my ($use_pathinfo) = gitweb_check_feature
('pathinfo');
815 # try to put as many parameters as possible in PATH_INFO:
818 # - hash_parent or hash_parent_base:/file_parent
819 # - hash or hash_base:/filename
820 # - the snapshot_format as an appropriate suffix
822 # When the script is the root DirectoryIndex for the domain,
823 # $href here would be something like http://gitweb.example.com/
824 # Thus, we strip any trailing / from $href, to spare us double
825 # slashes in the final URL
828 # Then add the project name, if present
829 $href .= "/".esc_url
($params{'project'}) if defined $params{'project'};
830 delete $params{'project'};
832 # since we destructively absorb parameters, we keep this
833 # boolean that remembers if we're handling a snapshot
834 my $is_snapshot = $params{'action'} eq 'snapshot';
836 # Summary just uses the project path URL, any other action is
838 if (defined $params{'action'}) {
839 $href .= "/".esc_url
($params{'action'}) unless $params{'action'} eq 'summary';
840 delete $params{'action'};
843 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
844 # stripping nonexistent or useless pieces
845 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
846 || $params{'hash_parent'} || $params{'hash'});
847 if (defined $params{'hash_base'}) {
848 if (defined $params{'hash_parent_base'}) {
849 $href .= esc_url
($params{'hash_parent_base'});
850 # skip the file_parent if it's the same as the file_name
851 delete $params{'file_parent'} if $params{'file_parent'} eq $params{'file_name'};
852 if (defined $params{'file_parent'} && $params{'file_parent'} !~ /\.\./) {
853 $href .= ":/".esc_url
($params{'file_parent'});
854 delete $params{'file_parent'};
857 delete $params{'hash_parent'};
858 delete $params{'hash_parent_base'};
859 } elsif (defined $params{'hash_parent'}) {
860 $href .= esc_url
($params{'hash_parent'}). "..";
861 delete $params{'hash_parent'};
864 $href .= esc_url
($params{'hash_base'});
865 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
866 $href .= ":/".esc_url
($params{'file_name'});
867 delete $params{'file_name'};
869 delete $params{'hash'};
870 delete $params{'hash_base'};
871 } elsif (defined $params{'hash'}) {
872 $href .= esc_url
($params{'hash'});
873 delete $params{'hash'};
876 # If the action was a snapshot, we can absorb the
877 # snapshot_format parameter too
879 my $fmt = $params{'snapshot_format'};
880 # snapshot_format should always be defined when href()
881 # is called, but just in case some code forgets, we
882 # fall back to the default
883 $fmt ||= $snapshot_fmts[0];
884 $href .= $known_snapshot_formats{$fmt}{'suffix'};
885 delete $params{'snapshot_format'};
889 # now encode the parameters explicitly
891 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
892 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
893 if (defined $params{$name}) {
894 if (ref($params{$name}) eq "ARRAY") {
895 foreach my $par (@
{$params{$name}}) {
896 push @result, $symbol . "=" . esc_param
($par);
899 push @result, $symbol . "=" . esc_param
($params{$name});
903 $href .= "?" . join(';', @result) if scalar @result;
909 ## ======================================================================
910 ## validation, quoting/unquoting and escaping
912 sub validate_action
{
913 my $input = shift || return undef;
914 return undef unless exists $actions{$input};
918 sub validate_project
{
919 my $input = shift || return undef;
920 if (!validate_pathname
($input) ||
921 !(-d
"$projectroot/$input") ||
922 !check_export_ok
("$projectroot/$input") ||
923 ($strict_export && !project_in_list
($input))) {
930 sub validate_pathname
{
931 my $input = shift || return undef;
933 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
934 # at the beginning, at the end, and between slashes.
935 # also this catches doubled slashes
936 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
940 if ($input =~ m!\0!) {
946 sub validate_refname
{
947 my $input = shift || return undef;
949 # textual hashes are O.K.
950 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
953 # it must be correct pathname
954 $input = validate_pathname
($input)
956 # restrictions on ref name according to git-check-ref-format
957 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
963 # decode sequences of octets in utf8 into Perl's internal form,
964 # which is utf-8 with utf8 flag set if needed. gitweb writes out
965 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
968 if (utf8
::valid
($str)) {
972 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
976 # quote unsafe chars, but keep the slash, even when it's not
977 # correct, but quoted slashes look too horrible in bookmarks
980 $str =~ s/([^A-Za-z0-9\-_.~()\/:@])/sprintf
("%%%02X", ord($1))/eg
;
986 # quote unsafe chars in whole URL, so some charactrs cannot be quoted
989 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&=])/sprintf
("%%%02X", ord($1))/eg
;
995 # replace invalid utf8 character with SUBSTITUTION sequence
1000 $str = to_utf8
($str);
1001 $str = $cgi->escapeHTML($str);
1002 if ($opts{'-nbsp'}) {
1003 $str =~ s/ / /g;
1005 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1009 # quote control characters and escape filename to HTML
1014 $str = to_utf8
($str);
1015 $str = $cgi->escapeHTML($str);
1016 if ($opts{'-nbsp'}) {
1017 $str =~ s/ / /g;
1019 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1023 # Make control characters "printable", using character escape codes (CEC)
1027 my %es = ( # character escape codes, aka escape sequences
1028 "\t" => '\t', # tab (HT)
1029 "\n" => '\n', # line feed (LF)
1030 "\r" => '\r', # carrige return (CR)
1031 "\f" => '\f', # form feed (FF)
1032 "\b" => '\b', # backspace (BS)
1033 "\a" => '\a', # alarm (bell) (BEL)
1034 "\e" => '\e', # escape (ESC)
1035 "\013" => '\v', # vertical tab (VT)
1036 "\000" => '\0', # nul character (NUL)
1038 my $chr = ( (exists $es{$cntrl})
1040 : sprintf('\%2x', ord($cntrl)) );
1041 if ($opts{-nohtml
}) {
1044 return "<span class=\"cntrl\">$chr</span>";
1048 # Alternatively use unicode control pictures codepoints,
1049 # Unicode "printable representation" (PR)
1054 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1055 if ($opts{-nohtml
}) {
1058 return "<span class=\"cntrl\">$chr</span>";
1062 # git may return quoted and escaped filenames
1068 my %es = ( # character escape codes, aka escape sequences
1069 't' => "\t", # tab (HT, TAB)
1070 'n' => "\n", # newline (NL)
1071 'r' => "\r", # return (CR)
1072 'f' => "\f", # form feed (FF)
1073 'b' => "\b", # backspace (BS)
1074 'a' => "\a", # alarm (bell) (BEL)
1075 'e' => "\e", # escape (ESC)
1076 'v' => "\013", # vertical tab (VT)
1079 if ($seq =~ m/^[0-7]{1,3}$/) {
1080 # octal char sequence
1081 return chr(oct($seq));
1082 } elsif (exists $es{$seq}) {
1083 # C escape sequence, aka character escape code
1086 # quoted ordinary character
1090 if ($str =~ m/^"(.*)"$/) {
1093 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1098 # escape tabs (convert tabs to spaces)
1102 while ((my $pos = index($line, "\t")) != -1) {
1103 if (my $count = (8 - ($pos % 8))) {
1104 my $spaces = ' ' x
$count;
1105 $line =~ s/\t/$spaces/;
1112 sub project_in_list
{
1113 my $project = shift;
1114 my @list = git_get_projects_list
();
1115 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1118 ## ----------------------------------------------------------------------
1119 ## HTML aware string manipulation
1121 # Try to chop given string on a word boundary between position
1122 # $len and $len+$add_len. If there is no word boundary there,
1123 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1124 # (marking chopped part) would be longer than given string.
1128 my $add_len = shift || 10;
1129 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1131 # Make sure perl knows it is utf8 encoded so we don't
1132 # cut in the middle of a utf8 multibyte char.
1133 $str = to_utf8
($str);
1135 # allow only $len chars, but don't cut a word if it would fit in $add_len
1136 # if it doesn't fit, cut it if it's still longer than the dots we would add
1137 # remove chopped character entities entirely
1139 # when chopping in the middle, distribute $len into left and right part
1140 # return early if chopping wouldn't make string shorter
1141 if ($where eq 'center') {
1142 return $str if ($len + 5 >= length($str)); # filler is length 5
1145 return $str if ($len + 4 >= length($str)); # filler is length 4
1148 # regexps: ending and beginning with word part up to $add_len
1149 my $endre = qr/.{$len}\w{0,$add_len}/;
1150 my $begre = qr/\w{0,$add_len}.{$len}/;
1152 if ($where eq 'left') {
1153 $str =~ m/^(.*?)($begre)$/;
1154 my ($lead, $body) = ($1, $2);
1155 if (length($lead) > 4) {
1156 $body =~ s/^[^;]*;// if ($lead =~ m/&[^;]*$/);
1159 return "$lead$body";
1161 } elsif ($where eq 'center') {
1162 $str =~ m/^($endre)(.*)$/;
1163 my ($left, $str) = ($1, $2);
1164 $str =~ m/^(.*?)($begre)$/;
1165 my ($mid, $right) = ($1, $2);
1166 if (length($mid) > 5) {
1167 $left =~ s/&[^;]*$//;
1168 $right =~ s/^[^;]*;// if ($mid =~ m/&[^;]*$/);
1171 return "$left$mid$right";
1174 $str =~ m/^($endre)(.*)$/;
1177 if (length($tail) > 4) {
1178 $body =~ s/&[^;]*$//;
1181 return "$body$tail";
1185 # takes the same arguments as chop_str, but also wraps a <span> around the
1186 # result with a title attribute if it does get chopped. Additionally, the
1187 # string is HTML-escaped.
1188 sub chop_and_escape_str
{
1191 my $chopped = chop_str
(@_);
1192 if ($chopped eq $str) {
1193 return esc_html
($chopped);
1195 $str =~ s/([[:cntrl:]])/?/g;
1196 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1200 ## ----------------------------------------------------------------------
1201 ## functions returning short strings
1203 # CSS class for given age value (in seconds)
1207 if (!defined $age) {
1209 } elsif ($age < 60*60*2) {
1211 } elsif ($age < 60*60*24*2) {
1218 # convert age in seconds to "nn units ago" string
1223 if ($age > 60*60*24*365*2) {
1224 $age_str = (int $age/60/60/24/365);
1225 $age_str .= " years ago";
1226 } elsif ($age > 60*60*24*(365/12)*2) {
1227 $age_str = int $age/60/60/24/(365/12);
1228 $age_str .= " months ago";
1229 } elsif ($age > 60*60*24*7*2) {
1230 $age_str = int $age/60/60/24/7;
1231 $age_str .= " weeks ago";
1232 } elsif ($age > 60*60*24*2) {
1233 $age_str = int $age/60/60/24;
1234 $age_str .= " days ago";
1235 } elsif ($age > 60*60*2) {
1236 $age_str = int $age/60/60;
1237 $age_str .= " hours ago";
1238 } elsif ($age > 60*2) {
1239 $age_str = int $age/60;
1240 $age_str .= " min ago";
1241 } elsif ($age > 2) {
1242 $age_str = int $age;
1243 $age_str .= " sec ago";
1245 $age_str .= " right now";
1251 S_IFINVALID
=> 0030000,
1252 S_IFGITLINK
=> 0160000,
1255 # submodule/subproject, a commit object reference
1256 sub S_ISGITLINK
($) {
1259 return (($mode & S_IFMT
) == S_IFGITLINK
)
1262 # convert file mode in octal to symbolic file mode string
1264 my $mode = oct shift;
1266 if (S_ISGITLINK
($mode)) {
1267 return 'm---------';
1268 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1269 return 'drwxr-xr-x';
1270 } elsif (S_ISLNK
($mode)) {
1271 return 'lrwxrwxrwx';
1272 } elsif (S_ISREG
($mode)) {
1273 # git cares only about the executable bit
1274 if ($mode & S_IXUSR
) {
1275 return '-rwxr-xr-x';
1277 return '-rw-r--r--';
1280 return '----------';
1284 # convert file mode in octal to file type string
1288 if ($mode !~ m/^[0-7]+$/) {
1294 if (S_ISGITLINK
($mode)) {
1296 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1298 } elsif (S_ISLNK
($mode)) {
1300 } elsif (S_ISREG
($mode)) {
1307 # convert file mode in octal to file type description string
1308 sub file_type_long
{
1311 if ($mode !~ m/^[0-7]+$/) {
1317 if (S_ISGITLINK
($mode)) {
1319 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1321 } elsif (S_ISLNK
($mode)) {
1323 } elsif (S_ISREG
($mode)) {
1324 if ($mode & S_IXUSR
) {
1325 return "executable";
1335 ## ----------------------------------------------------------------------
1336 ## functions returning short HTML fragments, or transforming HTML fragments
1337 ## which don't belong to other sections
1339 # format line of commit message.
1340 sub format_log_line_html
{
1343 $line = esc_html
($line, -nbsp
=>1);
1344 if ($line =~ m/([0-9a-fA-F]{8,40})/) {
1347 $cgi->a({-href
=> href
(action
=>"object", hash
=>$hash_text),
1348 -class => "text"}, $hash_text);
1349 $line =~ s/$hash_text/$link/;
1354 # format marker of refs pointing to given object
1356 # the destination action is chosen based on object type and current context:
1357 # - for annotated tags, we choose the tag view unless it's the current view
1358 # already, in which case we go to shortlog view
1359 # - for other refs, we keep the current view if we're in history, shortlog or
1360 # log view, and select shortlog otherwise
1361 sub format_ref_marker
{
1362 my ($refs, $id) = @_;
1365 if (defined $refs->{$id}) {
1366 foreach my $ref (@
{$refs->{$id}}) {
1367 # this code exploits the fact that non-lightweight tags are the
1368 # only indirect objects, and that they are the only objects for which
1369 # we want to use tag instead of shortlog as action
1370 my ($type, $name) = qw();
1371 my $indirect = ($ref =~ s/\^\{\}$//);
1372 # e.g. tags/v2.6.11 or heads/next
1373 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1382 $class .= " indirect" if $indirect;
1384 my $dest_action = "shortlog";
1387 $dest_action = "tag" unless $action eq "tag";
1388 } elsif ($action =~ /^(history|(short)?log)$/) {
1389 $dest_action = $action;
1393 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1396 my $link = $cgi->a({
1398 action
=>$dest_action,
1402 $markers .= " <span class=\"$class\" title=\"$ref\">" .
1408 return ' <span class="refs">'. $markers . '</span>';
1414 # format, perhaps shortened and with markers, title line
1415 sub format_subject_html
{
1416 my ($long, $short, $href, $extra) = @_;
1417 $extra = '' unless defined($extra);
1419 if (length($short) < length($long)) {
1420 return $cgi->a({-href
=> $href, -class => "list subject",
1421 -title
=> to_utf8
($long)},
1422 esc_html
($short) . $extra);
1424 return $cgi->a({-href
=> $href, -class => "list subject"},
1425 esc_html
($long) . $extra);
1429 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1430 sub format_git_diff_header_line
{
1432 my $diffinfo = shift;
1433 my ($from, $to) = @_;
1435 if ($diffinfo->{'nparents'}) {
1437 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1438 if ($to->{'href'}) {
1439 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1440 esc_path
($to->{'file'}));
1441 } else { # file was deleted (no href)
1442 $line .= esc_path
($to->{'file'});
1446 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1447 if ($from->{'href'}) {
1448 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
1449 'a/' . esc_path
($from->{'file'}));
1450 } else { # file was added (no href)
1451 $line .= 'a/' . esc_path
($from->{'file'});
1454 if ($to->{'href'}) {
1455 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1456 'b/' . esc_path
($to->{'file'}));
1457 } else { # file was deleted
1458 $line .= 'b/' . esc_path
($to->{'file'});
1462 return "<div class=\"diff header\">$line</div>\n";
1465 # format extended diff header line, before patch itself
1466 sub format_extended_diff_header_line
{
1468 my $diffinfo = shift;
1469 my ($from, $to) = @_;
1472 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1473 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1474 esc_path
($from->{'file'}));
1476 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1477 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1478 esc_path
($to->{'file'}));
1480 # match single <mode>
1481 if ($line =~ m/\s(\d{6})$/) {
1482 $line .= '<span class="info"> (' .
1483 file_type_long
($1) .
1487 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1488 # can match only for combined diff
1490 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1491 if ($from->{'href'}[$i]) {
1492 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
1494 substr($diffinfo->{'from_id'}[$i],0,7));
1499 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1502 if ($to->{'href'}) {
1503 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1504 substr($diffinfo->{'to_id'},0,7));
1509 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
1510 # can match only for ordinary diff
1511 my ($from_link, $to_link);
1512 if ($from->{'href'}) {
1513 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
1514 substr($diffinfo->{'from_id'},0,7));
1516 $from_link = '0' x
7;
1518 if ($to->{'href'}) {
1519 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1520 substr($diffinfo->{'to_id'},0,7));
1524 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
1525 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
1528 return $line . "<br/>\n";
1531 # format from-file/to-file diff header
1532 sub format_diff_from_to_header
{
1533 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
1538 #assert($line =~ m/^---/) if DEBUG;
1539 # no extra formatting for "^--- /dev/null"
1540 if (! $diffinfo->{'nparents'}) {
1541 # ordinary (single parent) diff
1542 if ($line =~ m!^--- "?a/!) {
1543 if ($from->{'href'}) {
1545 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1546 esc_path
($from->{'file'}));
1549 esc_path
($from->{'file'});
1552 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1555 # combined diff (merge commit)
1556 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1557 if ($from->{'href'}[$i]) {
1559 $cgi->a({-href
=>href
(action
=>"blobdiff",
1560 hash_parent
=>$diffinfo->{'from_id'}[$i],
1561 hash_parent_base
=>$parents[$i],
1562 file_parent
=>$from->{'file'}[$i],
1563 hash
=>$diffinfo->{'to_id'},
1565 file_name
=>$to->{'file'}),
1567 -title
=>"diff" . ($i+1)},
1570 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
1571 esc_path
($from->{'file'}[$i]));
1573 $line = '--- /dev/null';
1575 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1580 #assert($line =~ m/^\+\+\+/) if DEBUG;
1581 # no extra formatting for "^+++ /dev/null"
1582 if ($line =~ m!^\+\+\+ "?b/!) {
1583 if ($to->{'href'}) {
1585 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1586 esc_path
($to->{'file'}));
1589 esc_path
($to->{'file'});
1592 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
1597 # create note for patch simplified by combined diff
1598 sub format_diff_cc_simplified
{
1599 my ($diffinfo, @parents) = @_;
1602 $result .= "<div class=\"diff header\">" .
1604 if (!is_deleted
($diffinfo)) {
1605 $result .= $cgi->a({-href
=> href
(action
=>"blob",
1607 hash
=>$diffinfo->{'to_id'},
1608 file_name
=>$diffinfo->{'to_file'}),
1610 esc_path
($diffinfo->{'to_file'}));
1612 $result .= esc_path
($diffinfo->{'to_file'});
1614 $result .= "</div>\n" . # class="diff header"
1615 "<div class=\"diff nodifferences\">" .
1617 "</div>\n"; # class="diff nodifferences"
1622 # format patch (diff) line (not to be used for diff headers)
1623 sub format_diff_line
{
1625 my ($from, $to) = @_;
1626 my $diff_class = "";
1630 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
1632 my $prefix = substr($line, 0, scalar @
{$from->{'href'}});
1633 if ($line =~ m/^\@{3}/) {
1634 $diff_class = " chunk_header";
1635 } elsif ($line =~ m/^\\/) {
1636 $diff_class = " incomplete";
1637 } elsif ($prefix =~ tr/+/+/) {
1638 $diff_class = " add";
1639 } elsif ($prefix =~ tr/-/-/) {
1640 $diff_class = " rem";
1643 # assume ordinary diff
1644 my $char = substr($line, 0, 1);
1646 $diff_class = " add";
1647 } elsif ($char eq '-') {
1648 $diff_class = " rem";
1649 } elsif ($char eq '@') {
1650 $diff_class = " chunk_header";
1651 } elsif ($char eq "\\") {
1652 $diff_class = " incomplete";
1655 $line = untabify
($line);
1656 if ($from && $to && $line =~ m/^\@{2} /) {
1657 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
1658 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
1660 $from_lines = 0 unless defined $from_lines;
1661 $to_lines = 0 unless defined $to_lines;
1663 if ($from->{'href'}) {
1664 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
1665 -class=>"list"}, $from_text);
1667 if ($to->{'href'}) {
1668 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1669 -class=>"list"}, $to_text);
1671 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
1672 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1673 return "<div class=\"diff$diff_class\">$line</div>\n";
1674 } elsif ($from && $to && $line =~ m/^\@{3}/) {
1675 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
1676 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
1678 @from_text = split(' ', $ranges);
1679 for (my $i = 0; $i < @from_text; ++$i) {
1680 ($from_start[$i], $from_nlines[$i]) =
1681 (split(',', substr($from_text[$i], 1)), 0);
1684 $to_text = pop @from_text;
1685 $to_start = pop @from_start;
1686 $to_nlines = pop @from_nlines;
1688 $line = "<span class=\"chunk_info\">$prefix ";
1689 for (my $i = 0; $i < @from_text; ++$i) {
1690 if ($from->{'href'}[$i]) {
1691 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
1692 -class=>"list"}, $from_text[$i]);
1694 $line .= $from_text[$i];
1698 if ($to->{'href'}) {
1699 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1700 -class=>"list"}, $to_text);
1704 $line .= " $prefix</span>" .
1705 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1706 return "<div class=\"diff$diff_class\">$line</div>\n";
1708 return "<div class=\"diff$diff_class\">" . esc_html
($line, -nbsp
=>1) . "</div>\n";
1711 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
1712 # linked. Pass the hash of the tree/commit to snapshot.
1713 sub format_snapshot_links
{
1715 my $num_fmts = @snapshot_fmts;
1716 if ($num_fmts > 1) {
1717 # A parenthesized list of links bearing format names.
1718 # e.g. "snapshot (_tar.gz_ _zip_)"
1719 return "snapshot (" . join(' ', map
1726 }, $known_snapshot_formats{$_}{'display'})
1727 , @snapshot_fmts) . ")";
1728 } elsif ($num_fmts == 1) {
1729 # A single "snapshot" link whose tooltip bears the format name.
1731 my ($fmt) = @snapshot_fmts;
1737 snapshot_format
=>$fmt
1739 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
1741 } else { # $num_fmts == 0
1746 ## ......................................................................
1747 ## functions returning values to be passed, perhaps after some
1748 ## transformation, to other functions; e.g. returning arguments to href()
1750 # returns hash to be passed to href to generate gitweb URL
1751 # in -title key it returns description of link
1753 my $format = shift || 'Atom';
1754 my %res = (action
=> lc($format));
1756 # feed links are possible only for project views
1757 return unless (defined $project);
1758 # some views should link to OPML, or to generic project feed,
1759 # or don't have specific feed yet (so they should use generic)
1760 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
1763 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
1764 # from tag links; this also makes possible to detect branch links
1765 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
1766 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
1769 # find log type for feed description (title)
1771 if (defined $file_name) {
1772 $type = "history of $file_name";
1773 $type .= "/" if ($action eq 'tree');
1774 $type .= " on '$branch'" if (defined $branch);
1776 $type = "log of $branch" if (defined $branch);
1779 $res{-title
} = $type;
1780 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
1781 $res{'file_name'} = $file_name;
1786 ## ----------------------------------------------------------------------
1787 ## git utility subroutines, invoking git commands
1789 # returns path to the core git executable and the --git-dir parameter as list
1791 return $GIT, '--git-dir='.$git_dir;
1794 # quote the given arguments for passing them to the shell
1795 # quote_command("command", "arg 1", "arg with ' and ! characters")
1796 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
1797 # Try to avoid using this function wherever possible.
1800 map( { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ ));
1803 # get HEAD ref of given project as hash
1804 sub git_get_head_hash
{
1805 my $project = shift;
1806 my $o_git_dir = $git_dir;
1808 $git_dir = "$projectroot/$project";
1809 if (open my $fd, "-|", git_cmd
(), "rev-parse", "--verify", "HEAD") {
1812 if (defined $head && $head =~ /^([0-9a-fA-F]{40})$/) {
1816 if (defined $o_git_dir) {
1817 $git_dir = $o_git_dir;
1822 # get type of given object
1826 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
1828 close $fd or return;
1833 # repository configuration
1834 our $config_file = '';
1837 # store multiple values for single key as anonymous array reference
1838 # single values stored directly in the hash, not as [ <value> ]
1839 sub hash_set_multi
{
1840 my ($hash, $key, $value) = @_;
1842 if (!exists $hash->{$key}) {
1843 $hash->{$key} = $value;
1844 } elsif (!ref $hash->{$key}) {
1845 $hash->{$key} = [ $hash->{$key}, $value ];
1847 push @
{$hash->{$key}}, $value;
1851 # return hash of git project configuration
1852 # optionally limited to some section, e.g. 'gitweb'
1853 sub git_parse_project_config
{
1854 my $section_regexp = shift;
1859 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
1862 while (my $keyval = <$fh>) {
1864 my ($key, $value) = split(/\n/, $keyval, 2);
1866 hash_set_multi
(\
%config, $key, $value)
1867 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
1874 # convert config value to boolean, 'true' or 'false'
1875 # no value, number > 0, 'true' and 'yes' values are true
1876 # rest of values are treated as false (never as error)
1877 sub config_to_bool
{
1880 # strip leading and trailing whitespace
1884 return (!defined $val || # section.key
1885 ($val =~ /^\d+$/ && $val) || # section.key = 1
1886 ($val =~ /^(?:true|yes)$/i)); # section.key = true
1889 # convert config value to simple decimal number
1890 # an optional value suffix of 'k', 'm', or 'g' will cause the value
1891 # to be multiplied by 1024, 1048576, or 1073741824
1895 # strip leading and trailing whitespace
1899 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
1901 # unknown unit is treated as 1
1902 return $num * ($unit eq 'g' ?
1073741824 :
1903 $unit eq 'm' ?
1048576 :
1904 $unit eq 'k' ?
1024 : 1);
1909 # convert config value to array reference, if needed
1910 sub config_to_multi
{
1913 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
1916 sub git_get_project_config
{
1917 my ($key, $type) = @_;
1920 return unless ($key);
1921 $key =~ s/^gitweb\.//;
1922 return if ($key =~ m/\W/);
1925 if (defined $type) {
1928 unless ($type eq 'bool' || $type eq 'int');
1932 if (!defined $config_file ||
1933 $config_file ne "$git_dir/config") {
1934 %config = git_parse_project_config
('gitweb');
1935 $config_file = "$git_dir/config";
1939 if (!defined $type) {
1940 return $config{"gitweb.$key"};
1941 } elsif ($type eq 'bool') {
1942 # backward compatibility: 'git config --bool' returns true/false
1943 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
1944 } elsif ($type eq 'int') {
1945 return config_to_int
($config{"gitweb.$key"});
1947 return $config{"gitweb.$key"};
1950 # get hash of given path at given ref
1951 sub git_get_hash_by_path
{
1953 my $path = shift || return undef;
1958 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
1959 or die_error
(500, "Open git-ls-tree failed");
1961 close $fd or return undef;
1963 if (!defined $line) {
1964 # there is no tree or hash given by $path at $base
1968 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
1969 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
1970 if (defined $type && $type ne $2) {
1971 # type doesn't match
1977 # get path of entry with given hash at given tree-ish (ref)
1978 # used to get 'from' filename for combined diff (merge commit) for renames
1979 sub git_get_path_by_hash
{
1980 my $base = shift || return;
1981 my $hash = shift || return;
1985 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
1987 while (my $line = <$fd>) {
1990 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
1991 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
1992 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2001 ## ......................................................................
2002 ## git utility functions, directly accessing git repository
2004 sub git_get_project_description
{
2007 $git_dir = "$projectroot/$path";
2008 open my $fd, "$git_dir/description"
2009 or return git_get_project_config
('description');
2012 if (defined $descr) {
2018 sub git_get_project_ctags
{
2022 $git_dir = "$projectroot/$path";
2023 unless (opendir D
, "$git_dir/ctags") {
2026 foreach (grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir(D
)) {
2027 open CT
, $_ or next;
2031 my $ctag = $_; $ctag =~ s
#.*/##;
2032 $ctags->{$ctag} = $val;
2038 sub git_populate_project_tagcloud
{
2041 # First, merge different-cased tags; tags vote on casing
2043 foreach (keys %$ctags) {
2044 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2045 if (not $ctags_lc{lc $_}->{topcount
}
2046 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2047 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2048 $ctags_lc{lc $_}->{topname
} = $_;
2053 if (eval { require HTML
::TagCloud
; 1; }) {
2054 $cloud = HTML
::TagCloud
->new;
2055 foreach (sort keys %ctags_lc) {
2056 # Pad the title with spaces so that the cloud looks
2058 my $title = $ctags_lc{$_}->{topname
};
2059 $title =~ s/ / /g;
2060 $title =~ s/^/ /g;
2061 $title =~ s/$/ /g;
2062 $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count
});
2065 $cloud = \
%ctags_lc;
2070 sub git_show_project_tagcloud
{
2071 my ($cloud, $count) = @_;
2072 print STDERR
ref($cloud)."..\n";
2073 if (ref $cloud eq 'HTML::TagCloud') {
2074 return $cloud->html_and_css($count);
2076 my @tags = sort { $cloud->{$a}->{count
} <=> $cloud->{$b}->{count
} } keys %$cloud;
2077 return '<p align="center">' . join (', ', map {
2078 "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
2079 } splice(@tags, 0, $count)) . '</p>';
2083 sub git_get_project_url_list
{
2086 $git_dir = "$projectroot/$path";
2087 open my $fd, "$git_dir/cloneurl"
2088 or return wantarray ?
2089 @
{ config_to_multi
(git_get_project_config
('url')) } :
2090 config_to_multi
(git_get_project_config
('url'));
2091 my @git_project_url_list = map { chomp; $_ } <$fd>;
2094 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2097 sub git_get_projects_list
{
2102 $filter =~ s/\.git$//;
2104 my ($check_forks) = gitweb_check_feature
('forks');
2106 if (-d
$projects_list) {
2107 # search in directory
2108 my $dir = $projects_list . ($filter ?
"/$filter" : '');
2109 # remove the trailing "/"
2111 my $pfxlen = length("$dir");
2112 my $pfxdepth = ($dir =~ tr!/!!);
2115 follow_fast
=> 1, # follow symbolic links
2116 follow_skip
=> 2, # ignore duplicates
2117 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2119 # skip project-list toplevel, if we get it.
2120 return if (m!^[/.]$!);
2121 # only directories can be git repositories
2122 return unless (-d
$_);
2123 # don't traverse too deep (Find is super slow on os x)
2124 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2125 $File::Find
::prune
= 1;
2129 my $subdir = substr($File::Find
::name
, $pfxlen + 1);
2130 # we check related file in $projectroot
2131 if (check_export_ok
("$projectroot/$filter/$subdir")) {
2132 push @list, { path
=> ($filter ?
"$filter/" : '') . $subdir };
2133 $File::Find
::prune
= 1;
2138 } elsif (-f
$projects_list) {
2139 # read from file(url-encoded):
2140 # 'git%2Fgit.git Linus+Torvalds'
2141 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2142 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2144 open my ($fd), $projects_list or return;
2146 while (my $line = <$fd>) {
2148 my ($path, $owner) = split ' ', $line;
2149 $path = unescape
($path);
2150 $owner = unescape
($owner);
2151 if (!defined $path) {
2154 if ($filter ne '') {
2155 # looking for forks;
2156 my $pfx = substr($path, 0, length($filter));
2157 if ($pfx ne $filter) {
2160 my $sfx = substr($path, length($filter));
2161 if ($sfx !~ /^\/.*\
.git
$/) {
2164 } elsif ($check_forks) {
2166 foreach my $filter (keys %paths) {
2167 # looking for forks;
2168 my $pfx = substr($path, 0, length($filter));
2169 if ($pfx ne $filter) {
2172 my $sfx = substr($path, length($filter));
2173 if ($sfx !~ /^\/.*\
.git
$/) {
2176 # is a fork, don't include it in
2181 if (check_export_ok
("$projectroot/$path")) {
2184 owner
=> to_utf8
($owner),
2187 (my $forks_path = $path) =~ s/\.git$//;
2188 $paths{$forks_path}++;
2196 our $gitweb_project_owner = undef;
2197 sub git_get_project_list_from_file
{
2199 return if (defined $gitweb_project_owner);
2201 $gitweb_project_owner = {};
2202 # read from file (url-encoded):
2203 # 'git%2Fgit.git Linus+Torvalds'
2204 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2205 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2206 if (-f
$projects_list) {
2207 open (my $fd , $projects_list);
2208 while (my $line = <$fd>) {
2210 my ($pr, $ow) = split ' ', $line;
2211 $pr = unescape
($pr);
2212 $ow = unescape
($ow);
2213 $gitweb_project_owner->{$pr} = to_utf8
($ow);
2219 sub git_get_project_owner
{
2220 my $project = shift;
2223 return undef unless $project;
2224 $git_dir = "$projectroot/$project";
2226 if (!defined $gitweb_project_owner) {
2227 git_get_project_list_from_file
();
2230 if (exists $gitweb_project_owner->{$project}) {
2231 $owner = $gitweb_project_owner->{$project};
2233 if (!defined $owner){
2234 $owner = git_get_project_config
('owner');
2236 if (!defined $owner) {
2237 $owner = get_file_owner
("$git_dir");
2243 sub git_get_last_activity
{
2247 $git_dir = "$projectroot/$path";
2248 open($fd, "-|", git_cmd
(), 'for-each-ref',
2249 '--format=%(committer)',
2250 '--sort=-committerdate',
2252 'refs/heads') or return;
2253 my $most_recent = <$fd>;
2254 close $fd or return;
2255 if (defined $most_recent &&
2256 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2258 my $age = time - $timestamp;
2259 return ($age, age_string
($age));
2261 return (undef, undef);
2264 sub git_get_references
{
2265 my $type = shift || "";
2267 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2268 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2269 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
2270 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
2273 while (my $line = <$fd>) {
2275 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2276 if (defined $refs{$1}) {
2277 push @
{$refs{$1}}, $2;
2283 close $fd or return;
2287 sub git_get_rev_name_tags
{
2288 my $hash = shift || return undef;
2290 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
2292 my $name_rev = <$fd>;
2295 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
2298 # catches also '$hash undefined' output
2303 ## ----------------------------------------------------------------------
2304 ## parse to hash functions
2308 my $tz = shift || "-0000";
2311 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2312 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2313 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2314 $date{'hour'} = $hour;
2315 $date{'minute'} = $min;
2316 $date{'mday'} = $mday;
2317 $date{'day'} = $days[$wday];
2318 $date{'month'} = $months[$mon];
2319 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2320 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2321 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2322 $mday, $months[$mon], $hour ,$min;
2323 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2324 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2326 $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2327 my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2328 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2329 $date{'hour_local'} = $hour;
2330 $date{'minute_local'} = $min;
2331 $date{'tz_local'} = $tz;
2332 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2333 1900+$year, $mon+1, $mday,
2334 $hour, $min, $sec, $tz);
2343 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
2344 $tag{'id'} = $tag_id;
2345 while (my $line = <$fd>) {
2347 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2348 $tag{'object'} = $1;
2349 } elsif ($line =~ m/^type (.+)$/) {
2351 } elsif ($line =~ m/^tag (.+)$/) {
2353 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2354 $tag{'author'} = $1;
2357 } elsif ($line =~ m/--BEGIN/) {
2358 push @comment, $line;
2360 } elsif ($line eq "") {
2364 push @comment, <$fd>;
2365 $tag{'comment'} = \
@comment;
2366 close $fd or return;
2367 if (!defined $tag{'name'}) {
2373 sub parse_commit_text
{
2374 my ($commit_text, $withparents) = @_;
2375 my @commit_lines = split '\n', $commit_text;
2378 pop @commit_lines; # Remove '\0'
2380 if (! @commit_lines) {
2384 my $header = shift @commit_lines;
2385 if ($header !~ m/^[0-9a-fA-F]{40}/) {
2388 ($co{'id'}, my @parents) = split ' ', $header;
2389 while (my $line = shift @commit_lines) {
2390 last if $line eq "\n";
2391 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2393 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2395 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2397 $co{'author_epoch'} = $2;
2398 $co{'author_tz'} = $3;
2399 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2400 $co{'author_name'} = $1;
2401 $co{'author_email'} = $2;
2403 $co{'author_name'} = $co{'author'};
2405 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2406 $co{'committer'} = $1;
2407 $co{'committer_epoch'} = $2;
2408 $co{'committer_tz'} = $3;
2409 $co{'committer_name'} = $co{'committer'};
2410 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2411 $co{'committer_name'} = $1;
2412 $co{'committer_email'} = $2;
2414 $co{'committer_name'} = $co{'committer'};
2418 if (!defined $co{'tree'}) {
2421 $co{'parents'} = \
@parents;
2422 $co{'parent'} = $parents[0];
2424 foreach my $title (@commit_lines) {
2427 $co{'title'} = chop_str
($title, 80, 5);
2428 # remove leading stuff of merges to make the interesting part visible
2429 if (length($title) > 50) {
2430 $title =~ s/^Automatic //;
2431 $title =~ s/^merge (of|with) /Merge ... /i;
2432 if (length($title) > 50) {
2433 $title =~ s/(http|rsync):\/\///;
2435 if (length($title) > 50) {
2436 $title =~ s/(master|www|rsync)\.//;
2438 if (length($title) > 50) {
2439 $title =~ s/kernel.org:?//;
2441 if (length($title) > 50) {
2442 $title =~ s/\/pub\/scm//;
2445 $co{'title_short'} = chop_str
($title, 50, 5);
2449 if (! defined $co{'title'} || $co{'title'} eq "") {
2450 $co{'title'} = $co{'title_short'} = '(no commit message)';
2452 # remove added spaces
2453 foreach my $line (@commit_lines) {
2456 $co{'comment'} = \
@commit_lines;
2458 my $age = time - $co{'committer_epoch'};
2460 $co{'age_string'} = age_string
($age);
2461 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2462 if ($age > 60*60*24*7*2) {
2463 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2464 $co{'age_string_age'} = $co{'age_string'};
2466 $co{'age_string_date'} = $co{'age_string'};
2467 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2473 my ($commit_id) = @_;
2478 open my $fd, "-|", git_cmd
(), "rev-list",
2484 or die_error
(500, "Open git-rev-list failed");
2485 %co = parse_commit_text
(<$fd>, 1);
2492 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
2500 open my $fd, "-|", git_cmd
(), "rev-list",
2503 ("--max-count=" . $maxcount),
2504 ("--skip=" . $skip),
2508 ($filename ?
($filename) : ())
2509 or die_error
(500, "Open git-rev-list failed");
2510 while (my $line = <$fd>) {
2511 my %co = parse_commit_text
($line);
2516 return wantarray ?
@cos : \
@cos;
2519 # parse line of git-diff-tree "raw" output
2520 sub parse_difftree_raw_line
{
2524 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
2525 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
2526 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
2527 $res{'from_mode'} = $1;
2528 $res{'to_mode'} = $2;
2529 $res{'from_id'} = $3;
2531 $res{'status'} = $5;
2532 $res{'similarity'} = $6;
2533 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
2534 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
2536 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
2539 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
2540 # combined diff (for merge commit)
2541 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
2542 $res{'nparents'} = length($1);
2543 $res{'from_mode'} = [ split(' ', $2) ];
2544 $res{'to_mode'} = pop @
{$res{'from_mode'}};
2545 $res{'from_id'} = [ split(' ', $3) ];
2546 $res{'to_id'} = pop @
{$res{'from_id'}};
2547 $res{'status'} = [ split('', $4) ];
2548 $res{'to_file'} = unquote
($5);
2550 # 'c512b523472485aef4fff9e57b229d9d243c967f'
2551 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
2552 $res{'commit'} = $1;
2555 return wantarray ?
%res : \
%res;
2558 # wrapper: return parsed line of git-diff-tree "raw" output
2559 # (the argument might be raw line, or parsed info)
2560 sub parsed_difftree_line
{
2561 my $line_or_ref = shift;
2563 if (ref($line_or_ref) eq "HASH") {
2564 # pre-parsed (or generated by hand)
2565 return $line_or_ref;
2567 return parse_difftree_raw_line
($line_or_ref);
2571 # parse line of git-ls-tree output
2572 sub parse_ls_tree_line
($;%) {
2577 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2578 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
2586 $res{'name'} = unquote
($4);
2589 return wantarray ?
%res : \
%res;
2592 # generates _two_ hashes, references to which are passed as 2 and 3 argument
2593 sub parse_from_to_diffinfo
{
2594 my ($diffinfo, $from, $to, @parents) = @_;
2596 if ($diffinfo->{'nparents'}) {
2598 $from->{'file'} = [];
2599 $from->{'href'} = [];
2600 fill_from_file_info
($diffinfo, @parents)
2601 unless exists $diffinfo->{'from_file'};
2602 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2603 $from->{'file'}[$i] =
2604 defined $diffinfo->{'from_file'}[$i] ?
2605 $diffinfo->{'from_file'}[$i] :
2606 $diffinfo->{'to_file'};
2607 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
2608 $from->{'href'}[$i] = href
(action
=>"blob",
2609 hash_base
=>$parents[$i],
2610 hash
=>$diffinfo->{'from_id'}[$i],
2611 file_name
=>$from->{'file'}[$i]);
2613 $from->{'href'}[$i] = undef;
2617 # ordinary (not combined) diff
2618 $from->{'file'} = $diffinfo->{'from_file'};
2619 if ($diffinfo->{'status'} ne "A") { # not new (added) file
2620 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
2621 hash
=>$diffinfo->{'from_id'},
2622 file_name
=>$from->{'file'});
2624 delete $from->{'href'};
2628 $to->{'file'} = $diffinfo->{'to_file'};
2629 if (!is_deleted
($diffinfo)) { # file exists in result
2630 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
2631 hash
=>$diffinfo->{'to_id'},
2632 file_name
=>$to->{'file'});
2634 delete $to->{'href'};
2638 ## ......................................................................
2639 ## parse to array of hashes functions
2641 sub git_get_heads_list
{
2645 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2646 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
2647 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
2650 while (my $line = <$fd>) {
2654 my ($refinfo, $committerinfo) = split(/\0/, $line);
2655 my ($hash, $name, $title) = split(' ', $refinfo, 3);
2656 my ($committer, $epoch, $tz) =
2657 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
2658 $ref_item{'fullname'} = $name;
2659 $name =~ s!^refs/heads/!!;
2661 $ref_item{'name'} = $name;
2662 $ref_item{'id'} = $hash;
2663 $ref_item{'title'} = $title || '(no commit message)';
2664 $ref_item{'epoch'} = $epoch;
2666 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2668 $ref_item{'age'} = "unknown";
2671 push @headslist, \
%ref_item;
2675 return wantarray ?
@headslist : \
@headslist;
2678 sub git_get_tags_list
{
2682 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2683 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
2684 '--format=%(objectname) %(objecttype) %(refname) '.
2685 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
2688 while (my $line = <$fd>) {
2692 my ($refinfo, $creatorinfo) = split(/\0/, $line);
2693 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
2694 my ($creator, $epoch, $tz) =
2695 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
2696 $ref_item{'fullname'} = $name;
2697 $name =~ s!^refs/tags/!!;
2699 $ref_item{'type'} = $type;
2700 $ref_item{'id'} = $id;
2701 $ref_item{'name'} = $name;
2702 if ($type eq "tag") {
2703 $ref_item{'subject'} = $title;
2704 $ref_item{'reftype'} = $reftype;
2705 $ref_item{'refid'} = $refid;
2707 $ref_item{'reftype'} = $type;
2708 $ref_item{'refid'} = $id;
2711 if ($type eq "tag" || $type eq "commit") {
2712 $ref_item{'epoch'} = $epoch;
2714 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2716 $ref_item{'age'} = "unknown";
2720 push @tagslist, \
%ref_item;
2724 return wantarray ?
@tagslist : \
@tagslist;
2727 ## ----------------------------------------------------------------------
2728 ## filesystem-related functions
2730 sub get_file_owner
{
2733 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
2734 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
2735 if (!defined $gcos) {
2739 $owner =~ s/[,;].*$//;
2740 return to_utf8
($owner);
2743 ## ......................................................................
2744 ## mimetype related functions
2746 sub mimetype_guess_file
{
2747 my $filename = shift;
2748 my $mimemap = shift;
2749 -r
$mimemap or return undef;
2752 open(MIME
, $mimemap) or return undef;
2754 next if m/^#/; # skip comments
2755 my ($mime, $exts) = split(/\t+/);
2756 if (defined $exts) {
2757 my @exts = split(/\s+/, $exts);
2758 foreach my $ext (@exts) {
2759 $mimemap{$ext} = $mime;
2765 $filename =~ /\.([^.]*)$/;
2766 return $mimemap{$1};
2769 sub mimetype_guess
{
2770 my $filename = shift;
2772 $filename =~ /\./ or return undef;
2774 if ($mimetypes_file) {
2775 my $file = $mimetypes_file;
2776 if ($file !~ m!^/!) { # if it is relative path
2777 # it is relative to project
2778 $file = "$projectroot/$project/$file";
2780 $mime = mimetype_guess_file
($filename, $file);
2782 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
2788 my $filename = shift;
2791 my $mime = mimetype_guess
($filename);
2792 $mime and return $mime;
2796 return $default_blob_plain_mimetype unless $fd;
2799 return 'text/plain';
2800 } elsif (! $filename) {
2801 return 'application/octet-stream';
2802 } elsif ($filename =~ m/\.png$/i) {
2804 } elsif ($filename =~ m/\.gif$/i) {
2806 } elsif ($filename =~ m/\.jpe?g$/i) {
2807 return 'image/jpeg';
2809 return 'application/octet-stream';
2813 sub blob_contenttype
{
2814 my ($fd, $file_name, $type) = @_;
2816 $type ||= blob_mimetype
($fd, $file_name);
2817 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
2818 $type .= "; charset=$default_text_plain_charset";
2824 ## ======================================================================
2825 ## functions printing HTML: header, footer, error page
2827 sub git_header_html
{
2828 my $status = shift || "200 OK";
2829 my $expires = shift;
2831 my $title = "$site_name";
2832 if (defined $project) {
2833 $title .= " - " . to_utf8
($project);
2834 if (defined $action) {
2835 $title .= "/$action";
2836 if (defined $file_name) {
2837 $title .= " - " . esc_path
($file_name);
2838 if ($action eq "tree" && $file_name !~ m
|/$|) {
2845 # require explicit support from the UA if we are to send the page as
2846 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
2847 # we have to do this because MSIE sometimes globs '*/*', pretending to
2848 # support xhtml+xml but choking when it gets what it asked for.
2849 if (defined $cgi->http('HTTP_ACCEPT') &&
2850 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
2851 $cgi->Accept('application/xhtml+xml') != 0) {
2852 $content_type = 'application/xhtml+xml';
2854 $content_type = 'text/html';
2856 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
2857 -status
=> $status, -expires
=> $expires);
2858 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
2860 <?xml version="1.0" encoding="utf-8"?>
2861 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2862 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
2863 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
2864 <!-- git core binaries version $git_version -->
2866 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
2867 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
2868 <meta name="robots" content="index, nofollow"/>
2869 <title>$title</title>
2871 # print out each stylesheet that exist
2872 if (defined $stylesheet) {
2873 #provides backwards capability for those people who define style sheet in a config file
2874 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2876 foreach my $stylesheet (@stylesheets) {
2877 next unless $stylesheet;
2878 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2881 if (defined $project) {
2882 my %href_params = get_feed_info
();
2883 if (!exists $href_params{'-title'}) {
2884 $href_params{'-title'} = 'log';
2887 foreach my $format qw(RSS Atom) {
2888 my $type = lc($format);
2890 '-rel' => 'alternate',
2891 '-title' => "$project - $href_params{'-title'} - $format feed",
2892 '-type' => "application/$type+xml"
2895 $href_params{'action'} = $type;
2896 $link_attr{'-href'} = href
(%href_params);
2898 "rel=\"$link_attr{'-rel'}\" ".
2899 "title=\"$link_attr{'-title'}\" ".
2900 "href=\"$link_attr{'-href'}\" ".
2901 "type=\"$link_attr{'-type'}\" ".
2904 $href_params{'extra_options'} = '--no-merges';
2905 $link_attr{'-href'} = href
(%href_params);
2906 $link_attr{'-title'} .= ' (no merges)';
2908 "rel=\"$link_attr{'-rel'}\" ".
2909 "title=\"$link_attr{'-title'}\" ".
2910 "href=\"$link_attr{'-href'}\" ".
2911 "type=\"$link_attr{'-type'}\" ".
2916 printf('<link rel="alternate" title="%s projects list" '.
2917 'href="%s" type="text/plain; charset=utf-8" />'."\n",
2918 $site_name, href
(project
=>undef, action
=>"project_index"));
2919 printf('<link rel="alternate" title="%s projects feeds" '.
2920 'href="%s" type="text/x-opml" />'."\n",
2921 $site_name, href
(project
=>undef, action
=>"opml"));
2923 if (defined $favicon) {
2924 print qq(<link rel
="shortcut icon" href
="$favicon" type
="image/png" />\n);
2930 if (-f
$site_header) {
2931 open (my $fd, $site_header);
2936 print "<div class=\"page_header\">\n" .
2937 $cgi->a({-href
=> esc_url
($logo_url),
2938 -title
=> $logo_label},
2939 qq(<img src
="$logo" width
="72" height
="27" alt
="git" class="logo"/>));
2940 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
2941 if (defined $project) {
2942 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
2943 if (defined $action) {
2950 my ($have_search) = gitweb_check_feature
('search');
2951 if (defined $project && $have_search) {
2952 if (!defined $searchtext) {
2956 if (defined $hash_base) {
2957 $search_hash = $hash_base;
2958 } elsif (defined $hash) {
2959 $search_hash = $hash;
2961 $search_hash = "HEAD";
2963 my $action = $my_uri;
2964 my ($use_pathinfo) = gitweb_check_feature
('pathinfo');
2965 if ($use_pathinfo) {
2966 $action .= "/".esc_url
($project);
2968 print $cgi->startform(-method
=> "get", -action
=> $action) .
2969 "<div class=\"search\">\n" .
2971 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
2972 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
2973 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
2974 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
2975 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
2976 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
2978 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
2979 "<span title=\"Extended regular expression\">" .
2980 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
2981 -checked
=> $search_use_regexp) .
2984 $cgi->end_form() . "\n";
2988 sub git_footer_html
{
2989 my $feed_class = 'rss_logo';
2991 print "<div class=\"page_footer\">\n";
2992 if (defined $project) {
2993 my $descr = git_get_project_description
($project);
2994 if (defined $descr) {
2995 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
2998 my %href_params = get_feed_info
();
2999 if (!%href_params) {
3000 $feed_class .= ' generic';
3002 $href_params{'-title'} ||= 'log';
3004 foreach my $format qw(RSS Atom) {
3005 $href_params{'action'} = lc($format);
3006 print $cgi->a({-href
=> href
(%href_params),
3007 -title
=> "$href_params{'-title'} $format feed",
3008 -class => $feed_class}, $format)."\n";
3012 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3013 -class => $feed_class}, "OPML") . " ";
3014 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3015 -class => $feed_class}, "TXT") . "\n";
3017 print "</div>\n"; # class="page_footer"
3019 if (-f
$site_footer) {
3020 open (my $fd, $site_footer);
3029 # die_error(<http_status_code>, <error_message>)
3030 # Example: die_error(404, 'Hash not found')
3031 # By convention, use the following status codes (as defined in RFC 2616):
3032 # 400: Invalid or missing CGI parameters, or
3033 # requested object exists but has wrong type.
3034 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
3035 # this server or project.
3036 # 404: Requested object/revision/project doesn't exist.
3037 # 500: The server isn't configured properly, or
3038 # an internal error occurred (e.g. failed assertions caused by bugs), or
3039 # an unknown error occurred (e.g. the git binary died unexpectedly).
3041 my $status = shift || 500;
3042 my $error = shift || "Internal server error";
3044 my %http_responses = (400 => '400 Bad Request',
3045 403 => '403 Forbidden',
3046 404 => '404 Not Found',
3047 500 => '500 Internal Server Error');
3048 git_header_html
($http_responses{$status});
3050 <div class="page_body">
3060 ## ----------------------------------------------------------------------
3061 ## functions printing or outputting HTML: navigation
3063 sub git_print_page_nav
{
3064 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3065 $extra = '' if !defined $extra; # pager or formats
3067 my @navs = qw(summary shortlog log commit commitdiff tree);
3069 @navs = grep { $_ ne $suppress } @navs;
3072 my %arg = map { $_ => {action
=>$_} } @navs;
3073 if (defined $head) {
3074 for (qw(commit commitdiff)) {
3075 $arg{$_}{'hash'} = $head;
3077 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3078 for (qw(shortlog log)) {
3079 $arg{$_}{'hash'} = $head;
3084 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3085 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3087 my @actions = gitweb_check_feature
('actions');
3089 my ($label, $link, $pos) = (shift(@actions), shift(@actions), shift(@actions));
3090 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
3092 $link =~ s
#%n#$project#g;
3093 $link =~ s
#%f#$git_dir#g;
3094 $treehead ?
$link =~ s
#%h#$treehead#g : $link =~ s#%h##g;
3095 $treebase ?
$link =~ s
#%b#$treebase#g : $link =~ s#%b##g;
3096 $arg{$label}{'_href'} = $link;
3099 print "<div class=\"page_nav\">\n" .
3101 map { $_ eq $current ?
3102 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
3104 print "<br/>\n$extra<br/>\n" .
3108 sub format_paging_nav
{
3109 my ($action, $hash, $head, $page, $has_next_link) = @_;
3113 if ($hash ne $head || $page) {
3114 $paging_nav .= $cgi->a({-href
=> href
(action
=>$action)}, "HEAD");
3116 $paging_nav .= "HEAD";
3120 $paging_nav .= " ⋅ " .
3121 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
3122 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
3124 $paging_nav .= " ⋅ prev";
3127 if ($has_next_link) {
3128 $paging_nav .= " ⋅ " .
3129 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
3130 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
3132 $paging_nav .= " ⋅ next";
3138 ## ......................................................................
3139 ## functions printing or outputting HTML: div
3141 sub git_print_header_div
{
3142 my ($action, $title, $hash, $hash_base) = @_;
3145 $args{'action'} = $action;
3146 $args{'hash'} = $hash if $hash;
3147 $args{'hash_base'} = $hash_base if $hash_base;
3149 print "<div class=\"header\">\n" .
3150 $cgi->a({-href
=> href
(%args), -class => "title"},
3151 $title ?
$title : $action) .
3155 #sub git_print_authorship (\%) {
3156 sub git_print_authorship
{
3159 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
3160 print "<div class=\"author_date\">" .
3161 esc_html
($co->{'author_name'}) .
3163 if ($ad{'hour_local'} < 6) {
3164 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3165 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
3167 printf(" (%02d:%02d %s)",
3168 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
3173 sub git_print_page_path
{
3179 print "<div class=\"page_path\">";
3180 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
3181 -title
=> 'tree root'}, to_utf8
("[$project]"));
3183 if (defined $name) {
3184 my @dirname = split '/', $name;
3185 my $basename = pop @dirname;
3188 foreach my $dir (@dirname) {
3189 $fullname .= ($fullname ?
'/' : '') . $dir;
3190 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
3192 -title
=> $fullname}, esc_path
($dir));
3195 if (defined $type && $type eq 'blob') {
3196 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
3198 -title
=> $name}, esc_path
($basename));
3199 } elsif (defined $type && $type eq 'tree') {
3200 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
3202 -title
=> $name}, esc_path
($basename));
3205 print esc_path
($basename);
3208 print "<br/></div>\n";
3211 # sub git_print_log (\@;%) {
3212 sub git_print_log
($;%) {
3216 if ($opts{'-remove_title'}) {
3217 # remove title, i.e. first line of log
3220 # remove leading empty lines
3221 while (defined $log->[0] && $log->[0] eq "") {
3228 foreach my $line (@
$log) {
3229 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3232 if (! $opts{'-remove_signoff'}) {
3233 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
3236 # remove signoff lines
3243 # print only one empty line
3244 # do not print empty line after signoff
3246 next if ($empty || $signoff);
3252 print format_log_line_html
($line) . "<br/>\n";
3255 if ($opts{'-final_empty_line'}) {
3256 # end with single empty line
3257 print "<br/>\n" unless $empty;
3261 # return link target (what link points to)
3262 sub git_get_link_target
{
3267 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
3271 $link_target = <$fd>;
3276 return $link_target;
3279 # given link target, and the directory (basedir) the link is in,
3280 # return target of link relative to top directory (top tree);
3281 # return undef if it is not possible (including absolute links).
3282 sub normalize_link_target
{
3283 my ($link_target, $basedir, $hash_base) = @_;
3285 # we can normalize symlink target only if $hash_base is provided
3286 return unless $hash_base;
3288 # absolute symlinks (beginning with '/') cannot be normalized
3289 return if (substr($link_target, 0, 1) eq '/');
3291 # normalize link target to path from top (root) tree (dir)
3294 $path = $basedir . '/' . $link_target;
3296 # we are in top (root) tree (dir)
3297 $path = $link_target;
3300 # remove //, /./, and /../
3302 foreach my $part (split('/', $path)) {
3303 # discard '.' and ''
3304 next if (!$part || $part eq '.');
3306 if ($part eq '..') {
3310 # link leads outside repository (outside top dir)
3314 push @path_parts, $part;
3317 $path = join('/', @path_parts);
3322 # print tree entry (row of git_tree), but without encompassing <tr> element
3323 sub git_print_tree_entry
{
3324 my ($t, $basedir, $hash_base, $have_blame) = @_;
3327 $base_key{'hash_base'} = $hash_base if defined $hash_base;
3329 # The format of a table row is: mode list link. Where mode is
3330 # the mode of the entry, list is the name of the entry, an href,
3331 # and link is the action links of the entry.
3333 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
3334 if ($t->{'type'} eq "blob") {
3335 print "<td class=\"list\">" .
3336 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3337 file_name
=>"$basedir$t->{'name'}", %base_key),
3338 -class => "list"}, esc_path
($t->{'name'}));
3339 if (S_ISLNK
(oct $t->{'mode'})) {
3340 my $link_target = git_get_link_target
($t->{'hash'});
3342 my $norm_target = normalize_link_target
($link_target, $basedir, $hash_base);
3343 if (defined $norm_target) {
3345 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
3346 file_name
=>$norm_target),
3347 -title
=> $norm_target}, esc_path
($link_target));
3349 print " -> " . esc_path
($link_target);
3354 print "<td class=\"link\">";
3355 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3356 file_name
=>"$basedir$t->{'name'}", %base_key)},
3360 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
3361 file_name
=>"$basedir$t->{'name'}", %base_key)},
3364 if (defined $hash_base) {
3366 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3367 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
3371 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
3372 file_name
=>"$basedir$t->{'name'}")},
3376 } elsif ($t->{'type'} eq "tree") {
3377 print "<td class=\"list\">";
3378 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3379 file_name
=>"$basedir$t->{'name'}", %base_key)},
3380 esc_path
($t->{'name'}));
3382 print "<td class=\"link\">";
3383 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3384 file_name
=>"$basedir$t->{'name'}", %base_key)},
3386 if (defined $hash_base) {
3388 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3389 file_name
=>"$basedir$t->{'name'}")},
3394 # unknown object: we can only present history for it
3395 # (this includes 'commit' object, i.e. submodule support)
3396 print "<td class=\"list\">" .
3397 esc_path
($t->{'name'}) .
3399 print "<td class=\"link\">";
3400 if (defined $hash_base) {
3401 print $cgi->a({-href
=> href
(action
=>"history",
3402 hash_base
=>$hash_base,
3403 file_name
=>"$basedir$t->{'name'}")},
3410 ## ......................................................................
3411 ## functions printing large fragments of HTML
3413 # get pre-image filenames for merge (combined) diff
3414 sub fill_from_file_info
{
3415 my ($diff, @parents) = @_;
3417 $diff->{'from_file'} = [ ];
3418 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
3419 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3420 if ($diff->{'status'}[$i] eq 'R' ||
3421 $diff->{'status'}[$i] eq 'C') {
3422 $diff->{'from_file'}[$i] =
3423 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
3430 # is current raw difftree line of file deletion
3432 my $diffinfo = shift;
3434 return $diffinfo->{'to_id'} eq ('0' x
40);
3437 # does patch correspond to [previous] difftree raw line
3438 # $diffinfo - hashref of parsed raw diff format
3439 # $patchinfo - hashref of parsed patch diff format
3440 # (the same keys as in $diffinfo)
3441 sub is_patch_split
{
3442 my ($diffinfo, $patchinfo) = @_;
3444 return defined $diffinfo && defined $patchinfo
3445 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
3449 sub git_difftree_body
{
3450 my ($difftree, $hash, @parents) = @_;
3451 my ($parent) = $parents[0];
3452 my ($have_blame) = gitweb_check_feature
('blame');
3453 print "<div class=\"list_head\">\n";
3454 if ($#{$difftree} > 10) {
3455 print(($#{$difftree} + 1) . " files changed:\n");
3459 print "<table class=\"" .
3460 (@parents > 1 ?
"combined " : "") .
3463 # header only for combined diff in 'commitdiff' view
3464 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
3467 print "<thead><tr>\n" .
3468 "<th></th><th></th>\n"; # filename, patchN link
3469 for (my $i = 0; $i < @parents; $i++) {
3470 my $par = $parents[$i];
3472 $cgi->a({-href
=> href
(action
=>"commitdiff",
3473 hash
=>$hash, hash_parent
=>$par),
3474 -title
=> 'commitdiff to parent number ' .
3475 ($i+1) . ': ' . substr($par,0,7)},
3479 print "</tr></thead>\n<tbody>\n";
3484 foreach my $line (@
{$difftree}) {
3485 my $diff = parsed_difftree_line
($line);
3488 print "<tr class=\"dark\">\n";
3490 print "<tr class=\"light\">\n";
3494 if (exists $diff->{'nparents'}) { # combined diff
3496 fill_from_file_info
($diff, @parents)
3497 unless exists $diff->{'from_file'};
3499 if (!is_deleted
($diff)) {
3500 # file exists in the result (child) commit
3502 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3503 file_name
=>$diff->{'to_file'},
3505 -class => "list"}, esc_path
($diff->{'to_file'})) .
3509 esc_path
($diff->{'to_file'}) .
3513 if ($action eq 'commitdiff') {
3516 print "<td class=\"link\">" .
3517 $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3522 my $has_history = 0;
3523 my $not_deleted = 0;
3524 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3525 my $hash_parent = $parents[$i];
3526 my $from_hash = $diff->{'from_id'}[$i];
3527 my $from_path = $diff->{'from_file'}[$i];
3528 my $status = $diff->{'status'}[$i];
3530 $has_history ||= ($status ne 'A');
3531 $not_deleted ||= ($status ne 'D');
3533 if ($status eq 'A') {
3534 print "<td class=\"link\" align=\"right\"> | </td>\n";
3535 } elsif ($status eq 'D') {
3536 print "<td class=\"link\">" .
3537 $cgi->a({-href
=> href
(action
=>"blob",
3540 file_name
=>$from_path)},
3544 if ($diff->{'to_id'} eq $from_hash) {
3545 print "<td class=\"link nochange\">";
3547 print "<td class=\"link\">";
3549 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3550 hash
=>$diff->{'to_id'},
3551 hash_parent
=>$from_hash,
3553 hash_parent_base
=>$hash_parent,
3554 file_name
=>$diff->{'to_file'},
3555 file_parent
=>$from_path)},
3561 print "<td class=\"link\">";
3563 print $cgi->a({-href
=> href
(action
=>"blob",
3564 hash
=>$diff->{'to_id'},
3565 file_name
=>$diff->{'to_file'},
3568 print " | " if ($has_history);
3571 print $cgi->a({-href
=> href
(action
=>"history",
3572 file_name
=>$diff->{'to_file'},
3579 next; # instead of 'else' clause, to avoid extra indent
3581 # else ordinary diff
3583 my ($to_mode_oct, $to_mode_str, $to_file_type);
3584 my ($from_mode_oct, $from_mode_str, $from_file_type);
3585 if ($diff->{'to_mode'} ne ('0' x
6)) {
3586 $to_mode_oct = oct $diff->{'to_mode'};
3587 if (S_ISREG
($to_mode_oct)) { # only for regular file
3588 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
3590 $to_file_type = file_type
($diff->{'to_mode'});
3592 if ($diff->{'from_mode'} ne ('0' x
6)) {
3593 $from_mode_oct = oct $diff->{'from_mode'};
3594 if (S_ISREG
($to_mode_oct)) { # only for regular file
3595 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
3597 $from_file_type = file_type
($diff->{'from_mode'});
3600 if ($diff->{'status'} eq "A") { # created
3601 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
3602 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
3603 $mode_chng .= "]</span>";
3605 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3606 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3607 -class => "list"}, esc_path
($diff->{'file'}));
3609 print "<td>$mode_chng</td>\n";
3610 print "<td class=\"link\">";
3611 if ($action eq 'commitdiff') {
3614 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3617 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3618 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3622 } elsif ($diff->{'status'} eq "D") { # deleted
3623 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
3625 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3626 hash_base
=>$parent, file_name
=>$diff->{'file'}),
3627 -class => "list"}, esc_path
($diff->{'file'}));
3629 print "<td>$mode_chng</td>\n";
3630 print "<td class=\"link\">";
3631 if ($action eq 'commitdiff') {
3634 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3637 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3638 hash_base
=>$parent, file_name
=>$diff->{'file'})},
3641 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
3642 file_name
=>$diff->{'file'})},
3645 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
3646 file_name
=>$diff->{'file'})},
3650 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
3651 my $mode_chnge = "";
3652 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3653 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
3654 if ($from_file_type ne $to_file_type) {
3655 $mode_chnge .= " from $from_file_type to $to_file_type";
3657 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
3658 if ($from_mode_str && $to_mode_str) {
3659 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
3660 } elsif ($to_mode_str) {
3661 $mode_chnge .= " mode: $to_mode_str";
3664 $mode_chnge .= "]</span>\n";
3667 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3668 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3669 -class => "list"}, esc_path
($diff->{'file'}));
3671 print "<td>$mode_chnge</td>\n";
3672 print "<td class=\"link\">";
3673 if ($action eq 'commitdiff') {
3676 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3678 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3679 # "commit" view and modified file (not onlu mode changed)
3680 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3681 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3682 hash_base
=>$hash, hash_parent_base
=>$parent,
3683 file_name
=>$diff->{'file'})},
3687 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3688 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3691 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3692 file_name
=>$diff->{'file'})},
3695 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3696 file_name
=>$diff->{'file'})},
3700 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
3701 my %status_name = ('R' => 'moved', 'C' => 'copied');
3702 my $nstatus = $status_name{$diff->{'status'}};
3704 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3705 # mode also for directories, so we cannot use $to_mode_str
3706 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
3709 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
3710 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
3711 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
3712 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
3713 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
3714 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
3715 -class => "list"}, esc_path
($diff->{'from_file'})) .
3716 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
3717 "<td class=\"link\">";
3718 if ($action eq 'commitdiff') {
3721 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3723 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3724 # "commit" view and modified file (not only pure rename or copy)
3725 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3726 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3727 hash_base
=>$hash, hash_parent_base
=>$parent,
3728 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
3732 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3733 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
3736 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3737 file_name
=>$diff->{'to_file'})},
3740 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3741 file_name
=>$diff->{'to_file'})},
3745 } # we should not encounter Unmerged (U) or Unknown (X) status
3748 print "</tbody>" if $has_header;
3752 sub git_patchset_body
{
3753 my ($fd, $difftree, $hash, @hash_parents) = @_;
3754 my ($hash_parent) = $hash_parents[0];
3756 my $is_combined = (@hash_parents > 1);
3758 my $patch_number = 0;
3764 print "<div class=\"patchset\">\n";
3766 # skip to first patch
3767 while ($patch_line = <$fd>) {
3770 last if ($patch_line =~ m/^diff /);
3774 while ($patch_line) {
3776 # parse "git diff" header line
3777 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
3778 # $1 is from_name, which we do not use
3779 $to_name = unquote
($2);
3780 $to_name =~ s!^b/!!;
3781 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
3782 # $1 is 'cc' or 'combined', which we do not use
3783 $to_name = unquote
($2);
3788 # check if current patch belong to current raw line
3789 # and parse raw git-diff line if needed
3790 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
3791 # this is continuation of a split patch
3792 print "<div class=\"patch cont\">\n";
3794 # advance raw git-diff output if needed
3795 $patch_idx++ if defined $diffinfo;
3797 # read and prepare patch information
3798 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3800 # compact combined diff output can have some patches skipped
3801 # find which patch (using pathname of result) we are at now;
3803 while ($to_name ne $diffinfo->{'to_file'}) {
3804 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3805 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3806 "</div>\n"; # class="patch"
3811 last if $patch_idx > $#$difftree;
3812 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3816 # modifies %from, %to hashes
3817 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
3819 # this is first patch for raw difftree line with $patch_idx index
3820 # we index @$difftree array from 0, but number patches from 1
3821 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
3825 #assert($patch_line =~ m/^diff /) if DEBUG;
3826 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
3828 # print "git diff" header
3829 print format_git_diff_header_line
($patch_line, $diffinfo,
3832 # print extended diff header
3833 print "<div class=\"diff extended_header\">\n";
3835 while ($patch_line = <$fd>) {
3838 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
3840 print format_extended_diff_header_line
($patch_line, $diffinfo,
3843 print "</div>\n"; # class="diff extended_header"
3845 # from-file/to-file diff header
3846 if (! $patch_line) {
3847 print "</div>\n"; # class="patch"
3850 next PATCH
if ($patch_line =~ m/^diff /);
3851 #assert($patch_line =~ m/^---/) if DEBUG;
3853 my $last_patch_line = $patch_line;
3854 $patch_line = <$fd>;
3856 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
3858 print format_diff_from_to_header
($last_patch_line, $patch_line,
3859 $diffinfo, \
%from, \
%to,
3864 while ($patch_line = <$fd>) {
3867 next PATCH
if ($patch_line =~ m/^diff /);
3869 print format_diff_line
($patch_line, \
%from, \
%to);
3873 print "</div>\n"; # class="patch"
3876 # for compact combined (--cc) format, with chunk and patch simpliciaction
3877 # patchset might be empty, but there might be unprocessed raw lines
3878 for (++$patch_idx if $patch_number > 0;
3879 $patch_idx < @
$difftree;
3881 # read and prepare patch information
3882 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3884 # generate anchor for "patch" links in difftree / whatchanged part
3885 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3886 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3887 "</div>\n"; # class="patch"
3892 if ($patch_number == 0) {
3893 if (@hash_parents > 1) {
3894 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
3896 print "<div class=\"diff nodifferences\">No differences found</div>\n";
3900 print "</div>\n"; # class="patchset"
3903 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3905 # fills project list info (age, description, owner, forks) for each
3906 # project in the list, removing invalid projects from returned list
3907 # NOTE: modifies $projlist, but does not remove entries from it
3908 sub fill_project_list_info
{
3909 my ($projlist, $check_forks) = @_;
3912 my $show_ctags = gitweb_check_feature
('ctags');
3914 foreach my $pr (@
$projlist) {
3915 my (@activity) = git_get_last_activity
($pr->{'path'});
3916 unless (@activity) {
3919 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
3920 if (!defined $pr->{'descr'}) {
3921 my $descr = git_get_project_description
($pr->{'path'}) || "";
3922 $descr = to_utf8
($descr);
3923 $pr->{'descr_long'} = $descr;
3924 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
3926 if (!defined $pr->{'owner'}) {
3927 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
3930 my $pname = $pr->{'path'};
3931 if (($pname =~ s/\.git$//) &&
3932 ($pname !~ /\/$/) &&
3933 (-d
"$projectroot/$pname")) {
3934 $pr->{'forks'} = "-d $projectroot/$pname";
3939 $show_ctags and $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
3940 push @projects, $pr;
3946 # print 'sort by' <th> element, generating 'sort by $name' replay link
3947 # if that order is not selected
3949 my ($name, $order, $header) = @_;
3950 $header ||= ucfirst($name);
3952 if ($order eq $name) {
3953 print "<th>$header</th>\n";
3956 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
3957 -class => "header"}, $header) .
3962 sub git_project_list_body
{
3963 # actually uses global variable $project
3964 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
3966 my ($check_forks) = gitweb_check_feature
('forks');
3967 my @projects = fill_project_list_info
($projlist, $check_forks);
3969 $order ||= $default_projects_order;
3970 $from = 0 unless defined $from;
3971 $to = $#projects if (!defined $to || $#projects < $to);
3974 project
=> { key
=> 'path', type
=> 'str' },
3975 descr
=> { key
=> 'descr_long', type
=> 'str' },
3976 owner
=> { key
=> 'owner', type
=> 'str' },
3977 age
=> { key
=> 'age', type
=> 'num' }
3979 my $oi = $order_info{$order};
3980 if ($oi->{'type'} eq 'str') {
3981 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
3983 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
3986 my $show_ctags = gitweb_check_feature
('ctags');
3989 foreach my $p (@projects) {
3990 foreach my $ct (keys %{$p->{'ctags'}}) {
3991 $ctags{$ct} += $p->{'ctags'}->{$ct};
3994 my $cloud = git_populate_project_tagcloud
(\
%ctags);
3995 print git_show_project_tagcloud
($cloud, 64);
3998 print "<table class=\"project_list\">\n";
3999 unless ($no_header) {
4002 print "<th></th>\n";
4004 print_sort_th
('project', $order, 'Project');
4005 print_sort_th
('descr', $order, 'Description');
4006 print_sort_th
('owner', $order, 'Owner');
4007 print_sort_th
('age', $order, 'Last Change');
4008 print "<th></th>\n" . # for links
4012 my $tagfilter = $cgi->param('by_tag');
4013 for (my $i = $from; $i <= $to; $i++) {
4014 my $pr = $projects[$i];
4016 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
4017 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
4018 and not $pr->{'descr_long'} =~ /$searchtext/;
4019 # Weed out forks or non-matching entries of search
4021 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s
#\.git$#/#;
4022 $forkbase="^$forkbase" if $forkbase;
4023 next if not $searchtext and not $tagfilter and $show_ctags
4024 and $pr->{'path'} =~ m
#$forkbase.*/.*#; # regexp-safe
4028 print "<tr class=\"dark\">\n";
4030 print "<tr class=\"light\">\n";
4035 if ($pr->{'forks'}) {
4036 print "<!-- $pr->{'forks'} -->\n";
4037 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "+");
4041 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4042 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
4043 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4044 -class => "list", -title
=> $pr->{'descr_long'}},
4045 esc_html
($pr->{'descr'})) . "</td>\n" .
4046 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
4047 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
4048 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
4049 "<td class=\"link\">" .
4050 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
4051 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
4052 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
4053 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
4054 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
4058 if (defined $extra) {
4061 print "<td></td>\n";
4063 print "<td colspan=\"5\">$extra</td>\n" .
4069 sub git_shortlog_body
{
4070 # uses global variable $project
4071 my ($commitlist, $from, $to, $refs, $extra) = @_;
4073 $from = 0 unless defined $from;
4074 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4076 print "<table class=\"shortlog\">\n";
4078 for (my $i = $from; $i <= $to; $i++) {
4079 my %co = %{$commitlist->[$i]};
4080 my $commit = $co{'id'};
4081 my $ref = format_ref_marker
($refs, $commit);
4083 print "<tr class=\"dark\">\n";
4085 print "<tr class=\"light\">\n";
4088 my $author = chop_and_escape_str
($co{'author_name'}, 10);
4089 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4090 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4091 "<td><i>" . $author . "</i></td>\n" .
4093 print format_subject_html
($co{'title'}, $co{'title_short'},
4094 href
(action
=>"commit", hash
=>$commit), $ref);
4096 "<td class=\"link\">" .
4097 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
4098 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
4099 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
4100 my $snapshot_links = format_snapshot_links
($commit);
4101 if (defined $snapshot_links) {
4102 print " | " . $snapshot_links;
4107 if (defined $extra) {
4109 "<td colspan=\"4\">$extra</td>\n" .
4115 sub git_history_body
{
4116 # Warning: assumes constant type (blob or tree) during history
4117 my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
4119 $from = 0 unless defined $from;
4120 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
4122 print "<table class=\"history\">\n";
4124 for (my $i = $from; $i <= $to; $i++) {
4125 my %co = %{$commitlist->[$i]};
4129 my $commit = $co{'id'};
4131 my $ref = format_ref_marker
($refs, $commit);
4134 print "<tr class=\"dark\">\n";
4136 print "<tr class=\"light\">\n";
4139 # shortlog uses chop_str($co{'author_name'}, 10)
4140 my $author = chop_and_escape_str
($co{'author_name'}, 15, 3);
4141 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4142 "<td><i>" . $author . "</i></td>\n" .
4144 # originally git_history used chop_str($co{'title'}, 50)
4145 print format_subject_html
($co{'title'}, $co{'title_short'},
4146 href
(action
=>"commit", hash
=>$commit), $ref);
4148 "<td class=\"link\">" .
4149 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
4150 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
4152 if ($ftype eq 'blob') {
4153 my $blob_current = git_get_hash_by_path
($hash_base, $file_name);
4154 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
4155 if (defined $blob_current && defined $blob_parent &&
4156 $blob_current ne $blob_parent) {
4158 $cgi->a({-href
=> href
(action
=>"blobdiff",
4159 hash
=>$blob_current, hash_parent
=>$blob_parent,
4160 hash_base
=>$hash_base, hash_parent_base
=>$commit,
4161 file_name
=>$file_name)},
4168 if (defined $extra) {
4170 "<td colspan=\"4\">$extra</td>\n" .
4177 # uses global variable $project
4178 my ($taglist, $from, $to, $extra) = @_;
4179 $from = 0 unless defined $from;
4180 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
4182 print "<table class=\"tags\">\n";
4184 for (my $i = $from; $i <= $to; $i++) {
4185 my $entry = $taglist->[$i];
4187 my $comment = $tag{'subject'};
4189 if (defined $comment) {
4190 $comment_short = chop_str
($comment, 30, 5);
4193 print "<tr class=\"dark\">\n";
4195 print "<tr class=\"light\">\n";
4198 if (defined $tag{'age'}) {
4199 print "<td><i>$tag{'age'}</i></td>\n";
4201 print "<td></td>\n";
4204 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
4205 -class => "list name"}, esc_html
($tag{'name'})) .
4208 if (defined $comment) {
4209 print format_subject_html
($comment, $comment_short,
4210 href
(action
=>"tag", hash
=>$tag{'id'}));
4213 "<td class=\"selflink\">";
4214 if ($tag{'type'} eq "tag") {
4215 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
4220 "<td class=\"link\">" . " | " .
4221 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
4222 if ($tag{'reftype'} eq "commit") {
4223 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
4224 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
4225 } elsif ($tag{'reftype'} eq "blob") {
4226 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
4231 if (defined $extra) {
4233 "<td colspan=\"5\">$extra</td>\n" .
4239 sub git_heads_body
{
4240 # uses global variable $project
4241 my ($headlist, $head, $from, $to, $extra) = @_;
4242 $from = 0 unless defined $from;
4243 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4245 print "<table class=\"heads\">\n";
4247 for (my $i = $from; $i <= $to; $i++) {
4248 my $entry = $headlist->[$i];
4250 my $curr = $ref{'id'} eq $head;
4252 print "<tr class=\"dark\">\n";
4254 print "<tr class=\"light\">\n";
4257 print "<td><i>$ref{'age'}</i></td>\n" .
4258 ($curr ?
"<td class=\"current_head\">" : "<td>") .
4259 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
4260 -class => "list name"},esc_html
($ref{'name'})) .
4262 "<td class=\"link\">" .
4263 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
4264 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
4265 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'name'})}, "tree") .
4269 if (defined $extra) {
4271 "<td colspan=\"3\">$extra</td>\n" .
4277 sub git_search_grep_body
{
4278 my ($commitlist, $from, $to, $extra) = @_;
4279 $from = 0 unless defined $from;
4280 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4282 print "<table class=\"commit_search\">\n";
4284 for (my $i = $from; $i <= $to; $i++) {
4285 my %co = %{$commitlist->[$i]};
4289 my $commit = $co{'id'};
4291 print "<tr class=\"dark\">\n";
4293 print "<tr class=\"light\">\n";
4296 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
4297 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4298 "<td><i>" . $author . "</i></td>\n" .
4300 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
4301 -class => "list subject"},
4302 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
4303 my $comment = $co{'comment'};
4304 foreach my $line (@
$comment) {
4305 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
4306 my ($lead, $match, $trail) = ($1, $2, $3);
4307 $match = chop_str
($match, 70, 5, 'center');
4308 my $contextlen = int((80 - length($match))/2);
4309 $contextlen = 30 if ($contextlen > 30);
4310 $lead = chop_str
($lead, $contextlen, 10, 'left');
4311 $trail = chop_str
($trail, $contextlen, 10, 'right');
4313 $lead = esc_html
($lead);
4314 $match = esc_html
($match);
4315 $trail = esc_html
($trail);
4317 print "$lead<span class=\"match\">$match</span>$trail<br />";
4321 "<td class=\"link\">" .
4322 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
4324 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
4326 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
4330 if (defined $extra) {
4332 "<td colspan=\"3\">$extra</td>\n" .
4338 ## ======================================================================
4339 ## ======================================================================
4342 sub git_project_list
{
4343 my $order = $input_params{'order'};
4344 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4345 die_error
(400, "Unknown order parameter");
4348 my @list = git_get_projects_list
();
4350 die_error
(404, "No projects found");
4354 if (-f
$home_text) {
4355 print "<div class=\"index_include\">\n";
4356 open (my $fd, $home_text);
4361 print $cgi->startform(-method
=> "get") .
4362 "<p class=\"projsearch\">Search:\n" .
4363 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
4365 $cgi->end_form() . "\n";
4366 git_project_list_body
(\
@list, $order);
4371 my $order = $input_params{'order'};
4372 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4373 die_error
(400, "Unknown order parameter");
4376 my @list = git_get_projects_list
($project);
4378 die_error
(404, "No forks found");
4382 git_print_page_nav
('','');
4383 git_print_header_div
('summary', "$project forks");
4384 git_project_list_body
(\
@list, $order);
4388 sub git_project_index
{
4389 my @projects = git_get_projects_list
($project);
4392 -type
=> 'text/plain',
4393 -charset
=> 'utf-8',
4394 -content_disposition
=> 'inline; filename="index.aux"');
4396 foreach my $pr (@projects) {
4397 if (!exists $pr->{'owner'}) {
4398 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
4401 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
4402 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
4403 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4404 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4408 print "$path $owner\n";
4413 my $descr = git_get_project_description
($project) || "none";
4414 my %co = parse_commit
("HEAD");
4415 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
4416 my $head = $co{'id'};
4418 my $owner = git_get_project_owner
($project);
4420 my $refs = git_get_references
();
4421 # These get_*_list functions return one more to allow us to see if
4422 # there are more ...
4423 my @taglist = git_get_tags_list
(16);
4424 my @headlist = git_get_heads_list
(16);
4426 my ($check_forks) = gitweb_check_feature
('forks');
4429 @forklist = git_get_projects_list
($project);
4433 git_print_page_nav
('summary','', $head);
4435 print "<div class=\"title\"> </div>\n";
4436 print "<table class=\"projects_list\">\n" .
4437 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
4438 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
4439 if (defined $cd{'rfc2822'}) {
4440 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
4443 # use per project git URL list in $projectroot/$project/cloneurl
4444 # or make project git URL from git base URL and project name
4445 my $url_tag = "URL";
4446 my @url_list = git_get_project_url_list
($project);
4447 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
4448 foreach my $git_url (@url_list) {
4449 next unless $git_url;
4450 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
4455 my $show_ctags = (gitweb_check_feature
('ctags'))[0];
4457 my $ctags = git_get_project_ctags
($project);
4458 my $cloud = git_populate_project_tagcloud
($ctags);
4459 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
4460 print "</td>\n<td>" unless %$ctags;
4461 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
4462 print "</td>\n<td>" if %$ctags;
4463 print git_show_project_tagcloud
($cloud, 48);
4469 if (-s
"$projectroot/$project/README.html") {
4470 if (open my $fd, "$projectroot/$project/README.html") {
4471 print "<div class=\"title\">readme</div>\n" .
4472 "<div class=\"readme\">\n";
4473 print $_ while (<$fd>);
4474 print "\n</div>\n"; # class="readme"
4479 # we need to request one more than 16 (0..15) to check if
4481 my @commitlist = $head ? parse_commits
($head, 17) : ();
4483 git_print_header_div
('shortlog');
4484 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
4485 $#commitlist <= 15 ?
undef :
4486 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
4490 git_print_header_div
('tags');
4491 git_tags_body
(\
@taglist, 0, 15,
4492 $#taglist <= 15 ?
undef :
4493 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
4497 git_print_header_div
('heads');
4498 git_heads_body
(\
@headlist, $head, 0, 15,
4499 $#headlist <= 15 ?
undef :
4500 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
4504 git_print_header_div
('forks');
4505 git_project_list_body
(\
@forklist, 'age', 0, 15,
4506 $#forklist <= 15 ?
undef :
4507 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
4515 my $head = git_get_head_hash
($project);
4517 git_print_page_nav
('','', $head,undef,$head);
4518 my %tag = parse_tag
($hash);
4521 die_error
(404, "Unknown tag object");
4524 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
4525 print "<div class=\"title_text\">\n" .
4526 "<table class=\"object_header\">\n" .
4528 "<td>object</td>\n" .
4529 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4530 $tag{'object'}) . "</td>\n" .
4531 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4532 $tag{'type'}) . "</td>\n" .
4534 if (defined($tag{'author'})) {
4535 my %ad = parse_date
($tag{'epoch'}, $tag{'tz'});
4536 print "<tr><td>author</td><td>" . esc_html
($tag{'author'}) . "</td></tr>\n";
4537 print "<tr><td></td><td>" . $ad{'rfc2822'} .
4538 sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
4541 print "</table>\n\n" .
4543 print "<div class=\"page_body\">";
4544 my $comment = $tag{'comment'};
4545 foreach my $line (@
$comment) {
4547 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
4557 gitweb_check_feature
('blame')
4558 or die_error
(403, "Blame view not allowed");
4560 die_error
(400, "No file name given") unless $file_name;
4561 $hash_base ||= git_get_head_hash
($project);
4562 die_error
(404, "Couldn't find base commit") unless ($hash_base);
4563 my %co = parse_commit
($hash_base)
4564 or die_error
(404, "Commit not found");
4565 if (!defined $hash) {
4566 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
4567 or die_error
(404, "Error looking up file");
4569 $ftype = git_get_type
($hash);
4570 if ($ftype !~ "blob") {
4571 die_error
(400, "Object is not a blob");
4573 open ($fd, "-|", git_cmd
(), "blame", '-p', '--',
4574 $file_name, $hash_base)
4575 or die_error
(500, "Open git-blame failed");
4578 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
4581 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4584 $cgi->a({-href
=> href
(action
=>"blame", file_name
=>$file_name)},
4586 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4587 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4588 git_print_page_path
($file_name, $ftype, $hash_base);
4589 my @rev_color = (qw(light2 dark2));
4590 my $num_colors = scalar(@rev_color);
4591 my $current_color = 0;
4594 <div class="page_body">
4595 <table class="blame">
4596 <tr><th>Commit</th><th>Line</th><th>Data</th></tr>
4601 last unless defined $_;
4602 my ($full_rev, $orig_lineno, $lineno, $group_size) =
4603 /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/;
4604 if (!exists $metainfo{$full_rev}) {
4605 $metainfo{$full_rev} = {};
4607 my $meta = $metainfo{$full_rev};
4610 if (/^(\S+) (.*)$/) {
4616 my $rev = substr($full_rev, 0, 8);
4617 my $author = $meta->{'author'};
4618 my %date = parse_date
($meta->{'author-time'},
4619 $meta->{'author-tz'});
4620 my $date = $date{'iso-tz'};
4622 $current_color = ++$current_color % $num_colors;
4624 print "<tr class=\"$rev_color[$current_color]\">\n";
4626 print "<td class=\"sha1\"";
4627 print " title=\"". esc_html
($author) . ", $date\"";
4628 print " rowspan=\"$group_size\"" if ($group_size > 1);
4630 print $cgi->a({-href
=> href
(action
=>"commit",
4632 file_name
=>$file_name)},
4636 open (my $dd, "-|", git_cmd
(), "rev-parse", "$full_rev^")
4637 or die_error
(500, "Open git-rev-parse failed");
4638 my $parent_commit = <$dd>;
4640 chomp($parent_commit);
4641 my $blamed = href
(action
=> 'blame',
4642 file_name
=> $meta->{'filename'},
4643 hash_base
=> $parent_commit);
4644 print "<td class=\"linenr\">";
4645 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
4647 -class => "linenr" },
4650 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
4656 or print "Reading blob failed\n";
4661 my $head = git_get_head_hash
($project);
4663 git_print_page_nav
('','', $head,undef,$head);
4664 git_print_header_div
('summary', $project);
4666 my @tagslist = git_get_tags_list
();
4668 git_tags_body
(\
@tagslist);
4674 my $head = git_get_head_hash
($project);
4676 git_print_page_nav
('','', $head,undef,$head);
4677 git_print_header_div
('summary', $project);
4679 my @headslist = git_get_heads_list
();
4681 git_heads_body
(\
@headslist, $head);
4686 sub git_blob_plain
{
4690 if (!defined $hash) {
4691 if (defined $file_name) {
4692 my $base = $hash_base || git_get_head_hash
($project);
4693 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4694 or die_error
(404, "Cannot find file");
4696 die_error
(400, "No file name defined");
4698 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4699 # blobs defined by non-textual hash id's can be cached
4703 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4704 or die_error
(500, "Open git-cat-file blob '$hash' failed");
4706 # content-type (can include charset)
4707 $type = blob_contenttype
($fd, $file_name, $type);
4709 # "save as" filename, even when no $file_name is given
4710 my $save_as = "$hash";
4711 if (defined $file_name) {
4712 $save_as = $file_name;
4713 } elsif ($type =~ m/^text\//) {
4719 -expires
=> $expires,
4720 -content_disposition
=> 'inline; filename="' . $save_as . '"');
4722 binmode STDOUT
, ':raw';
4724 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
4732 if (!defined $hash) {
4733 if (defined $file_name) {
4734 my $base = $hash_base || git_get_head_hash
($project);
4735 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4736 or die_error
(404, "Cannot find file");
4738 die_error
(400, "No file name defined");
4740 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4741 # blobs defined by non-textual hash id's can be cached
4745 my ($have_blame) = gitweb_check_feature
('blame');
4746 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4747 or die_error
(500, "Couldn't cat $file_name, $hash");
4748 my $mimetype = blob_mimetype
($fd, $file_name);
4749 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
4751 return git_blob_plain
($mimetype);
4753 # we can have blame only for text/* mimetype
4754 $have_blame &&= ($mimetype =~ m!^text/!);
4756 git_header_html
(undef, $expires);
4757 my $formats_nav = '';
4758 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4759 if (defined $file_name) {
4762 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
4767 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4770 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4773 $cgi->a({-href
=> href
(action
=>"blob",
4774 hash_base
=>"HEAD", file_name
=>$file_name)},
4778 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4781 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4782 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4784 print "<div class=\"page_nav\">\n" .
4785 "<br/><br/></div>\n" .
4786 "<div class=\"title\">$hash</div>\n";
4788 git_print_page_path
($file_name, "blob", $hash_base);
4789 print "<div class=\"page_body\">\n";
4790 if ($mimetype =~ m!^image/!) {
4791 print qq!<img type
="$mimetype"!;
4793 print qq! alt
="$file_name" title
="$file_name"!;
4796 href(action=>"blob_plain
", hash=>$hash,
4797 hash_base=>$hash_base, file_name=>$file_name) .
4801 while (my $line = <$fd>) {
4804 $line = untabify
($line);
4805 printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
4806 $nr, $nr, $nr, esc_html
($line, -nbsp
=>1);
4810 or print "Reading blob failed.\n";
4816 if (!defined $hash_base) {
4817 $hash_base = "HEAD";
4819 if (!defined $hash) {
4820 if (defined $file_name) {
4821 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
4826 die_error
(404, "No such tree") unless defined($hash);
4828 open my $fd, "-|", git_cmd
(), "ls-tree", '-z', $hash
4829 or die_error
(500, "Open git-ls-tree failed");
4830 my @entries = map { chomp; $_ } <$fd>;
4831 close $fd or die_error
(404, "Reading tree failed");
4834 my $refs = git_get_references
();
4835 my $ref = format_ref_marker
($refs, $hash_base);
4838 my ($have_blame) = gitweb_check_feature
('blame');
4839 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4841 if (defined $file_name) {
4843 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4845 $cgi->a({-href
=> href
(action
=>"tree",
4846 hash_base
=>"HEAD", file_name
=>$file_name)},
4849 my $snapshot_links = format_snapshot_links
($hash);
4850 if (defined $snapshot_links) {
4851 # FIXME: Should be available when we have no hash base as well.
4852 push @views_nav, $snapshot_links;
4854 git_print_page_nav
('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
4855 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
4858 print "<div class=\"page_nav\">\n";
4859 print "<br/><br/></div>\n";
4860 print "<div class=\"title\">$hash</div>\n";
4862 if (defined $file_name) {
4863 $basedir = $file_name;
4864 if ($basedir ne '' && substr($basedir, -1) ne '/') {
4867 git_print_page_path
($file_name, 'tree', $hash_base);
4869 print "<div class=\"page_body\">\n";
4870 print "<table class=\"tree\">\n";
4872 # '..' (top directory) link if possible
4873 if (defined $hash_base &&
4874 defined $file_name && $file_name =~ m![^/]+$!) {
4876 print "<tr class=\"dark\">\n";
4878 print "<tr class=\"light\">\n";
4882 my $up = $file_name;
4883 $up =~ s!/?[^/]+$!!;
4884 undef $up unless $up;
4885 # based on git_print_tree_entry
4886 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
4887 print '<td class="list">';
4888 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hash_base,
4892 print "<td class=\"link\"></td>\n";
4896 foreach my $line (@entries) {
4897 my %t = parse_ls_tree_line
($line, -z
=> 1);
4900 print "<tr class=\"dark\">\n";
4902 print "<tr class=\"light\">\n";
4906 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
4910 print "</table>\n" .
4916 my $format = $input_params{'snapshot_format'};
4917 if (!@snapshot_fmts) {
4918 die_error
(403, "Snapshots not allowed");
4920 # default to first supported snapshot format
4921 $format ||= $snapshot_fmts[0];
4922 if ($format !~ m/^[a-z0-9]+$/) {
4923 die_error
(400, "Invalid snapshot format parameter");
4924 } elsif (!exists($known_snapshot_formats{$format})) {
4925 die_error
(400, "Unknown snapshot format");
4926 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
4927 die_error
(403, "Unsupported snapshot format");
4930 if (!defined $hash) {
4931 $hash = git_get_head_hash
($project);
4934 my $name = $project;
4935 $name =~ s
,([^/])/*\
.git
$,$1,;
4936 $name = basename
($name);
4937 my $filename = to_utf8
($name);
4938 $name =~ s/\047/\047\\\047\047/g;
4940 $filename .= "-$hash$known_snapshot_formats{$format}{'suffix'}";
4941 $cmd = quote_command
(
4942 git_cmd
(), 'archive',
4943 "--format=$known_snapshot_formats{$format}{'format'}",
4944 "--prefix=$name/", $hash);
4945 if (exists $known_snapshot_formats{$format}{'compressor'}) {
4946 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
4950 -type
=> $known_snapshot_formats{$format}{'type'},
4951 -content_disposition
=> 'inline; filename="' . "$filename" . '"',
4952 -status
=> '200 OK');
4954 open my $fd, "-|", $cmd
4955 or die_error
(500, "Execute git-archive failed");
4956 binmode STDOUT
, ':raw';
4958 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
4963 my $head = git_get_head_hash
($project);
4964 if (!defined $hash) {
4967 if (!defined $page) {
4970 my $refs = git_get_references
();
4972 my @commitlist = parse_commits
($hash, 101, (100 * $page));
4974 my $paging_nav = format_paging_nav
('log', $hash, $head, $page, $#commitlist >= 100);
4977 git_print_page_nav
('log','', $hash,undef,undef, $paging_nav);
4980 my %co = parse_commit
($hash);
4982 git_print_header_div
('summary', $project);
4983 print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
4985 my $to = ($#commitlist >= 99) ?
(99) : ($#commitlist);
4986 for (my $i = 0; $i <= $to; $i++) {
4987 my %co = %{$commitlist[$i]};
4989 my $commit = $co{'id'};
4990 my $ref = format_ref_marker
($refs, $commit);
4991 my %ad = parse_date
($co{'author_epoch'});
4992 git_print_header_div
('commit',
4993 "<span class=\"age\">$co{'age_string'}</span>" .
4994 esc_html
($co{'title'}) . $ref,
4996 print "<div class=\"title_text\">\n" .
4997 "<div class=\"log_link\">\n" .
4998 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
5000 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
5002 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
5005 "<i>" . esc_html
($co{'author_name'}) . " [$ad{'rfc2822'}]</i><br/>\n" .
5008 print "<div class=\"log_body\">\n";
5009 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
5012 if ($#commitlist >= 100) {
5013 print "<div class=\"page_nav\">\n";
5014 print $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5015 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5022 $hash ||= $hash_base || "HEAD";
5023 my %co = parse_commit
($hash)
5024 or die_error
(404, "Unknown commit object");
5025 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
5026 my %cd = parse_date
($co{'committer_epoch'}, $co{'committer_tz'});
5028 my $parent = $co{'parent'};
5029 my $parents = $co{'parents'}; # listref
5031 # we need to prepare $formats_nav before any parameter munging
5033 if (!defined $parent) {
5035 $formats_nav .= '(initial)';
5036 } elsif (@
$parents == 1) {
5037 # single parent commit
5040 $cgi->a({-href
=> href
(action
=>"commit",
5042 esc_html
(substr($parent, 0, 7))) .
5049 $cgi->a({-href
=> href
(action
=>"commit",
5051 esc_html
(substr($_, 0, 7)));
5056 if (!defined $parent) {
5060 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
5062 (@
$parents <= 1 ?
$parent : '-c'),
5064 or die_error
(500, "Open git-diff-tree failed");
5065 @difftree = map { chomp; $_ } <$fd>;
5066 close $fd or die_error
(404, "Reading git-diff-tree failed");
5068 # non-textual hash id's can be cached
5070 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5073 my $refs = git_get_references
();
5074 my $ref = format_ref_marker
($refs, $co{'id'});
5076 git_header_html
(undef, $expires);
5077 git_print_page_nav
('commit', '',
5078 $hash, $co{'tree'}, $hash,
5081 if (defined $co{'parent'}) {
5082 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
5084 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
5086 print "<div class=\"title_text\">\n" .
5087 "<table class=\"object_header\">\n";
5088 print "<tr><td>author</td><td>" . esc_html
($co{'author'}) . "</td></tr>\n".
5090 "<td></td><td> $ad{'rfc2822'}";
5091 if ($ad{'hour_local'} < 6) {
5092 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
5093 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
5095 printf(" (%02d:%02d %s)",
5096 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
5100 print "<tr><td>committer</td><td>" . esc_html
($co{'committer'}) . "</td></tr>\n";
5101 print "<tr><td></td><td> $cd{'rfc2822'}" .
5102 sprintf(" (%02d:%02d %s)", $cd{'hour_local'}, $cd{'minute_local'}, $cd{'tz_local'}) .
5104 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
5107 "<td class=\"sha1\">" .
5108 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
5109 class => "list"}, $co{'tree'}) .
5111 "<td class=\"link\">" .
5112 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
5114 my $snapshot_links = format_snapshot_links
($hash);
5115 if (defined $snapshot_links) {
5116 print " | " . $snapshot_links;
5121 foreach my $par (@
$parents) {
5124 "<td class=\"sha1\">" .
5125 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
5126 class => "list"}, $par) .
5128 "<td class=\"link\">" .
5129 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
5131 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
5138 print "<div class=\"page_body\">\n";
5139 git_print_log
($co{'comment'});
5142 git_difftree_body
(\
@difftree, $hash, @
$parents);
5148 # object is defined by:
5149 # - hash or hash_base alone
5150 # - hash_base and file_name
5153 # - hash or hash_base alone
5154 if ($hash || ($hash_base && !defined $file_name)) {
5155 my $object_id = $hash || $hash_base;
5157 open my $fd, "-|", quote_command
(
5158 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
5159 or die_error
(404, "Object does not exist");
5163 or die_error
(404, "Object does not exist");
5165 # - hash_base and file_name
5166 } elsif ($hash_base && defined $file_name) {
5167 $file_name =~ s
,/+$,,;
5169 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
5170 or die_error
(404, "Base object does not exist");
5172 # here errors should not hapen
5173 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
5174 or die_error
(500, "Open git-ls-tree failed");
5178 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
5179 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
5180 die_error
(404, "File or directory for given base does not exist");
5185 die_error
(400, "Not enough information to find object");
5188 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
5189 hash
=>$hash, hash_base
=>$hash_base,
5190 file_name
=>$file_name),
5191 -status
=> '302 Found');
5195 my $format = shift || 'html';
5202 # preparing $fd and %diffinfo for git_patchset_body
5204 if (defined $hash_base && defined $hash_parent_base) {
5205 if (defined $file_name) {
5207 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5208 $hash_parent_base, $hash_base,
5209 "--", (defined $file_parent ?
$file_parent : ()), $file_name
5210 or die_error
(500, "Open git-diff-tree failed");
5211 @difftree = map { chomp; $_ } <$fd>;
5213 or die_error
(404, "Reading git-diff-tree failed");
5215 or die_error
(404, "Blob diff not found");
5217 } elsif (defined $hash &&
5218 $hash =~ /[0-9a-fA-F]{40}/) {
5219 # try to find filename from $hash
5221 # read filtered raw output
5222 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5223 $hash_parent_base, $hash_base, "--"
5224 or die_error
(500, "Open git-diff-tree failed");
5226 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
5228 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
5229 map { chomp; $_ } <$fd>;
5231 or die_error
(404, "Reading git-diff-tree failed");
5233 or die_error
(404, "Blob diff not found");
5236 die_error
(400, "Missing one of the blob diff parameters");
5239 if (@difftree > 1) {
5240 die_error
(400, "Ambiguous blob diff specification");
5243 %diffinfo = parse_difftree_raw_line
($difftree[0]);
5244 $file_parent ||= $diffinfo{'from_file'} || $file_name;
5245 $file_name ||= $diffinfo{'to_file'};
5247 $hash_parent ||= $diffinfo{'from_id'};
5248 $hash ||= $diffinfo{'to_id'};
5250 # non-textual hash id's can be cached
5251 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
5252 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
5257 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5258 '-p', ($format eq 'html' ?
"--full-index" : ()),
5259 $hash_parent_base, $hash_base,
5260 "--", (defined $file_parent ?
$file_parent : ()), $file_name
5261 or die_error
(500, "Open git-diff-tree failed");
5264 # old/legacy style URI
5265 if (!%diffinfo && # if new style URI failed
5266 defined $hash && defined $hash_parent) {
5267 # fake git-diff-tree raw output
5268 $diffinfo{'from_mode'} = $diffinfo{'to_mode'} = "blob";
5269 $diffinfo{'from_id'} = $hash_parent;
5270 $diffinfo{'to_id'} = $hash;
5271 if (defined $file_name) {
5272 if (defined $file_parent) {
5273 $diffinfo{'status'} = '2';
5274 $diffinfo{'from_file'} = $file_parent;
5275 $diffinfo{'to_file'} = $file_name;
5276 } else { # assume not renamed
5277 $diffinfo{'status'} = '1';
5278 $diffinfo{'from_file'} = $file_name;
5279 $diffinfo{'to_file'} = $file_name;
5281 } else { # no filename given
5282 $diffinfo{'status'} = '2';
5283 $diffinfo{'from_file'} = $hash_parent;
5284 $diffinfo{'to_file'} = $hash;
5287 # non-textual hash id's can be cached
5288 if ($hash =~ m/^[0-9a-fA-F]{40}$/ &&
5289 $hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5294 open $fd, "-|", git_cmd
(), "diff", @diff_opts,
5295 '-p', ($format eq 'html' ?
"--full-index" : ()),
5296 $hash_parent, $hash, "--"
5297 or die_error
(500, "Open git-diff failed");
5299 die_error
(400, "Missing one of the blob diff parameters")
5304 if ($format eq 'html') {
5306 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
5308 git_header_html
(undef, $expires);
5309 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5310 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5311 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5313 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
5314 print "<div class=\"title\">$hash vs $hash_parent</div>\n";
5316 if (defined $file_name) {
5317 git_print_page_path
($file_name, "blob", $hash_base);
5319 print "<div class=\"page_path\"></div>\n";
5322 } elsif ($format eq 'plain') {
5324 -type
=> 'text/plain',
5325 -charset
=> 'utf-8',
5326 -expires
=> $expires,
5327 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
5329 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5332 die_error
(400, "Unknown blobdiff format");
5336 if ($format eq 'html') {
5337 print "<div class=\"page_body\">\n";
5339 git_patchset_body
($fd, [ \
%diffinfo ], $hash_base, $hash_parent_base);
5342 print "</div>\n"; # class="page_body"
5346 while (my $line = <$fd>) {
5347 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
5348 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
5352 last if $line =~ m!^\+\+\+!;
5360 sub git_blobdiff_plain
{
5361 git_blobdiff
('plain');
5364 sub git_commitdiff
{
5365 my $format = shift || 'html';
5366 $hash ||= $hash_base || "HEAD";
5367 my %co = parse_commit
($hash)
5368 or die_error
(404, "Unknown commit object");
5370 # choose format for commitdiff for merge
5371 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
5372 $hash_parent = '--cc';
5374 # we need to prepare $formats_nav before almost any parameter munging
5376 if ($format eq 'html') {
5378 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
5381 if (defined $hash_parent &&
5382 $hash_parent ne '-c' && $hash_parent ne '--cc') {
5383 # commitdiff with two commits given
5384 my $hash_parent_short = $hash_parent;
5385 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5386 $hash_parent_short = substr($hash_parent, 0, 7);
5390 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
5391 if ($co{'parents'}[$i] eq $hash_parent) {
5392 $formats_nav .= ' parent ' . ($i+1);
5396 $formats_nav .= ': ' .
5397 $cgi->a({-href
=> href
(action
=>"commitdiff",
5398 hash
=>$hash_parent)},
5399 esc_html
($hash_parent_short)) .
5401 } elsif (!$co{'parent'}) {
5403 $formats_nav .= ' (initial)';
5404 } elsif (scalar @
{$co{'parents'}} == 1) {
5405 # single parent commit
5408 $cgi->a({-href
=> href
(action
=>"commitdiff",
5409 hash
=>$co{'parent'})},
5410 esc_html
(substr($co{'parent'}, 0, 7))) .
5414 if ($hash_parent eq '--cc') {
5415 $formats_nav .= ' | ' .
5416 $cgi->a({-href
=> href
(action
=>"commitdiff",
5417 hash
=>$hash, hash_parent
=>'-c')},
5419 } else { # $hash_parent eq '-c'
5420 $formats_nav .= ' | ' .
5421 $cgi->a({-href
=> href
(action
=>"commitdiff",
5422 hash
=>$hash, hash_parent
=>'--cc')},
5428 $cgi->a({-href
=> href
(action
=>"commitdiff",
5430 esc_html
(substr($_, 0, 7)));
5431 } @
{$co{'parents'}} ) .
5436 my $hash_parent_param = $hash_parent;
5437 if (!defined $hash_parent_param) {
5438 # --cc for multiple parents, --root for parentless
5439 $hash_parent_param =
5440 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
5446 if ($format eq 'html') {
5447 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5448 "--no-commit-id", "--patch-with-raw", "--full-index",
5449 $hash_parent_param, $hash, "--"
5450 or die_error
(500, "Open git-diff-tree failed");
5452 while (my $line = <$fd>) {
5454 # empty line ends raw part of diff-tree output
5456 push @difftree, scalar parse_difftree_raw_line
($line);
5459 } elsif ($format eq 'plain') {
5460 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5461 '-p', $hash_parent_param, $hash, "--"
5462 or die_error
(500, "Open git-diff-tree failed");
5465 die_error
(400, "Unknown commitdiff format");
5468 # non-textual hash id's can be cached
5470 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5474 # write commit message
5475 if ($format eq 'html') {
5476 my $refs = git_get_references
();
5477 my $ref = format_ref_marker
($refs, $co{'id'});
5479 git_header_html
(undef, $expires);
5480 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
5481 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
5482 git_print_authorship
(\
%co);
5483 print "<div class=\"page_body\">\n";
5484 if (@
{$co{'comment'}} > 1) {
5485 print "<div class=\"log\">\n";
5486 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
5487 print "</div>\n"; # class="log"
5490 } elsif ($format eq 'plain') {
5491 my $refs = git_get_references
("tags");
5492 my $tagname = git_get_rev_name_tags
($hash);
5493 my $filename = basename
($project) . "-$hash.patch";
5496 -type
=> 'text/plain',
5497 -charset
=> 'utf-8',
5498 -expires
=> $expires,
5499 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
5500 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
5501 print "From: " . to_utf8
($co{'author'}) . "\n";
5502 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
5503 print "Subject: " . to_utf8
($co{'title'}) . "\n";
5505 print "X-Git-Tag: $tagname\n" if $tagname;
5506 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5508 foreach my $line (@
{$co{'comment'}}) {
5509 print to_utf8
($line) . "\n";
5515 if ($format eq 'html') {
5516 my $use_parents = !defined $hash_parent ||
5517 $hash_parent eq '-c' || $hash_parent eq '--cc';
5518 git_difftree_body
(\
@difftree, $hash,
5519 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5522 git_patchset_body
($fd, \
@difftree, $hash,
5523 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5525 print "</div>\n"; # class="page_body"
5528 } elsif ($format eq 'plain') {
5532 or print "Reading git-diff-tree failed\n";
5536 sub git_commitdiff_plain
{
5537 git_commitdiff
('plain');
5541 if (!defined $hash_base) {
5542 $hash_base = git_get_head_hash
($project);
5544 if (!defined $page) {
5548 my %co = parse_commit
($hash_base)
5549 or die_error
(404, "Unknown commit object");
5551 my $refs = git_get_references
();
5552 my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
5554 my @commitlist = parse_commits
($hash_base, 101, (100 * $page),
5555 $file_name, "--full-history")
5556 or die_error
(404, "No such file or directory on given branch");
5558 if (!defined $hash && defined $file_name) {
5559 # some commits could have deleted file in question,
5560 # and not have it in tree, but one of them has to have it
5561 for (my $i = 0; $i <= @commitlist; $i++) {
5562 $hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
5563 last if defined $hash;
5566 if (defined $hash) {
5567 $ftype = git_get_type
($hash);
5569 if (!defined $ftype) {
5570 die_error
(500, "Unknown type of object");
5573 my $paging_nav = '';
5576 $cgi->a({-href
=> href
(action
=>"history", hash
=>$hash, hash_base
=>$hash_base,
5577 file_name
=>$file_name)},
5579 $paging_nav .= " ⋅ " .
5580 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5581 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5583 $paging_nav .= "first";
5584 $paging_nav .= " ⋅ prev";
5587 if ($#commitlist >= 100) {
5589 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5590 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5591 $paging_nav .= " ⋅ $next_link";
5593 $paging_nav .= " ⋅ next";
5597 git_print_page_nav
('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
5598 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5599 git_print_page_path
($file_name, $ftype, $hash_base);
5601 git_history_body
(\
@commitlist, 0, 99,
5602 $refs, $hash_base, $ftype, $next_link);
5608 gitweb_check_feature
('search') or die_error
(403, "Search is disabled");
5609 if (!defined $searchtext) {
5610 die_error
(400, "Text field is empty");
5612 if (!defined $hash) {
5613 $hash = git_get_head_hash
($project);
5615 my %co = parse_commit
($hash);
5617 die_error
(404, "Unknown commit object");
5619 if (!defined $page) {
5623 $searchtype ||= 'commit';
5624 if ($searchtype eq 'pickaxe') {
5625 # pickaxe may take all resources of your box and run for several minutes
5626 # with every query - so decide by yourself how public you make this feature
5627 gitweb_check_feature
('pickaxe')
5628 or die_error
(403, "Pickaxe is disabled");
5630 if ($searchtype eq 'grep') {
5631 gitweb_check_feature
('grep')
5632 or die_error
(403, "Grep is disabled");
5637 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
5639 if ($searchtype eq 'commit') {
5640 $greptype = "--grep=";
5641 } elsif ($searchtype eq 'author') {
5642 $greptype = "--author=";
5643 } elsif ($searchtype eq 'committer') {
5644 $greptype = "--committer=";
5646 $greptype .= $searchtext;
5647 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5648 $greptype, '--regexp-ignore-case',
5649 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5651 my $paging_nav = '';
5654 $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
5655 searchtext
=>$searchtext,
5656 searchtype
=>$searchtype)},
5658 $paging_nav .= " ⋅ " .
5659 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5660 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5662 $paging_nav .= "first";
5663 $paging_nav .= " ⋅ prev";
5666 if ($#commitlist >= 100) {
5668 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5669 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5670 $paging_nav .= " ⋅ $next_link";
5672 $paging_nav .= " ⋅ next";
5675 if ($#commitlist >= 100) {
5678 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5679 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5680 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5683 if ($searchtype eq 'pickaxe') {
5684 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5685 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5687 print "<table class=\"pickaxe search\">\n";
5690 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5691 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5692 ($search_use_regexp ?
'--pickaxe-regex' : ());
5695 while (my $line = <$fd>) {
5699 my %set = parse_difftree_raw_line
($line);
5700 if (defined $set{'commit'}) {
5701 # finish previous commit
5704 "<td class=\"link\">" .
5705 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5707 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5713 print "<tr class=\"dark\">\n";
5715 print "<tr class=\"light\">\n";
5718 %co = parse_commit
($set{'commit'});
5719 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5720 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5721 "<td><i>$author</i></td>\n" .
5723 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5724 -class => "list subject"},
5725 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5726 } elsif (defined $set{'to_id'}) {
5727 next if ($set{'to_id'} =~ m/^0{40}$/);
5729 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5730 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5732 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5738 # finish last commit (warning: repetition!)
5741 "<td class=\"link\">" .
5742 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5744 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5752 if ($searchtype eq 'grep') {
5753 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5754 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5756 print "<table class=\"grep_search\">\n";
5760 open my $fd, "-|", git_cmd
(), 'grep', '-n',
5761 $search_use_regexp ?
('-E', '-i') : '-F',
5762 $searchtext, $co{'tree'};
5764 while (my $line = <$fd>) {
5766 my ($file, $lno, $ltext, $binary);
5767 last if ($matches++ > 1000);
5768 if ($line =~ /^Binary file (.+) matches$/) {
5772 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5774 if ($file ne $lastfile) {
5775 $lastfile and print "</td></tr>\n";
5777 print "<tr class=\"dark\">\n";
5779 print "<tr class=\"light\">\n";
5781 print "<td class=\"list\">".
5782 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5783 file_name
=>"$file"),
5784 -class => "list"}, esc_path
($file));
5785 print "</td><td>\n";
5789 print "<div class=\"binary\">Binary file</div>\n";
5791 $ltext = untabify
($ltext);
5792 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5793 $ltext = esc_html
($1, -nbsp
=>1);
5794 $ltext .= '<span class="match">';
5795 $ltext .= esc_html
($2, -nbsp
=>1);
5796 $ltext .= '</span>';
5797 $ltext .= esc_html
($3, -nbsp
=>1);
5799 $ltext = esc_html
($ltext, -nbsp
=>1);
5801 print "<div class=\"pre\">" .
5802 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5803 file_name
=>"$file").'#l'.$lno,
5804 -class => "linenr"}, sprintf('%4i', $lno))
5805 . ' ' . $ltext . "</div>\n";
5809 print "</td></tr>\n";
5810 if ($matches > 1000) {
5811 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5814 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5823 sub git_search_help
{
5825 git_print_page_nav
('','', $hash,$hash,$hash);
5827 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
5828 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
5829 the pattern entered is recognized as the POSIX extended
5830 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
5833 <dt><b>commit</b></dt>
5834 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
5836 my ($have_grep) = gitweb_check_feature
('grep');
5839 <dt><b>grep</b></dt>
5840 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
5841 a different one) are searched for the given pattern. On large trees, this search can take
5842 a while and put some strain on the server, so please use it with some consideration. Note that
5843 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
5844 case-sensitive.</dd>
5848 <dt><b>author</b></dt>
5849 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
5850 <dt><b>committer</b></dt>
5851 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
5853 my ($have_pickaxe) = gitweb_check_feature
('pickaxe');
5854 if ($have_pickaxe) {
5856 <dt><b>pickaxe</b></dt>
5857 <dd>All commits that caused the string to appear or disappear from any file (changes that
5858 added, removed or "modified" the string) will be listed. This search can take a while and
5859 takes a lot of strain on the server, so please use it wisely. Note that since you may be
5860 interested even in changes just changing the case as well, this search is case sensitive.</dd>
5868 my $head = git_get_head_hash
($project);
5869 if (!defined $hash) {
5872 if (!defined $page) {
5875 my $refs = git_get_references
();
5877 my $commit_hash = $hash;
5878 if (defined $hash_parent) {
5879 $commit_hash = "$hash_parent..$hash";
5881 my @commitlist = parse_commits
($commit_hash, 101, (100 * $page));
5883 my $paging_nav = format_paging_nav
('shortlog', $hash, $head, $page, $#commitlist >= 100);
5885 if ($#commitlist >= 100) {
5887 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5888 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5892 git_print_page_nav
('shortlog','', $hash,$hash,$hash, $paging_nav);
5893 git_print_header_div
('summary', $project);
5895 git_shortlog_body
(\
@commitlist, 0, 99, $refs, $next_link);
5900 ## ......................................................................
5901 ## feeds (RSS, Atom; OPML)
5904 my $format = shift || 'atom';
5905 my ($have_blame) = gitweb_check_feature
('blame');
5907 # Atom: http://www.atomenabled.org/developers/syndication/
5908 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
5909 if ($format ne 'rss' && $format ne 'atom') {
5910 die_error
(400, "Unknown web feed format");
5913 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
5914 my $head = $hash || 'HEAD';
5915 my @commitlist = parse_commits
($head, 150, 0, $file_name);
5919 my $content_type = "application/$format+xml";
5920 if (defined $cgi->http('HTTP_ACCEPT') &&
5921 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
5922 # browser (feed reader) prefers text/xml
5923 $content_type = 'text/xml';
5925 if (defined($commitlist[0])) {
5926 %latest_commit = %{$commitlist[0]};
5927 %latest_date = parse_date
($latest_commit{'author_epoch'});
5929 -type
=> $content_type,
5930 -charset
=> 'utf-8',
5931 -last_modified
=> $latest_date{'rfc2822'});
5934 -type
=> $content_type,
5935 -charset
=> 'utf-8');
5938 # Optimization: skip generating the body if client asks only
5939 # for Last-Modified date.
5940 return if ($cgi->request_method() eq 'HEAD');
5943 my $title = "$site_name - $project/$action";
5944 my $feed_type = 'log';
5945 if (defined $hash) {
5946 $title .= " - '$hash'";
5947 $feed_type = 'branch log';
5948 if (defined $file_name) {
5949 $title .= " :: $file_name";
5950 $feed_type = 'history';
5952 } elsif (defined $file_name) {
5953 $title .= " - $file_name";
5954 $feed_type = 'history';
5956 $title .= " $feed_type";
5957 my $descr = git_get_project_description
($project);
5958 if (defined $descr) {
5959 $descr = esc_html
($descr);
5961 $descr = "$project " .
5962 ($format eq 'rss' ?
'RSS' : 'Atom') .
5965 my $owner = git_get_project_owner
($project);
5966 $owner = esc_html
($owner);
5970 if (defined $file_name) {
5971 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
5972 } elsif (defined $hash) {
5973 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
5975 $alt_url = href
(-full
=>1, action
=>"summary");
5977 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
5978 if ($format eq 'rss') {
5980 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
5983 print "<title>$title</title>\n" .
5984 "<link>$alt_url</link>\n" .
5985 "<description>$descr</description>\n" .
5986 "<language>en</language>\n";
5987 } elsif ($format eq 'atom') {
5989 <feed xmlns="http://www.w3.org/2005/Atom">
5991 print "<title>$title</title>\n" .
5992 "<subtitle>$descr</subtitle>\n" .
5993 '<link rel="alternate" type="text/html" href="' .
5994 $alt_url . '" />' . "\n" .
5995 '<link rel="self" type="' . $content_type . '" href="' .
5996 $cgi->self_url() . '" />' . "\n" .
5997 "<id>" . href
(-full
=>1) . "</id>\n" .
5998 # use project owner for feed author
5999 "<author><name>$owner</name></author>\n";
6000 if (defined $favicon) {
6001 print "<icon>" . esc_url
($favicon) . "</icon>\n";
6003 if (defined $logo_url) {
6004 # not twice as wide as tall: 72 x 27 pixels
6005 print "<logo>" . esc_url
($logo) . "</logo>\n";
6007 if (! %latest_date) {
6008 # dummy date to keep the feed valid until commits trickle in:
6009 print "<updated>1970-01-01T00:00:00Z</updated>\n";
6011 print "<updated>$latest_date{'iso-8601'}</updated>\n";
6016 for (my $i = 0; $i <= $#commitlist; $i++) {
6017 my %co = %{$commitlist[$i]};
6018 my $commit = $co{'id'};
6019 # we read 150, we always show 30 and the ones more recent than 48 hours
6020 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
6023 my %cd = parse_date
($co{'author_epoch'});
6025 # get list of changed files
6026 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6027 $co{'parent'} || "--root",
6028 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
6030 my @difftree = map { chomp; $_ } <$fd>;
6034 # print element (entry, item)
6035 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
6036 if ($format eq 'rss') {
6038 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
6039 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
6040 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
6041 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
6042 "<link>$co_url</link>\n" .
6043 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
6044 "<content:encoded>" .
6046 } elsif ($format eq 'atom') {
6048 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
6049 "<updated>$cd{'iso-8601'}</updated>\n" .
6051 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
6052 if ($co{'author_email'}) {
6053 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
6055 print "</author>\n" .
6056 # use committer for contributor
6058 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
6059 if ($co{'committer_email'}) {
6060 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
6062 print "</contributor>\n" .
6063 "<published>$cd{'iso-8601'}</published>\n" .
6064 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
6065 "<id>$co_url</id>\n" .
6066 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
6067 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
6069 my $comment = $co{'comment'};
6071 foreach my $line (@
$comment) {
6072 $line = esc_html
($line);
6075 print "</pre><ul>\n";
6076 foreach my $difftree_line (@difftree) {
6077 my %difftree = parse_difftree_raw_line
($difftree_line);
6078 next if !$difftree{'from_id'};
6080 my $file = $difftree{'file'} || $difftree{'to_file'};
6084 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
6085 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
6086 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
6087 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
6088 -title
=> "diff"}, 'D');
6090 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
6091 file_name
=>$file, hash_base
=>$commit),
6092 -title
=> "blame"}, 'B');
6094 # if this is not a feed of a file history
6095 if (!defined $file_name || $file_name ne $file) {
6096 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
6097 file_name
=>$file, hash
=>$commit),
6098 -title
=> "history"}, 'H');
6100 $file = esc_path
($file);
6104 if ($format eq 'rss') {
6105 print "</ul>]]>\n" .
6106 "</content:encoded>\n" .
6108 } elsif ($format eq 'atom') {
6109 print "</ul>\n</div>\n" .
6116 if ($format eq 'rss') {
6117 print "</channel>\n</rss>\n";
6118 } elsif ($format eq 'atom') {
6132 my @list = git_get_projects_list
();
6134 print $cgi->header(-type
=> 'text/xml', -charset
=> 'utf-8');
6136 <?xml version="1.0" encoding="utf-8"?>
6137 <opml version="1.0">
6139 <title>$site_name OPML Export</title>
6142 <outline text="git RSS feeds">
6145 foreach my $pr (@list) {
6147 my $head = git_get_head_hash
($proj{'path'});
6148 if (!defined $head) {
6151 $git_dir = "$projectroot/$proj{'path'}";
6152 my %co = parse_commit
($head);
6157 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
6158 my $rss = "$my_url?p=$proj{'path'};a=rss";
6159 my $html = "$my_url?p=$proj{'path'};a=summary";
6160 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";