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
13 use CGI
qw(:standard :escapeHTML -nosticky);
14 use CGI
::Util
qw(unescape);
15 use CGI
::Carp
qw(fatalsToBrowser set_message);
19 use File
::Basename
qw(basename);
20 binmode STDOUT
, ':utf8';
23 if (eval { require Time
::HiRes
; 1; }) {
24 $t0 = [Time
::HiRes
::gettimeofday
()];
26 our $number_of_git_cmds = 0;
29 CGI
->compile() if $ENV{'MOD_PERL'};
32 our $version = "++GIT_VERSION++";
34 our ($my_url, $my_uri, $base_url, $path_info, $home_link);
38 our $my_url = $cgi->url();
39 our $my_uri = $cgi->url(-absolute
=> 1);
41 # Base URL for relative URLs in gitweb ($logo, $favicon, ...),
42 # needed and used only for URLs with nonempty PATH_INFO
43 our $base_url = $my_url;
45 # When the script is used as DirectoryIndex, the URL does not contain the name
46 # of the script file itself, and $cgi->url() fails to strip PATH_INFO, so we
47 # have to do it ourselves. We make $path_info global because it's also used
50 # Another issue with the script being the DirectoryIndex is that the resulting
51 # $my_url data is not the full script URL: this is good, because we want
52 # generated links to keep implying the script name if it wasn't explicitly
53 # indicated in the URL we're handling, but it means that $my_url cannot be used
55 # Therefore, if we needed to strip PATH_INFO, then we know that we have
56 # to build the base URL ourselves:
57 our $path_info = $ENV{"PATH_INFO"};
59 if ($my_url =~ s
,\Q
$path_info\E
$,, &&
60 $my_uri =~ s
,\Q
$path_info\E
$,, &&
61 defined $ENV{'SCRIPT_NAME'}) {
62 $base_url = $cgi->url(-base
=> 1) . $ENV{'SCRIPT_NAME'};
66 # target of the home link on top of all pages
67 our $home_link = $my_uri || "/";
70 # core git executable to use
71 # this can just be "git" if your webserver has a sensible PATH
72 our $GIT = "++GIT_BINDIR++/git";
74 # absolute fs-path which will be prepended to the project path
75 #our $projectroot = "/pub/scm";
76 our $projectroot = "++GITWEB_PROJECTROOT++";
78 # fs traversing limit for getting project list
79 # the number is relative to the projectroot
80 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
82 # string of the home link on top of all pages
83 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
85 # name of your site or organization to appear in page titles
86 # replace this with something more descriptive for clearer bookmarks
87 our $site_name = "++GITWEB_SITENAME++"
88 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
90 # filename of html text to include at top of each page
91 our $site_header = "++GITWEB_SITE_HEADER++";
92 # html text to include at home page
93 our $home_text = "++GITWEB_HOMETEXT++";
94 # filename of html text to include at bottom of each page
95 our $site_footer = "++GITWEB_SITE_FOOTER++";
98 our @stylesheets = ("++GITWEB_CSS++");
99 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
100 our $stylesheet = undef;
101 # URI of GIT logo (72x27 size)
102 our $logo = "++GITWEB_LOGO++";
103 # URI of GIT favicon, assumed to be image/png type
104 our $favicon = "++GITWEB_FAVICON++";
105 # URI of gitweb.js (JavaScript code for gitweb)
106 our $javascript = "++GITWEB_JS++";
108 # URI and label (title) of GIT logo link
109 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
110 #our $logo_label = "git documentation";
111 our $logo_url = "http://git-scm.com/";
112 our $logo_label = "git homepage";
114 # source of projects list
115 our $projects_list = "++GITWEB_LIST++";
117 # the width (in characters) of the projects list "Description" column
118 our $projects_list_description_width = 25;
120 # default order of projects list
121 # valid values are none, project, descr, owner, and age
122 our $default_projects_order = "project";
124 # show repository only if this file exists
125 # (only effective if this variable evaluates to true)
126 our $export_ok = "++GITWEB_EXPORT_OK++";
128 # show repository only if this subroutine returns true
129 # when given the path to the project, for example:
130 # sub { return -e "$_[0]/git-daemon-export-ok"; }
131 our $export_auth_hook = undef;
133 # only allow viewing of repositories also shown on the overview page
134 our $strict_export = "++GITWEB_STRICT_EXPORT++";
136 # list of git base URLs used for URL to where fetch project from,
137 # i.e. full URL is "$git_base_url/$project"
138 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
140 # default blob_plain mimetype and default charset for text/plain blob
141 our $default_blob_plain_mimetype = 'text/plain';
142 our $default_text_plain_charset = undef;
144 # file to use for guessing MIME types before trying /etc/mime.types
145 # (relative to the current git repository)
146 our $mimetypes_file = undef;
148 # assume this charset if line contains non-UTF-8 characters;
149 # it should be valid encoding (see Encoding::Supported(3pm) for list),
150 # for which encoding all byte sequences are valid, for example
151 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
152 # could be even 'utf-8' for the old behavior)
153 our $fallback_encoding = 'latin1';
155 # rename detection options for git-diff and git-diff-tree
156 # - default is '-M', with the cost proportional to
157 # (number of removed files) * (number of new files).
158 # - more costly is '-C' (which implies '-M'), with the cost proportional to
159 # (number of changed files + number of removed files) * (number of new files)
160 # - even more costly is '-C', '--find-copies-harder' with cost
161 # (number of files in the original tree) * (number of new files)
162 # - one might want to include '-B' option, e.g. '-B', '-M'
163 our @diff_opts = ('-M'); # taken from git_commit
165 # Disables features that would allow repository owners to inject script into
167 our $prevent_xss = 0;
169 # Path to the highlight executable to use (must be the one from
170 # http://www.andre-simon.de due to assumptions about parameters and output).
171 # Useful if highlight is not installed on your webserver's PATH.
172 # [Default: highlight]
173 our $highlight_bin = "++HIGHLIGHT_BIN++";
175 # information about snapshot formats that gitweb is capable of serving
176 our %known_snapshot_formats = (
178 # 'display' => display name,
179 # 'type' => mime type,
180 # 'suffix' => filename suffix,
181 # 'format' => --format for git-archive,
182 # 'compressor' => [compressor command and arguments]
183 # (array reference, optional)
184 # 'disabled' => boolean (optional)}
187 'display' => 'tar.gz',
188 'type' => 'application/x-gzip',
189 'suffix' => '.tar.gz',
191 'compressor' => ['gzip']},
194 'display' => 'tar.bz2',
195 'type' => 'application/x-bzip2',
196 'suffix' => '.tar.bz2',
198 'compressor' => ['bzip2']},
201 'display' => 'tar.xz',
202 'type' => 'application/x-xz',
203 'suffix' => '.tar.xz',
205 'compressor' => ['xz'],
210 'type' => 'application/x-zip',
215 # Aliases so we understand old gitweb.snapshot values in repository
217 our %known_snapshot_format_aliases = (
222 # backward compatibility: legacy gitweb config support
223 'x-gzip' => undef, 'gz' => undef,
224 'x-bzip2' => undef, 'bz2' => undef,
225 'x-zip' => undef, '' => undef,
228 # Pixel sizes for icons and avatars. If the default font sizes or lineheights
229 # are changed, it may be appropriate to change these values too via
236 # Used to set the maximum load that we will still respond to gitweb queries.
237 # If server load exceed this value then return "503 server busy" error.
238 # If gitweb cannot determined server load, it is taken to be 0.
239 # Leave it undefined (or set to 'undef') to turn off load checking.
242 # configuration for 'highlight' (http://www.andre-simon.de/)
244 our %highlight_basename = (
247 'SConstruct' => 'py', # SCons equivalent of Makefile
248 'Makefile' => 'make',
251 our %highlight_ext = (
252 # main extensions, defining name of syntax;
253 # see files in /usr/share/highlight/langDefs/ directory
255 qw(py c cpp rb java css php sh pl js tex bib xml awk bat ini spec tcl),
256 # alternate extensions, see /etc/highlight/filetypes.conf
258 map { $_ => 'cpp' } qw(cxx c++ cc),
259 map { $_ => 'php' } qw(php3 php4),
260 map { $_ => 'pl' } qw(perl pm), # perhaps also 'cgi'
262 map { $_ => 'xml' } qw(xhtml html htm),
265 # You define site-wide feature defaults here; override them with
266 # $GITWEB_CONFIG as necessary.
269 # 'sub' => feature-sub (subroutine),
270 # 'override' => allow-override (boolean),
271 # 'default' => [ default options...] (array reference)}
273 # if feature is overridable (it means that allow-override has true value),
274 # then feature-sub will be called with default options as parameters;
275 # return value of feature-sub indicates if to enable specified feature
277 # if there is no 'sub' key (no feature-sub), then feature cannot be
280 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
281 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
284 # Enable the 'blame' blob view, showing the last commit that modified
285 # each line in the file. This can be very CPU-intensive.
287 # To enable system wide have in $GITWEB_CONFIG
288 # $feature{'blame'}{'default'} = [1];
289 # To have project specific config enable override in $GITWEB_CONFIG
290 # $feature{'blame'}{'override'} = 1;
291 # and in project config gitweb.blame = 0|1;
293 'sub' => sub { feature_bool
('blame', @_) },
297 # Enable the 'snapshot' link, providing a compressed archive of any
298 # tree. This can potentially generate high traffic if you have large
301 # Value is a list of formats defined in %known_snapshot_formats that
303 # To disable system wide have in $GITWEB_CONFIG
304 # $feature{'snapshot'}{'default'} = [];
305 # To have project specific config enable override in $GITWEB_CONFIG
306 # $feature{'snapshot'}{'override'} = 1;
307 # and in project config, a comma-separated list of formats or "none"
308 # to disable. Example: gitweb.snapshot = tbz2,zip;
310 'sub' => \
&feature_snapshot
,
312 'default' => ['tgz']},
314 # Enable text search, which will list the commits which match author,
315 # committer or commit text to a given string. Enabled by default.
316 # Project specific override is not supported.
321 # Enable grep search, which will list the files in currently selected
322 # tree containing the given string. Enabled by default. This can be
323 # potentially CPU-intensive, of course.
325 # To enable system wide have in $GITWEB_CONFIG
326 # $feature{'grep'}{'default'} = [1];
327 # To have project specific config enable override in $GITWEB_CONFIG
328 # $feature{'grep'}{'override'} = 1;
329 # and in project config gitweb.grep = 0|1;
331 'sub' => sub { feature_bool
('grep', @_) },
335 # Enable the pickaxe search, which will list the commits that modified
336 # a given string in a file. This can be practical and quite faster
337 # alternative to 'blame', but still potentially CPU-intensive.
339 # To enable system wide have in $GITWEB_CONFIG
340 # $feature{'pickaxe'}{'default'} = [1];
341 # To have project specific config enable override in $GITWEB_CONFIG
342 # $feature{'pickaxe'}{'override'} = 1;
343 # and in project config gitweb.pickaxe = 0|1;
345 'sub' => sub { feature_bool
('pickaxe', @_) },
349 # Enable showing size of blobs in a 'tree' view, in a separate
350 # column, similar to what 'ls -l' does. This cost a bit of IO.
352 # To disable system wide have in $GITWEB_CONFIG
353 # $feature{'show-sizes'}{'default'} = [0];
354 # To have project specific config enable override in $GITWEB_CONFIG
355 # $feature{'show-sizes'}{'override'} = 1;
356 # and in project config gitweb.showsizes = 0|1;
358 'sub' => sub { feature_bool
('showsizes', @_) },
362 # Make gitweb use an alternative format of the URLs which can be
363 # more readable and natural-looking: project name is embedded
364 # directly in the path and the query string contains other
365 # auxiliary information. All gitweb installations recognize
366 # URL in either format; this configures in which formats gitweb
369 # To enable system wide have in $GITWEB_CONFIG
370 # $feature{'pathinfo'}{'default'} = [1];
371 # Project specific override is not supported.
373 # Note that you will need to change the default location of CSS,
374 # favicon, logo and possibly other files to an absolute URL. Also,
375 # if gitweb.cgi serves as your indexfile, you will need to force
376 # $my_uri to contain the script name in your $GITWEB_CONFIG.
381 # Make gitweb consider projects in project root subdirectories
382 # to be forks of existing projects. Given project $projname.git,
383 # projects matching $projname/*.git will not be shown in the main
384 # projects list, instead a '+' mark will be added to $projname
385 # there and a 'forks' view will be enabled for the project, listing
386 # all the forks. If project list is taken from a file, forks have
387 # to be listed after the main project.
389 # To enable system wide have in $GITWEB_CONFIG
390 # $feature{'forks'}{'default'} = [1];
391 # Project specific override is not supported.
396 # Insert custom links to the action bar of all project pages.
397 # This enables you mainly to link to third-party scripts integrating
398 # into gitweb; e.g. git-browser for graphical history representation
399 # or custom web-based repository administration interface.
401 # The 'default' value consists of a list of triplets in the form
402 # (label, link, position) where position is the label after which
403 # to insert the link and link is a format string where %n expands
404 # to the project name, %f to the project path within the filesystem,
405 # %h to the current hash (h gitweb parameter) and %b to the current
406 # hash base (hb gitweb parameter); %% expands to %.
408 # To enable system wide have in $GITWEB_CONFIG e.g.
409 # $feature{'actions'}{'default'} = [('graphiclog',
410 # '/git-browser/by-commit.html?r=%n', 'summary')];
411 # Project specific override is not supported.
416 # Allow gitweb scan project content tags described in ctags/
417 # of project repository, and display the popular Web 2.0-ish
418 # "tag cloud" near the project list. Note that this is something
419 # COMPLETELY different from the normal Git tags.
421 # gitweb by itself can show existing tags, but it does not handle
422 # tagging itself; you need an external application for that.
423 # For an example script, check Girocco's cgi/tagproj.cgi.
424 # You may want to install the HTML::TagCloud Perl module to get
425 # a pretty tag cloud instead of just a list of tags.
427 # To enable system wide have in $GITWEB_CONFIG
428 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
429 # Project specific override is not supported.
434 # The maximum number of patches in a patchset generated in patch
435 # view. Set this to 0 or undef to disable patch view, or to a
436 # negative number to remove any limit.
438 # To disable system wide have in $GITWEB_CONFIG
439 # $feature{'patches'}{'default'} = [0];
440 # To have project specific config enable override in $GITWEB_CONFIG
441 # $feature{'patches'}{'override'} = 1;
442 # and in project config gitweb.patches = 0|n;
443 # where n is the maximum number of patches allowed in a patchset.
445 'sub' => \
&feature_patches
,
449 # Avatar support. When this feature is enabled, views such as
450 # shortlog or commit will display an avatar associated with
451 # the email of the committer(s) and/or author(s).
453 # Currently available providers are gravatar and picon.
454 # If an unknown provider is specified, the feature is disabled.
456 # Gravatar depends on Digest::MD5.
457 # Picon currently relies on the indiana.edu database.
459 # To enable system wide have in $GITWEB_CONFIG
460 # $feature{'avatar'}{'default'} = ['<provider>'];
461 # where <provider> is either gravatar or picon.
462 # To have project specific config enable override in $GITWEB_CONFIG
463 # $feature{'avatar'}{'override'} = 1;
464 # and in project config gitweb.avatar = <provider>;
466 'sub' => \
&feature_avatar
,
470 # Enable displaying how much time and how many git commands
471 # it took to generate and display page. Disabled by default.
472 # Project specific override is not supported.
477 # Enable turning some links into links to actions which require
478 # JavaScript to run (like 'blame_incremental'). Not enabled by
479 # default. Project specific override is currently not supported.
480 'javascript-actions' => {
484 # Syntax highlighting support. This is based on Daniel Svensson's
485 # and Sham Chukoury's work in gitweb-xmms2.git.
486 # It requires the 'highlight' program present in $PATH,
487 # and therefore is disabled by default.
489 # To enable system wide have in $GITWEB_CONFIG
490 # $feature{'highlight'}{'default'} = [1];
493 'sub' => sub { feature_bool
('highlight', @_) },
497 # Enable displaying of remote heads in the heads list
499 # To enable system wide have in $GITWEB_CONFIG
500 # $feature{'remote_heads'}{'default'} = [1];
501 # To have project specific config enable override in $GITWEB_CONFIG
502 # $feature{'remote_heads'}{'override'} = 1;
503 # and in project config gitweb.remote_heads = 0|1;
505 'sub' => sub { feature_bool
('remote_heads', @_) },
510 sub gitweb_get_feature
{
512 return unless exists $feature{$name};
513 my ($sub, $override, @defaults) = (
514 $feature{$name}{'sub'},
515 $feature{$name}{'override'},
516 @
{$feature{$name}{'default'}});
517 # project specific override is possible only if we have project
518 our $git_dir; # global variable, declared later
519 if (!$override || !defined $git_dir) {
523 warn "feature $name is not overridable";
526 return $sub->(@defaults);
529 # A wrapper to check if a given feature is enabled.
530 # With this, you can say
532 # my $bool_feat = gitweb_check_feature('bool_feat');
533 # gitweb_check_feature('bool_feat') or somecode;
537 # my ($bool_feat) = gitweb_get_feature('bool_feat');
538 # (gitweb_get_feature('bool_feat'))[0] or somecode;
540 sub gitweb_check_feature
{
541 return (gitweb_get_feature
(@_))[0];
547 my ($val) = git_get_project_config
($key, '--bool');
551 } elsif ($val eq 'true') {
553 } elsif ($val eq 'false') {
558 sub feature_snapshot
{
561 my ($val) = git_get_project_config
('snapshot');
564 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
570 sub feature_patches
{
571 my @val = (git_get_project_config
('patches', '--int'));
581 my @val = (git_get_project_config
('avatar'));
583 return @val ?
@val : @_;
586 # checking HEAD file with -e is fragile if the repository was
587 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
589 sub check_head_link
{
591 my $headfile = "$dir/HEAD";
592 return ((-e
$headfile) ||
593 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
596 sub check_export_ok
{
598 return (check_head_link
($dir) &&
599 (!$export_ok || -e
"$dir/$export_ok") &&
600 (!$export_auth_hook || $export_auth_hook->($dir)));
603 # process alternate names for backward compatibility
604 # filter out unsupported (unknown) snapshot formats
605 sub filter_snapshot_fmts
{
609 exists $known_snapshot_format_aliases{$_} ?
610 $known_snapshot_format_aliases{$_} : $_} @fmts;
612 exists $known_snapshot_formats{$_} &&
613 !$known_snapshot_formats{$_}{'disabled'}} @fmts;
616 our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM);
617 sub evaluate_gitweb_config
{
618 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
619 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
620 # die if there are errors parsing config file
621 if (-e
$GITWEB_CONFIG) {
624 } elsif (-e
$GITWEB_CONFIG_SYSTEM) {
625 do $GITWEB_CONFIG_SYSTEM;
630 # Get loadavg of system, to compare against $maxload.
631 # Currently it requires '/proc/loadavg' present to get loadavg;
632 # if it is not present it returns 0, which means no load checking.
634 if( -e
'/proc/loadavg' ){
635 open my $fd, '<', '/proc/loadavg'
637 my @load = split(/\s+/, scalar <$fd>);
640 # The first three columns measure CPU and IO utilization of the last one,
641 # five, and 10 minute periods. The fourth column shows the number of
642 # currently running processes and the total number of processes in the m/n
643 # format. The last column displays the last process ID used.
644 return $load[0] || 0;
646 # additional checks for load average should go here for things that don't export
652 # version of the core git binary
654 sub evaluate_git_version
{
655 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
656 $number_of_git_cmds++;
660 if (defined $maxload && get_loadavg
() > $maxload) {
661 die_error
(503, "The load average on the server is too high");
665 # ======================================================================
666 # input validation and dispatch
668 # input parameters can be collected from a variety of sources (presently, CGI
669 # and PATH_INFO), so we define an %input_params hash that collects them all
670 # together during validation: this allows subsequent uses (e.g. href()) to be
671 # agnostic of the parameter origin
673 our %input_params = ();
675 # input parameters are stored with the long parameter name as key. This will
676 # also be used in the href subroutine to convert parameters to their CGI
677 # equivalent, and since the href() usage is the most frequent one, we store
678 # the name -> CGI key mapping here, instead of the reverse.
680 # XXX: Warning: If you touch this, check the search form for updating,
683 our @cgi_param_mapping = (
691 hash_parent_base
=> "hpb",
696 snapshot_format
=> "sf",
697 extra_options
=> "opt",
698 search_use_regexp
=> "sr",
699 # this must be last entry (for manipulation from JavaScript)
702 our %cgi_param_mapping = @cgi_param_mapping;
704 # we will also need to know the possible actions, for validation
706 "blame" => \
&git_blame
,
707 "blame_incremental" => \
&git_blame_incremental
,
708 "blame_data" => \
&git_blame_data
,
709 "blobdiff" => \
&git_blobdiff
,
710 "blobdiff_plain" => \
&git_blobdiff_plain
,
711 "blob" => \
&git_blob
,
712 "blob_plain" => \
&git_blob_plain
,
713 "commitdiff" => \
&git_commitdiff
,
714 "commitdiff_plain" => \
&git_commitdiff_plain
,
715 "commit" => \
&git_commit
,
716 "forks" => \
&git_forks
,
717 "heads" => \
&git_heads
,
718 "history" => \
&git_history
,
720 "patch" => \
&git_patch
,
721 "patches" => \
&git_patches
,
722 "remotes" => \
&git_remotes
,
724 "atom" => \
&git_atom
,
725 "search" => \
&git_search
,
726 "search_help" => \
&git_search_help
,
727 "shortlog" => \
&git_shortlog
,
728 "summary" => \
&git_summary
,
730 "tags" => \
&git_tags
,
731 "tree" => \
&git_tree
,
732 "snapshot" => \
&git_snapshot
,
733 "object" => \
&git_object
,
734 # those below don't need $project
735 "opml" => \
&git_opml
,
736 "project_list" => \
&git_project_list
,
737 "project_index" => \
&git_project_index
,
740 # finally, we have the hash of allowed extra_options for the commands that
742 our %allowed_options = (
743 "--no-merges" => [ qw(rss atom log shortlog history) ],
746 # fill %input_params with the CGI parameters. All values except for 'opt'
747 # should be single values, but opt can be an array. We should probably
748 # build an array of parameters that can be multi-valued, but since for the time
749 # being it's only this one, we just single it out
750 sub evaluate_query_params
{
753 while (my ($name, $symbol) = each %cgi_param_mapping) {
754 if ($symbol eq 'opt') {
755 $input_params{$name} = [ $cgi->param($symbol) ];
757 $input_params{$name} = $cgi->param($symbol);
762 # now read PATH_INFO and update the parameter list for missing parameters
763 sub evaluate_path_info
{
764 return if defined $input_params{'project'};
765 return if !$path_info;
766 $path_info =~ s
,^/+,,;
767 return if !$path_info;
769 # find which part of PATH_INFO is project
770 my $project = $path_info;
772 while ($project && !check_head_link
("$projectroot/$project")) {
773 $project =~ s
,/*[^/]*$,,;
775 return unless $project;
776 $input_params{'project'} = $project;
778 # do not change any parameters if an action is given using the query string
779 return if $input_params{'action'};
780 $path_info =~ s
,^\Q
$project\E
/*,,;
782 # next, check if we have an action
783 my $action = $path_info;
785 if (exists $actions{$action}) {
786 $path_info =~ s
,^$action/*,,;
787 $input_params{'action'} = $action;
790 # list of actions that want hash_base instead of hash, but can have no
791 # pathname (f) parameter
797 # we want to catch, among others
798 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
799 my ($parentrefname, $parentpathname, $refname, $pathname) =
800 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?([^:]+?)?(?::(.+))?$/);
802 # first, analyze the 'current' part
803 if (defined $pathname) {
804 # we got "branch:filename" or "branch:dir/"
805 # we could use git_get_type(branch:pathname), but:
806 # - it needs $git_dir
807 # - it does a git() call
808 # - the convention of terminating directories with a slash
809 # makes it superfluous
810 # - embedding the action in the PATH_INFO would make it even
812 $pathname =~ s
,^/+,,;
813 if (!$pathname || substr($pathname, -1) eq "/") {
814 $input_params{'action'} ||= "tree";
817 # the default action depends on whether we had parent info
819 if ($parentrefname) {
820 $input_params{'action'} ||= "blobdiff_plain";
822 $input_params{'action'} ||= "blob_plain";
825 $input_params{'hash_base'} ||= $refname;
826 $input_params{'file_name'} ||= $pathname;
827 } elsif (defined $refname) {
828 # we got "branch". In this case we have to choose if we have to
829 # set hash or hash_base.
831 # Most of the actions without a pathname only want hash to be
832 # set, except for the ones specified in @wants_base that want
833 # hash_base instead. It should also be noted that hand-crafted
834 # links having 'history' as an action and no pathname or hash
835 # set will fail, but that happens regardless of PATH_INFO.
836 if (defined $parentrefname) {
837 # if there is parent let the default be 'shortlog' action
838 # (for http://git.example.com/repo.git/A..B links); if there
839 # is no parent, dispatch will detect type of object and set
840 # action appropriately if required (if action is not set)
841 $input_params{'action'} ||= "shortlog";
843 if ($input_params{'action'} &&
844 grep { $_ eq $input_params{'action'} } @wants_base) {
845 $input_params{'hash_base'} ||= $refname;
847 $input_params{'hash'} ||= $refname;
851 # next, handle the 'parent' part, if present
852 if (defined $parentrefname) {
853 # a missing pathspec defaults to the 'current' filename, allowing e.g.
854 # someproject/blobdiff/oldrev..newrev:/filename
855 if ($parentpathname) {
856 $parentpathname =~ s
,^/+,,;
857 $parentpathname =~ s
,/$,,;
858 $input_params{'file_parent'} ||= $parentpathname;
860 $input_params{'file_parent'} ||= $input_params{'file_name'};
862 # we assume that hash_parent_base is wanted if a path was specified,
863 # or if the action wants hash_base instead of hash
864 if (defined $input_params{'file_parent'} ||
865 grep { $_ eq $input_params{'action'} } @wants_base) {
866 $input_params{'hash_parent_base'} ||= $parentrefname;
868 $input_params{'hash_parent'} ||= $parentrefname;
872 # for the snapshot action, we allow URLs in the form
873 # $project/snapshot/$hash.ext
874 # where .ext determines the snapshot and gets removed from the
875 # passed $refname to provide the $hash.
877 # To be able to tell that $refname includes the format extension, we
878 # require the following two conditions to be satisfied:
879 # - the hash input parameter MUST have been set from the $refname part
880 # of the URL (i.e. they must be equal)
881 # - the snapshot format MUST NOT have been defined already (e.g. from
883 # It's also useless to try any matching unless $refname has a dot,
884 # so we check for that too
885 if (defined $input_params{'action'} &&
886 $input_params{'action'} eq 'snapshot' &&
887 defined $refname && index($refname, '.') != -1 &&
888 $refname eq $input_params{'hash'} &&
889 !defined $input_params{'snapshot_format'}) {
890 # We loop over the known snapshot formats, checking for
891 # extensions. Allowed extensions are both the defined suffix
892 # (which includes the initial dot already) and the snapshot
893 # format key itself, with a prepended dot
894 while (my ($fmt, $opt) = each %known_snapshot_formats) {
896 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
900 # a valid suffix was found, so set the snapshot format
901 # and reset the hash parameter
902 $input_params{'snapshot_format'} = $fmt;
903 $input_params{'hash'} = $hash;
904 # we also set the format suffix to the one requested
905 # in the URL: this way a request for e.g. .tgz returns
906 # a .tgz instead of a .tar.gz
907 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
913 our ($action, $project, $file_name, $file_parent, $hash, $hash_parent, $hash_base,
914 $hash_parent_base, @extra_options, $page, $searchtype, $search_use_regexp,
915 $searchtext, $search_regexp);
916 sub evaluate_and_validate_params
{
917 our $action = $input_params{'action'};
918 if (defined $action) {
919 if (!validate_action
($action)) {
920 die_error
(400, "Invalid action parameter");
924 # parameters which are pathnames
925 our $project = $input_params{'project'};
926 if (defined $project) {
927 if (!validate_project
($project)) {
929 die_error
(404, "No such project");
933 our $file_name = $input_params{'file_name'};
934 if (defined $file_name) {
935 if (!validate_pathname
($file_name)) {
936 die_error
(400, "Invalid file parameter");
940 our $file_parent = $input_params{'file_parent'};
941 if (defined $file_parent) {
942 if (!validate_pathname
($file_parent)) {
943 die_error
(400, "Invalid file parent parameter");
947 # parameters which are refnames
948 our $hash = $input_params{'hash'};
950 if (!validate_refname
($hash)) {
951 die_error
(400, "Invalid hash parameter");
955 our $hash_parent = $input_params{'hash_parent'};
956 if (defined $hash_parent) {
957 if (!validate_refname
($hash_parent)) {
958 die_error
(400, "Invalid hash parent parameter");
962 our $hash_base = $input_params{'hash_base'};
963 if (defined $hash_base) {
964 if (!validate_refname
($hash_base)) {
965 die_error
(400, "Invalid hash base parameter");
969 our @extra_options = @
{$input_params{'extra_options'}};
970 # @extra_options is always defined, since it can only be (currently) set from
971 # CGI, and $cgi->param() returns the empty array in array context if the param
973 foreach my $opt (@extra_options) {
974 if (not exists $allowed_options{$opt}) {
975 die_error
(400, "Invalid option parameter");
977 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
978 die_error
(400, "Invalid option parameter for this action");
982 our $hash_parent_base = $input_params{'hash_parent_base'};
983 if (defined $hash_parent_base) {
984 if (!validate_refname
($hash_parent_base)) {
985 die_error
(400, "Invalid hash parent base parameter");
990 our $page = $input_params{'page'};
992 if ($page =~ m/[^0-9]/) {
993 die_error
(400, "Invalid page parameter");
997 our $searchtype = $input_params{'searchtype'};
998 if (defined $searchtype) {
999 if ($searchtype =~ m/[^a-z]/) {
1000 die_error
(400, "Invalid searchtype parameter");
1004 our $search_use_regexp = $input_params{'search_use_regexp'};
1006 our $searchtext = $input_params{'searchtext'};
1008 if (defined $searchtext) {
1009 if (length($searchtext) < 2) {
1010 die_error
(403, "At least two characters are required for search parameter");
1012 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
1016 # path to the current git repository
1018 sub evaluate_git_dir
{
1019 our $git_dir = "$projectroot/$project" if $project;
1022 our (@snapshot_fmts, $git_avatar);
1023 sub configure_gitweb_features
{
1024 # list of supported snapshot formats
1025 our @snapshot_fmts = gitweb_get_feature
('snapshot');
1026 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1028 # check that the avatar feature is set to a known provider name,
1029 # and for each provider check if the dependencies are satisfied.
1030 # if the provider name is invalid or the dependencies are not met,
1031 # reset $git_avatar to the empty string.
1032 our ($git_avatar) = gitweb_get_feature
('avatar');
1033 if ($git_avatar eq 'gravatar') {
1034 $git_avatar = '' unless (eval { require Digest
::MD5
; 1; });
1035 } elsif ($git_avatar eq 'picon') {
1042 # custom error handler: 'die <message>' is Internal Server Error
1043 sub handle_errors_html
{
1044 my $msg = shift; # it is already HTML escaped
1046 # to avoid infinite loop where error occurs in die_error,
1047 # change handler to default handler, disabling handle_errors_html
1048 set_message
("Error occured when inside die_error:\n$msg");
1050 # you cannot jump out of die_error when called as error handler;
1051 # the subroutine set via CGI::Carp::set_message is called _after_
1052 # HTTP headers are already written, so it cannot write them itself
1053 die_error
(undef, undef, $msg, -error_handler
=> 1, -no_http_header
=> 1);
1055 set_message
(\
&handle_errors_html
);
1059 if (!defined $action) {
1060 if (defined $hash) {
1061 $action = git_get_type
($hash);
1062 } elsif (defined $hash_base && defined $file_name) {
1063 $action = git_get_type
("$hash_base:$file_name");
1064 } elsif (defined $project) {
1065 $action = 'summary';
1067 $action = 'project_list';
1070 if (!defined($actions{$action})) {
1071 die_error
(400, "Unknown action");
1073 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1075 die_error
(400, "Project needed");
1077 $actions{$action}->();
1081 our $t0 = [Time
::HiRes
::gettimeofday
()]
1083 our $number_of_git_cmds = 0;
1090 evaluate_gitweb_config
();
1093 # $projectroot and $projects_list might be set in gitweb config file
1094 $projects_list ||= $projectroot;
1096 evaluate_query_params
();
1097 evaluate_path_info
();
1098 evaluate_and_validate_params
();
1101 configure_gitweb_features
();
1106 our $is_last_request = sub { 1 };
1107 our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1110 sub configure_as_fcgi
{
1112 our $CGI = 'CGI::Fast';
1114 my $request_number = 0;
1115 # let each child service 100 requests
1116 our $is_last_request = sub { ++$request_number > 100 };
1119 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__
;
1121 if $script_name =~ /\.fcgi$/;
1123 return unless (@ARGV);
1125 require Getopt
::Long
;
1126 Getopt
::Long
::GetOptions
(
1127 'fastcgi|fcgi|f' => \
&configure_as_fcgi
,
1128 'nproc|n=i' => sub {
1129 my ($arg, $val) = @_;
1130 return unless eval { require FCGI
::ProcManager
; 1; };
1131 my $proc_manager = FCGI
::ProcManager
->new({
1132 n_processes
=> $val,
1134 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1135 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1136 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1143 evaluate_git_version
();
1145 $pre_listen_hook->()
1146 if $pre_listen_hook;
1149 while ($cgi = $CGI->new()) {
1150 $pre_dispatch_hook->()
1151 if $pre_dispatch_hook;
1155 $post_dispatch_hook->()
1156 if $post_dispatch_hook;
1158 last REQUEST
if ($is_last_request->());
1167 if (defined caller) {
1168 # wrapped in a subroutine processing requests,
1169 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1172 # pure CGI script, serving single request
1176 ## ======================================================================
1179 # possible values of extra options
1180 # -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1181 # -replay => 1 - start from a current view (replay with modifications)
1182 # -path_info => 0|1 - don't use/use path_info URL (if possible)
1185 # default is to use -absolute url() i.e. $my_uri
1186 my $href = $params{-full
} ?
$my_url : $my_uri;
1188 $params{'project'} = $project unless exists $params{'project'};
1190 if ($params{-replay
}) {
1191 while (my ($name, $symbol) = each %cgi_param_mapping) {
1192 if (!exists $params{$name}) {
1193 $params{$name} = $input_params{$name};
1198 my $use_pathinfo = gitweb_check_feature
('pathinfo');
1199 if (defined $params{'project'} &&
1200 (exists $params{-path_info
} ?
$params{-path_info
} : $use_pathinfo)) {
1201 # try to put as many parameters as possible in PATH_INFO:
1204 # - hash_parent or hash_parent_base:/file_parent
1205 # - hash or hash_base:/filename
1206 # - the snapshot_format as an appropriate suffix
1208 # When the script is the root DirectoryIndex for the domain,
1209 # $href here would be something like http://gitweb.example.com/
1210 # Thus, we strip any trailing / from $href, to spare us double
1211 # slashes in the final URL
1214 # Then add the project name, if present
1215 $href .= "/".esc_url
($params{'project'});
1216 delete $params{'project'};
1218 # since we destructively absorb parameters, we keep this
1219 # boolean that remembers if we're handling a snapshot
1220 my $is_snapshot = $params{'action'} eq 'snapshot';
1222 # Summary just uses the project path URL, any other action is
1224 if (defined $params{'action'}) {
1225 $href .= "/".esc_url
($params{'action'}) unless $params{'action'} eq 'summary';
1226 delete $params{'action'};
1229 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1230 # stripping nonexistent or useless pieces
1231 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1232 || $params{'hash_parent'} || $params{'hash'});
1233 if (defined $params{'hash_base'}) {
1234 if (defined $params{'hash_parent_base'}) {
1235 $href .= esc_url
($params{'hash_parent_base'});
1236 # skip the file_parent if it's the same as the file_name
1237 if (defined $params{'file_parent'}) {
1238 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1239 delete $params{'file_parent'};
1240 } elsif ($params{'file_parent'} !~ /\.\./) {
1241 $href .= ":/".esc_url
($params{'file_parent'});
1242 delete $params{'file_parent'};
1246 delete $params{'hash_parent'};
1247 delete $params{'hash_parent_base'};
1248 } elsif (defined $params{'hash_parent'}) {
1249 $href .= esc_url
($params{'hash_parent'}). "..";
1250 delete $params{'hash_parent'};
1253 $href .= esc_url
($params{'hash_base'});
1254 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
1255 $href .= ":/".esc_url
($params{'file_name'});
1256 delete $params{'file_name'};
1258 delete $params{'hash'};
1259 delete $params{'hash_base'};
1260 } elsif (defined $params{'hash'}) {
1261 $href .= esc_url
($params{'hash'});
1262 delete $params{'hash'};
1265 # If the action was a snapshot, we can absorb the
1266 # snapshot_format parameter too
1268 my $fmt = $params{'snapshot_format'};
1269 # snapshot_format should always be defined when href()
1270 # is called, but just in case some code forgets, we
1271 # fall back to the default
1272 $fmt ||= $snapshot_fmts[0];
1273 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1274 delete $params{'snapshot_format'};
1278 # now encode the parameters explicitly
1280 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1281 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
1282 if (defined $params{$name}) {
1283 if (ref($params{$name}) eq "ARRAY") {
1284 foreach my $par (@
{$params{$name}}) {
1285 push @result, $symbol . "=" . esc_param
($par);
1288 push @result, $symbol . "=" . esc_param
($params{$name});
1292 $href .= "?" . join(';', @result) if scalar @result;
1298 ## ======================================================================
1299 ## validation, quoting/unquoting and escaping
1301 sub validate_action
{
1302 my $input = shift || return undef;
1303 return undef unless exists $actions{$input};
1307 sub validate_project
{
1308 my $input = shift || return undef;
1309 if (!validate_pathname
($input) ||
1310 !(-d
"$projectroot/$input") ||
1311 !check_export_ok
("$projectroot/$input") ||
1312 ($strict_export && !project_in_list
($input))) {
1319 sub validate_pathname
{
1320 my $input = shift || return undef;
1322 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1323 # at the beginning, at the end, and between slashes.
1324 # also this catches doubled slashes
1325 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1328 # no null characters
1329 if ($input =~ m!\0!) {
1335 sub validate_refname
{
1336 my $input = shift || return undef;
1338 # textual hashes are O.K.
1339 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1342 # it must be correct pathname
1343 $input = validate_pathname
($input)
1345 # restrictions on ref name according to git-check-ref-format
1346 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1352 # decode sequences of octets in utf8 into Perl's internal form,
1353 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1354 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1357 return undef unless defined $str;
1358 if (utf8
::valid
($str)) {
1362 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
1366 # quote unsafe chars, but keep the slash, even when it's not
1367 # correct, but quoted slashes look too horrible in bookmarks
1370 return undef unless defined $str;
1371 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI
::escape
($1)/eg
;
1376 # quote unsafe chars in whole URL, so some characters cannot be quoted
1379 return undef unless defined $str;
1380 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI
::escape
($1)/eg
;
1385 # replace invalid utf8 character with SUBSTITUTION sequence
1390 return undef unless defined $str;
1392 $str = to_utf8
($str);
1393 $str = $cgi->escapeHTML($str);
1394 if ($opts{'-nbsp'}) {
1395 $str =~ s/ / /g;
1397 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1401 # quote control characters and escape filename to HTML
1406 return undef unless defined $str;
1408 $str = to_utf8
($str);
1409 $str = $cgi->escapeHTML($str);
1410 if ($opts{'-nbsp'}) {
1411 $str =~ s/ / /g;
1413 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1417 # Make control characters "printable", using character escape codes (CEC)
1421 my %es = ( # character escape codes, aka escape sequences
1422 "\t" => '\t', # tab (HT)
1423 "\n" => '\n', # line feed (LF)
1424 "\r" => '\r', # carrige return (CR)
1425 "\f" => '\f', # form feed (FF)
1426 "\b" => '\b', # backspace (BS)
1427 "\a" => '\a', # alarm (bell) (BEL)
1428 "\e" => '\e', # escape (ESC)
1429 "\013" => '\v', # vertical tab (VT)
1430 "\000" => '\0', # nul character (NUL)
1432 my $chr = ( (exists $es{$cntrl})
1434 : sprintf('\%2x', ord($cntrl)) );
1435 if ($opts{-nohtml
}) {
1438 return "<span class=\"cntrl\">$chr</span>";
1442 # Alternatively use unicode control pictures codepoints,
1443 # Unicode "printable representation" (PR)
1448 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1449 if ($opts{-nohtml
}) {
1452 return "<span class=\"cntrl\">$chr</span>";
1456 # git may return quoted and escaped filenames
1462 my %es = ( # character escape codes, aka escape sequences
1463 't' => "\t", # tab (HT, TAB)
1464 'n' => "\n", # newline (NL)
1465 'r' => "\r", # return (CR)
1466 'f' => "\f", # form feed (FF)
1467 'b' => "\b", # backspace (BS)
1468 'a' => "\a", # alarm (bell) (BEL)
1469 'e' => "\e", # escape (ESC)
1470 'v' => "\013", # vertical tab (VT)
1473 if ($seq =~ m/^[0-7]{1,3}$/) {
1474 # octal char sequence
1475 return chr(oct($seq));
1476 } elsif (exists $es{$seq}) {
1477 # C escape sequence, aka character escape code
1480 # quoted ordinary character
1484 if ($str =~ m/^"(.*)"$/) {
1487 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1492 # escape tabs (convert tabs to spaces)
1496 while ((my $pos = index($line, "\t")) != -1) {
1497 if (my $count = (8 - ($pos % 8))) {
1498 my $spaces = ' ' x
$count;
1499 $line =~ s/\t/$spaces/;
1506 sub project_in_list
{
1507 my $project = shift;
1508 my @list = git_get_projects_list
();
1509 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1512 ## ----------------------------------------------------------------------
1513 ## HTML aware string manipulation
1515 # Try to chop given string on a word boundary between position
1516 # $len and $len+$add_len. If there is no word boundary there,
1517 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1518 # (marking chopped part) would be longer than given string.
1522 my $add_len = shift || 10;
1523 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1525 # Make sure perl knows it is utf8 encoded so we don't
1526 # cut in the middle of a utf8 multibyte char.
1527 $str = to_utf8
($str);
1529 # allow only $len chars, but don't cut a word if it would fit in $add_len
1530 # if it doesn't fit, cut it if it's still longer than the dots we would add
1531 # remove chopped character entities entirely
1533 # when chopping in the middle, distribute $len into left and right part
1534 # return early if chopping wouldn't make string shorter
1535 if ($where eq 'center') {
1536 return $str if ($len + 5 >= length($str)); # filler is length 5
1539 return $str if ($len + 4 >= length($str)); # filler is length 4
1542 # regexps: ending and beginning with word part up to $add_len
1543 my $endre = qr/.{$len}\w{0,$add_len}/;
1544 my $begre = qr/\w{0,$add_len}.{$len}/;
1546 if ($where eq 'left') {
1547 $str =~ m/^(.*?)($begre)$/;
1548 my ($lead, $body) = ($1, $2);
1549 if (length($lead) > 4) {
1552 return "$lead$body";
1554 } elsif ($where eq 'center') {
1555 $str =~ m/^($endre)(.*)$/;
1556 my ($left, $str) = ($1, $2);
1557 $str =~ m/^(.*?)($begre)$/;
1558 my ($mid, $right) = ($1, $2);
1559 if (length($mid) > 5) {
1562 return "$left$mid$right";
1565 $str =~ m/^($endre)(.*)$/;
1568 if (length($tail) > 4) {
1571 return "$body$tail";
1575 # takes the same arguments as chop_str, but also wraps a <span> around the
1576 # result with a title attribute if it does get chopped. Additionally, the
1577 # string is HTML-escaped.
1578 sub chop_and_escape_str
{
1581 my $chopped = chop_str
(@_);
1582 if ($chopped eq $str) {
1583 return esc_html
($chopped);
1585 $str =~ s/[[:cntrl:]]/?/g;
1586 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1590 ## ----------------------------------------------------------------------
1591 ## functions returning short strings
1593 # CSS class for given age value (in seconds)
1597 if (!defined $age) {
1599 } elsif ($age < 60*60*2) {
1601 } elsif ($age < 60*60*24*2) {
1608 # convert age in seconds to "nn units ago" string
1613 if ($age > 60*60*24*365*2) {
1614 $age_str = (int $age/60/60/24/365);
1615 $age_str .= " years ago";
1616 } elsif ($age > 60*60*24*(365/12)*2) {
1617 $age_str = int $age/60/60/24/(365/12);
1618 $age_str .= " months ago";
1619 } elsif ($age > 60*60*24*7*2) {
1620 $age_str = int $age/60/60/24/7;
1621 $age_str .= " weeks ago";
1622 } elsif ($age > 60*60*24*2) {
1623 $age_str = int $age/60/60/24;
1624 $age_str .= " days ago";
1625 } elsif ($age > 60*60*2) {
1626 $age_str = int $age/60/60;
1627 $age_str .= " hours ago";
1628 } elsif ($age > 60*2) {
1629 $age_str = int $age/60;
1630 $age_str .= " min ago";
1631 } elsif ($age > 2) {
1632 $age_str = int $age;
1633 $age_str .= " sec ago";
1635 $age_str .= " right now";
1641 S_IFINVALID
=> 0030000,
1642 S_IFGITLINK
=> 0160000,
1645 # submodule/subproject, a commit object reference
1649 return (($mode & S_IFMT
) == S_IFGITLINK
)
1652 # convert file mode in octal to symbolic file mode string
1654 my $mode = oct shift;
1656 if (S_ISGITLINK
($mode)) {
1657 return 'm---------';
1658 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1659 return 'drwxr-xr-x';
1660 } elsif (S_ISLNK
($mode)) {
1661 return 'lrwxrwxrwx';
1662 } elsif (S_ISREG
($mode)) {
1663 # git cares only about the executable bit
1664 if ($mode & S_IXUSR
) {
1665 return '-rwxr-xr-x';
1667 return '-rw-r--r--';
1670 return '----------';
1674 # convert file mode in octal to file type string
1678 if ($mode !~ m/^[0-7]+$/) {
1684 if (S_ISGITLINK
($mode)) {
1686 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1688 } elsif (S_ISLNK
($mode)) {
1690 } elsif (S_ISREG
($mode)) {
1697 # convert file mode in octal to file type description string
1698 sub file_type_long
{
1701 if ($mode !~ m/^[0-7]+$/) {
1707 if (S_ISGITLINK
($mode)) {
1709 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1711 } elsif (S_ISLNK
($mode)) {
1713 } elsif (S_ISREG
($mode)) {
1714 if ($mode & S_IXUSR
) {
1715 return "executable";
1725 ## ----------------------------------------------------------------------
1726 ## functions returning short HTML fragments, or transforming HTML fragments
1727 ## which don't belong to other sections
1729 # format line of commit message.
1730 sub format_log_line_html
{
1733 $line = esc_html
($line, -nbsp
=>1);
1734 $line =~ s
{\b([0-9a
-fA
-F
]{8,40})\b}{
1735 $cgi->a({-href
=> href
(action
=>"object", hash
=>$1),
1736 -class => "text"}, $1);
1742 # format marker of refs pointing to given object
1744 # the destination action is chosen based on object type and current context:
1745 # - for annotated tags, we choose the tag view unless it's the current view
1746 # already, in which case we go to shortlog view
1747 # - for other refs, we keep the current view if we're in history, shortlog or
1748 # log view, and select shortlog otherwise
1749 sub format_ref_marker
{
1750 my ($refs, $id) = @_;
1753 if (defined $refs->{$id}) {
1754 foreach my $ref (@
{$refs->{$id}}) {
1755 # this code exploits the fact that non-lightweight tags are the
1756 # only indirect objects, and that they are the only objects for which
1757 # we want to use tag instead of shortlog as action
1758 my ($type, $name) = qw();
1759 my $indirect = ($ref =~ s/\^\{\}$//);
1760 # e.g. tags/v2.6.11 or heads/next
1761 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1770 $class .= " indirect" if $indirect;
1772 my $dest_action = "shortlog";
1775 $dest_action = "tag" unless $action eq "tag";
1776 } elsif ($action =~ /^(history|(short)?log)$/) {
1777 $dest_action = $action;
1781 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1784 my $link = $cgi->a({
1786 action
=>$dest_action,
1790 $markers .= " <span class=\"$class\" title=\"$ref\">" .
1796 return ' <span class="refs">'. $markers . '</span>';
1802 # format, perhaps shortened and with markers, title line
1803 sub format_subject_html
{
1804 my ($long, $short, $href, $extra) = @_;
1805 $extra = '' unless defined($extra);
1807 if (length($short) < length($long)) {
1808 $long =~ s/[[:cntrl:]]/?/g;
1809 return $cgi->a({-href
=> $href, -class => "list subject",
1810 -title
=> to_utf8
($long)},
1811 esc_html
($short)) . $extra;
1813 return $cgi->a({-href
=> $href, -class => "list subject"},
1814 esc_html
($long)) . $extra;
1818 # Rather than recomputing the url for an email multiple times, we cache it
1819 # after the first hit. This gives a visible benefit in views where the avatar
1820 # for the same email is used repeatedly (e.g. shortlog).
1821 # The cache is shared by all avatar engines (currently gravatar only), which
1822 # are free to use it as preferred. Since only one avatar engine is used for any
1823 # given page, there's no risk for cache conflicts.
1824 our %avatar_cache = ();
1826 # Compute the picon url for a given email, by using the picon search service over at
1827 # http://www.cs.indiana.edu/picons/search.html
1829 my $email = lc shift;
1830 if (!$avatar_cache{$email}) {
1831 my ($user, $domain) = split('@', $email);
1832 $avatar_cache{$email} =
1833 "http://www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
1835 "users+domains+unknown/up/single";
1837 return $avatar_cache{$email};
1840 # Compute the gravatar url for a given email, if it's not in the cache already.
1841 # Gravatar stores only the part of the URL before the size, since that's the
1842 # one computationally more expensive. This also allows reuse of the cache for
1843 # different sizes (for this particular engine).
1845 my $email = lc shift;
1847 $avatar_cache{$email} ||=
1848 "http://www.gravatar.com/avatar/" .
1849 Digest
::MD5
::md5_hex
($email) . "?s=";
1850 return $avatar_cache{$email} . $size;
1853 # Insert an avatar for the given $email at the given $size if the feature
1855 sub git_get_avatar
{
1856 my ($email, %opts) = @_;
1857 my $pre_white = ($opts{-pad_before
} ?
" " : "");
1858 my $post_white = ($opts{-pad_after
} ?
" " : "");
1859 $opts{-size
} ||= 'default';
1860 my $size = $avatar_size{$opts{-size
}} || $avatar_size{'default'};
1862 if ($git_avatar eq 'gravatar') {
1863 $url = gravatar_url
($email, $size);
1864 } elsif ($git_avatar eq 'picon') {
1865 $url = picon_url
($email);
1867 # Other providers can be added by extending the if chain, defining $url
1868 # as needed. If no variant puts something in $url, we assume avatars
1869 # are completely disabled/unavailable.
1872 "<img width=\"$size\" " .
1873 "class=\"avatar\" " .
1882 sub format_search_author
{
1883 my ($author, $searchtype, $displaytext) = @_;
1884 my $have_search = gitweb_check_feature
('search');
1888 if ($searchtype eq 'author') {
1889 $performed = "authored";
1890 } elsif ($searchtype eq 'committer') {
1891 $performed = "committed";
1894 return $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
1895 searchtext
=>$author,
1896 searchtype
=>$searchtype), class=>"list",
1897 title
=>"Search for commits $performed by $author"},
1901 return $displaytext;
1905 # format the author name of the given commit with the given tag
1906 # the author name is chopped and escaped according to the other
1907 # optional parameters (see chop_str).
1908 sub format_author_html
{
1911 my $author = chop_and_escape_str
($co->{'author_name'}, @_);
1912 return "<$tag class=\"author\">" .
1913 format_search_author
($co->{'author_name'}, "author",
1914 git_get_avatar
($co->{'author_email'}, -pad_after
=> 1) .
1919 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1920 sub format_git_diff_header_line
{
1922 my $diffinfo = shift;
1923 my ($from, $to) = @_;
1925 if ($diffinfo->{'nparents'}) {
1927 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1928 if ($to->{'href'}) {
1929 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1930 esc_path
($to->{'file'}));
1931 } else { # file was deleted (no href)
1932 $line .= esc_path
($to->{'file'});
1936 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1937 if ($from->{'href'}) {
1938 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
1939 'a/' . esc_path
($from->{'file'}));
1940 } else { # file was added (no href)
1941 $line .= 'a/' . esc_path
($from->{'file'});
1944 if ($to->{'href'}) {
1945 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1946 'b/' . esc_path
($to->{'file'}));
1947 } else { # file was deleted
1948 $line .= 'b/' . esc_path
($to->{'file'});
1952 return "<div class=\"diff header\">$line</div>\n";
1955 # format extended diff header line, before patch itself
1956 sub format_extended_diff_header_line
{
1958 my $diffinfo = shift;
1959 my ($from, $to) = @_;
1962 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1963 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1964 esc_path
($from->{'file'}));
1966 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1967 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1968 esc_path
($to->{'file'}));
1970 # match single <mode>
1971 if ($line =~ m/\s(\d{6})$/) {
1972 $line .= '<span class="info"> (' .
1973 file_type_long
($1) .
1977 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1978 # can match only for combined diff
1980 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1981 if ($from->{'href'}[$i]) {
1982 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
1984 substr($diffinfo->{'from_id'}[$i],0,7));
1989 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1992 if ($to->{'href'}) {
1993 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1994 substr($diffinfo->{'to_id'},0,7));
1999 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
2000 # can match only for ordinary diff
2001 my ($from_link, $to_link);
2002 if ($from->{'href'}) {
2003 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
2004 substr($diffinfo->{'from_id'},0,7));
2006 $from_link = '0' x
7;
2008 if ($to->{'href'}) {
2009 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2010 substr($diffinfo->{'to_id'},0,7));
2014 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2015 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2018 return $line . "<br/>\n";
2021 # format from-file/to-file diff header
2022 sub format_diff_from_to_header
{
2023 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
2028 #assert($line =~ m/^---/) if DEBUG;
2029 # no extra formatting for "^--- /dev/null"
2030 if (! $diffinfo->{'nparents'}) {
2031 # ordinary (single parent) diff
2032 if ($line =~ m!^--- "?a/!) {
2033 if ($from->{'href'}) {
2035 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2036 esc_path
($from->{'file'}));
2039 esc_path
($from->{'file'});
2042 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2045 # combined diff (merge commit)
2046 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2047 if ($from->{'href'}[$i]) {
2049 $cgi->a({-href
=>href
(action
=>"blobdiff",
2050 hash_parent
=>$diffinfo->{'from_id'}[$i],
2051 hash_parent_base
=>$parents[$i],
2052 file_parent
=>$from->{'file'}[$i],
2053 hash
=>$diffinfo->{'to_id'},
2055 file_name
=>$to->{'file'}),
2057 -title
=>"diff" . ($i+1)},
2060 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
2061 esc_path
($from->{'file'}[$i]));
2063 $line = '--- /dev/null';
2065 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2070 #assert($line =~ m/^\+\+\+/) if DEBUG;
2071 # no extra formatting for "^+++ /dev/null"
2072 if ($line =~ m!^\+\+\+ "?b/!) {
2073 if ($to->{'href'}) {
2075 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2076 esc_path
($to->{'file'}));
2079 esc_path
($to->{'file'});
2082 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
2087 # create note for patch simplified by combined diff
2088 sub format_diff_cc_simplified
{
2089 my ($diffinfo, @parents) = @_;
2092 $result .= "<div class=\"diff header\">" .
2094 if (!is_deleted
($diffinfo)) {
2095 $result .= $cgi->a({-href
=> href
(action
=>"blob",
2097 hash
=>$diffinfo->{'to_id'},
2098 file_name
=>$diffinfo->{'to_file'}),
2100 esc_path
($diffinfo->{'to_file'}));
2102 $result .= esc_path
($diffinfo->{'to_file'});
2104 $result .= "</div>\n" . # class="diff header"
2105 "<div class=\"diff nodifferences\">" .
2107 "</div>\n"; # class="diff nodifferences"
2112 # format patch (diff) line (not to be used for diff headers)
2113 sub format_diff_line
{
2115 my ($from, $to) = @_;
2116 my $diff_class = "";
2120 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2122 my $prefix = substr($line, 0, scalar @
{$from->{'href'}});
2123 if ($line =~ m/^\@{3}/) {
2124 $diff_class = " chunk_header";
2125 } elsif ($line =~ m/^\\/) {
2126 $diff_class = " incomplete";
2127 } elsif ($prefix =~ tr/+/+/) {
2128 $diff_class = " add";
2129 } elsif ($prefix =~ tr/-/-/) {
2130 $diff_class = " rem";
2133 # assume ordinary diff
2134 my $char = substr($line, 0, 1);
2136 $diff_class = " add";
2137 } elsif ($char eq '-') {
2138 $diff_class = " rem";
2139 } elsif ($char eq '@') {
2140 $diff_class = " chunk_header";
2141 } elsif ($char eq "\\") {
2142 $diff_class = " incomplete";
2145 $line = untabify
($line);
2146 if ($from && $to && $line =~ m/^\@{2} /) {
2147 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2148 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2150 $from_lines = 0 unless defined $from_lines;
2151 $to_lines = 0 unless defined $to_lines;
2153 if ($from->{'href'}) {
2154 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
2155 -class=>"list"}, $from_text);
2157 if ($to->{'href'}) {
2158 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2159 -class=>"list"}, $to_text);
2161 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2162 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2163 return "<div class=\"diff$diff_class\">$line</div>\n";
2164 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2165 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2166 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2168 @from_text = split(' ', $ranges);
2169 for (my $i = 0; $i < @from_text; ++$i) {
2170 ($from_start[$i], $from_nlines[$i]) =
2171 (split(',', substr($from_text[$i], 1)), 0);
2174 $to_text = pop @from_text;
2175 $to_start = pop @from_start;
2176 $to_nlines = pop @from_nlines;
2178 $line = "<span class=\"chunk_info\">$prefix ";
2179 for (my $i = 0; $i < @from_text; ++$i) {
2180 if ($from->{'href'}[$i]) {
2181 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
2182 -class=>"list"}, $from_text[$i]);
2184 $line .= $from_text[$i];
2188 if ($to->{'href'}) {
2189 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2190 -class=>"list"}, $to_text);
2194 $line .= " $prefix</span>" .
2195 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2196 return "<div class=\"diff$diff_class\">$line</div>\n";
2198 return "<div class=\"diff$diff_class\">" . esc_html
($line, -nbsp
=>1) . "</div>\n";
2201 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2202 # linked. Pass the hash of the tree/commit to snapshot.
2203 sub format_snapshot_links
{
2205 my $num_fmts = @snapshot_fmts;
2206 if ($num_fmts > 1) {
2207 # A parenthesized list of links bearing format names.
2208 # e.g. "snapshot (_tar.gz_ _zip_)"
2209 return "snapshot (" . join(' ', map
2216 }, $known_snapshot_formats{$_}{'display'})
2217 , @snapshot_fmts) . ")";
2218 } elsif ($num_fmts == 1) {
2219 # A single "snapshot" link whose tooltip bears the format name.
2221 my ($fmt) = @snapshot_fmts;
2227 snapshot_format
=>$fmt
2229 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
2231 } else { # $num_fmts == 0
2236 ## ......................................................................
2237 ## functions returning values to be passed, perhaps after some
2238 ## transformation, to other functions; e.g. returning arguments to href()
2240 # returns hash to be passed to href to generate gitweb URL
2241 # in -title key it returns description of link
2243 my $format = shift || 'Atom';
2244 my %res = (action
=> lc($format));
2246 # feed links are possible only for project views
2247 return unless (defined $project);
2248 # some views should link to OPML, or to generic project feed,
2249 # or don't have specific feed yet (so they should use generic)
2250 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
2253 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
2254 # from tag links; this also makes possible to detect branch links
2255 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
2256 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
2259 # find log type for feed description (title)
2261 if (defined $file_name) {
2262 $type = "history of $file_name";
2263 $type .= "/" if ($action eq 'tree');
2264 $type .= " on '$branch'" if (defined $branch);
2266 $type = "log of $branch" if (defined $branch);
2269 $res{-title
} = $type;
2270 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
2271 $res{'file_name'} = $file_name;
2276 ## ----------------------------------------------------------------------
2277 ## git utility subroutines, invoking git commands
2279 # returns path to the core git executable and the --git-dir parameter as list
2281 $number_of_git_cmds++;
2282 return $GIT, '--git-dir='.$git_dir;
2285 # quote the given arguments for passing them to the shell
2286 # quote_command("command", "arg 1", "arg with ' and ! characters")
2287 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2288 # Try to avoid using this function wherever possible.
2291 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
2294 # get HEAD ref of given project as hash
2295 sub git_get_head_hash
{
2296 return git_get_full_hash
(shift, 'HEAD');
2299 sub git_get_full_hash
{
2300 return git_get_hash
(@_);
2303 sub git_get_short_hash
{
2304 return git_get_hash
(@_, '--short=7');
2308 my ($project, $hash, @options) = @_;
2309 my $o_git_dir = $git_dir;
2311 $git_dir = "$projectroot/$project";
2312 if (open my $fd, '-|', git_cmd
(), 'rev-parse',
2313 '--verify', '-q', @options, $hash) {
2315 chomp $retval if defined $retval;
2318 if (defined $o_git_dir) {
2319 $git_dir = $o_git_dir;
2324 # get type of given object
2328 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
2330 close $fd or return;
2335 # repository configuration
2336 our $config_file = '';
2339 # store multiple values for single key as anonymous array reference
2340 # single values stored directly in the hash, not as [ <value> ]
2341 sub hash_set_multi
{
2342 my ($hash, $key, $value) = @_;
2344 if (!exists $hash->{$key}) {
2345 $hash->{$key} = $value;
2346 } elsif (!ref $hash->{$key}) {
2347 $hash->{$key} = [ $hash->{$key}, $value ];
2349 push @
{$hash->{$key}}, $value;
2353 # return hash of git project configuration
2354 # optionally limited to some section, e.g. 'gitweb'
2355 sub git_parse_project_config
{
2356 my $section_regexp = shift;
2361 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
2364 while (my $keyval = <$fh>) {
2366 my ($key, $value) = split(/\n/, $keyval, 2);
2368 hash_set_multi
(\
%config, $key, $value)
2369 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2376 # convert config value to boolean: 'true' or 'false'
2377 # no value, number > 0, 'true' and 'yes' values are true
2378 # rest of values are treated as false (never as error)
2379 sub config_to_bool
{
2382 return 1 if !defined $val; # section.key
2384 # strip leading and trailing whitespace
2388 return (($val =~ /^\d+$/ && $val) || # section.key = 1
2389 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2392 # convert config value to simple decimal number
2393 # an optional value suffix of 'k', 'm', or 'g' will cause the value
2394 # to be multiplied by 1024, 1048576, or 1073741824
2398 # strip leading and trailing whitespace
2402 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2404 # unknown unit is treated as 1
2405 return $num * ($unit eq 'g' ?
1073741824 :
2406 $unit eq 'm' ?
1048576 :
2407 $unit eq 'k' ?
1024 : 1);
2412 # convert config value to array reference, if needed
2413 sub config_to_multi
{
2416 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
2419 sub git_get_project_config
{
2420 my ($key, $type) = @_;
2422 return unless defined $git_dir;
2425 return unless ($key);
2426 $key =~ s/^gitweb\.//;
2427 return if ($key =~ m/\W/);
2430 if (defined $type) {
2433 unless ($type eq 'bool' || $type eq 'int');
2437 if (!defined $config_file ||
2438 $config_file ne "$git_dir/config") {
2439 %config = git_parse_project_config
('gitweb');
2440 $config_file = "$git_dir/config";
2443 # check if config variable (key) exists
2444 return unless exists $config{"gitweb.$key"};
2447 if (!defined $type) {
2448 return $config{"gitweb.$key"};
2449 } elsif ($type eq 'bool') {
2450 # backward compatibility: 'git config --bool' returns true/false
2451 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
2452 } elsif ($type eq 'int') {
2453 return config_to_int
($config{"gitweb.$key"});
2455 return $config{"gitweb.$key"};
2458 # get hash of given path at given ref
2459 sub git_get_hash_by_path
{
2461 my $path = shift || return undef;
2466 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
2467 or die_error
(500, "Open git-ls-tree failed");
2469 close $fd or return undef;
2471 if (!defined $line) {
2472 # there is no tree or hash given by $path at $base
2476 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2477 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2478 if (defined $type && $type ne $2) {
2479 # type doesn't match
2485 # get path of entry with given hash at given tree-ish (ref)
2486 # used to get 'from' filename for combined diff (merge commit) for renames
2487 sub git_get_path_by_hash
{
2488 my $base = shift || return;
2489 my $hash = shift || return;
2493 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
2495 while (my $line = <$fd>) {
2498 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2499 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2500 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2509 ## ......................................................................
2510 ## git utility functions, directly accessing git repository
2512 sub git_get_project_description
{
2515 $git_dir = "$projectroot/$path";
2516 open my $fd, '<', "$git_dir/description"
2517 or return git_get_project_config
('description');
2520 if (defined $descr) {
2526 sub git_get_project_ctags
{
2530 $git_dir = "$projectroot/$path";
2531 opendir my $dh, "$git_dir/ctags"
2533 foreach (grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir($dh)) {
2534 open my $ct, '<', $_ or next;
2538 my $ctag = $_; $ctag =~ s
#.*/##;
2539 $ctags->{$ctag} = $val;
2545 sub git_populate_project_tagcloud
{
2548 # First, merge different-cased tags; tags vote on casing
2550 foreach (keys %$ctags) {
2551 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2552 if (not $ctags_lc{lc $_}->{topcount
}
2553 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2554 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2555 $ctags_lc{lc $_}->{topname
} = $_;
2560 if (eval { require HTML
::TagCloud
; 1; }) {
2561 $cloud = HTML
::TagCloud
->new;
2562 foreach (sort keys %ctags_lc) {
2563 # Pad the title with spaces so that the cloud looks
2565 my $title = $ctags_lc{$_}->{topname
};
2566 $title =~ s/ / /g;
2567 $title =~ s/^/ /g;
2568 $title =~ s/$/ /g;
2569 $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count
});
2572 $cloud = \
%ctags_lc;
2577 sub git_show_project_tagcloud
{
2578 my ($cloud, $count) = @_;
2579 print STDERR
ref($cloud)."..\n";
2580 if (ref $cloud eq 'HTML::TagCloud') {
2581 return $cloud->html_and_css($count);
2583 my @tags = sort { $cloud->{$a}->{count
} <=> $cloud->{$b}->{count
} } keys %$cloud;
2584 return '<p align="center">' . join (', ', map {
2585 "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
2586 } splice(@tags, 0, $count)) . '</p>';
2590 sub git_get_project_url_list
{
2593 $git_dir = "$projectroot/$path";
2594 open my $fd, '<', "$git_dir/cloneurl"
2595 or return wantarray ?
2596 @
{ config_to_multi
(git_get_project_config
('url')) } :
2597 config_to_multi
(git_get_project_config
('url'));
2598 my @git_project_url_list = map { chomp; $_ } <$fd>;
2601 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2604 sub git_get_projects_list
{
2609 $filter =~ s/\.git$//;
2611 my $check_forks = gitweb_check_feature
('forks');
2613 if (-d
$projects_list) {
2614 # search in directory
2615 my $dir = $projects_list . ($filter ?
"/$filter" : '');
2616 # remove the trailing "/"
2618 my $pfxlen = length("$dir");
2619 my $pfxdepth = ($dir =~ tr!/!!);
2622 follow_fast
=> 1, # follow symbolic links
2623 follow_skip
=> 2, # ignore duplicates
2624 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2627 our $project_maxdepth;
2629 # skip project-list toplevel, if we get it.
2630 return if (m!^[/.]$!);
2631 # only directories can be git repositories
2632 return unless (-d
$_);
2633 # don't traverse too deep (Find is super slow on os x)
2634 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2635 $File::Find
::prune
= 1;
2639 my $subdir = substr($File::Find
::name
, $pfxlen + 1);
2640 # we check related file in $projectroot
2641 my $path = ($filter ?
"$filter/" : '') . $subdir;
2642 if (check_export_ok
("$projectroot/$path")) {
2643 push @list, { path
=> $path };
2644 $File::Find
::prune
= 1;
2649 } elsif (-f
$projects_list) {
2650 # read from file(url-encoded):
2651 # 'git%2Fgit.git Linus+Torvalds'
2652 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2653 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2655 open my $fd, '<', $projects_list or return;
2657 while (my $line = <$fd>) {
2659 my ($path, $owner) = split ' ', $line;
2660 $path = unescape
($path);
2661 $owner = unescape
($owner);
2662 if (!defined $path) {
2665 if ($filter ne '') {
2666 # looking for forks;
2667 my $pfx = substr($path, 0, length($filter));
2668 if ($pfx ne $filter) {
2671 my $sfx = substr($path, length($filter));
2672 if ($sfx !~ /^\/.*\
.git
$/) {
2675 } elsif ($check_forks) {
2677 foreach my $filter (keys %paths) {
2678 # looking for forks;
2679 my $pfx = substr($path, 0, length($filter));
2680 if ($pfx ne $filter) {
2683 my $sfx = substr($path, length($filter));
2684 if ($sfx !~ /^\/.*\
.git
$/) {
2687 # is a fork, don't include it in
2692 if (check_export_ok
("$projectroot/$path")) {
2695 owner
=> to_utf8
($owner),
2698 (my $forks_path = $path) =~ s/\.git$//;
2699 $paths{$forks_path}++;
2707 our $gitweb_project_owner = undef;
2708 sub git_get_project_list_from_file
{
2710 return if (defined $gitweb_project_owner);
2712 $gitweb_project_owner = {};
2713 # read from file (url-encoded):
2714 # 'git%2Fgit.git Linus+Torvalds'
2715 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2716 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2717 if (-f
$projects_list) {
2718 open(my $fd, '<', $projects_list);
2719 while (my $line = <$fd>) {
2721 my ($pr, $ow) = split ' ', $line;
2722 $pr = unescape
($pr);
2723 $ow = unescape
($ow);
2724 $gitweb_project_owner->{$pr} = to_utf8
($ow);
2730 sub git_get_project_owner
{
2731 my $project = shift;
2734 return undef unless $project;
2735 $git_dir = "$projectroot/$project";
2737 if (!defined $gitweb_project_owner) {
2738 git_get_project_list_from_file
();
2741 if (exists $gitweb_project_owner->{$project}) {
2742 $owner = $gitweb_project_owner->{$project};
2744 if (!defined $owner){
2745 $owner = git_get_project_config
('owner');
2747 if (!defined $owner) {
2748 $owner = get_file_owner
("$git_dir");
2754 sub git_get_last_activity
{
2758 $git_dir = "$projectroot/$path";
2759 open($fd, "-|", git_cmd
(), 'for-each-ref',
2760 '--format=%(committer)',
2761 '--sort=-committerdate',
2763 'refs/heads') or return;
2764 my $most_recent = <$fd>;
2765 close $fd or return;
2766 if (defined $most_recent &&
2767 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2769 my $age = time - $timestamp;
2770 return ($age, age_string
($age));
2772 return (undef, undef);
2775 sub git_get_references
{
2776 my $type = shift || "";
2778 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2779 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2780 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
2781 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
2784 while (my $line = <$fd>) {
2786 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2787 if (defined $refs{$1}) {
2788 push @
{$refs{$1}}, $2;
2794 close $fd or return;
2798 sub git_get_rev_name_tags
{
2799 my $hash = shift || return undef;
2801 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
2803 my $name_rev = <$fd>;
2806 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
2809 # catches also '$hash undefined' output
2814 ## ----------------------------------------------------------------------
2815 ## parse to hash functions
2819 my $tz = shift || "-0000";
2822 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2823 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2824 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2825 $date{'hour'} = $hour;
2826 $date{'minute'} = $min;
2827 $date{'mday'} = $mday;
2828 $date{'day'} = $days[$wday];
2829 $date{'month'} = $months[$mon];
2830 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2831 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2832 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2833 $mday, $months[$mon], $hour ,$min;
2834 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2835 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2837 $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2838 my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2839 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2840 $date{'hour_local'} = $hour;
2841 $date{'minute_local'} = $min;
2842 $date{'tz_local'} = $tz;
2843 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2844 1900+$year, $mon+1, $mday,
2845 $hour, $min, $sec, $tz);
2854 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
2855 $tag{'id'} = $tag_id;
2856 while (my $line = <$fd>) {
2858 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2859 $tag{'object'} = $1;
2860 } elsif ($line =~ m/^type (.+)$/) {
2862 } elsif ($line =~ m/^tag (.+)$/) {
2864 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2865 $tag{'author'} = $1;
2866 $tag{'author_epoch'} = $2;
2867 $tag{'author_tz'} = $3;
2868 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2869 $tag{'author_name'} = $1;
2870 $tag{'author_email'} = $2;
2872 $tag{'author_name'} = $tag{'author'};
2874 } elsif ($line =~ m/--BEGIN/) {
2875 push @comment, $line;
2877 } elsif ($line eq "") {
2881 push @comment, <$fd>;
2882 $tag{'comment'} = \
@comment;
2883 close $fd or return;
2884 if (!defined $tag{'name'}) {
2890 sub parse_commit_text
{
2891 my ($commit_text, $withparents) = @_;
2892 my @commit_lines = split '\n', $commit_text;
2895 pop @commit_lines; # Remove '\0'
2897 if (! @commit_lines) {
2901 my $header = shift @commit_lines;
2902 if ($header !~ m/^[0-9a-fA-F]{40}/) {
2905 ($co{'id'}, my @parents) = split ' ', $header;
2906 while (my $line = shift @commit_lines) {
2907 last if $line eq "\n";
2908 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2910 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2912 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2913 $co{'author'} = to_utf8
($1);
2914 $co{'author_epoch'} = $2;
2915 $co{'author_tz'} = $3;
2916 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2917 $co{'author_name'} = $1;
2918 $co{'author_email'} = $2;
2920 $co{'author_name'} = $co{'author'};
2922 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2923 $co{'committer'} = to_utf8
($1);
2924 $co{'committer_epoch'} = $2;
2925 $co{'committer_tz'} = $3;
2926 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2927 $co{'committer_name'} = $1;
2928 $co{'committer_email'} = $2;
2930 $co{'committer_name'} = $co{'committer'};
2934 if (!defined $co{'tree'}) {
2937 $co{'parents'} = \
@parents;
2938 $co{'parent'} = $parents[0];
2940 foreach my $title (@commit_lines) {
2943 $co{'title'} = chop_str
($title, 80, 5);
2944 # remove leading stuff of merges to make the interesting part visible
2945 if (length($title) > 50) {
2946 $title =~ s/^Automatic //;
2947 $title =~ s/^merge (of|with) /Merge ... /i;
2948 if (length($title) > 50) {
2949 $title =~ s/(http|rsync):\/\///;
2951 if (length($title) > 50) {
2952 $title =~ s/(master|www|rsync)\.//;
2954 if (length($title) > 50) {
2955 $title =~ s/kernel.org:?//;
2957 if (length($title) > 50) {
2958 $title =~ s/\/pub\/scm//;
2961 $co{'title_short'} = chop_str
($title, 50, 5);
2965 if (! defined $co{'title'} || $co{'title'} eq "") {
2966 $co{'title'} = $co{'title_short'} = '(no commit message)';
2968 # remove added spaces
2969 foreach my $line (@commit_lines) {
2972 $co{'comment'} = \
@commit_lines;
2974 my $age = time - $co{'committer_epoch'};
2976 $co{'age_string'} = age_string
($age);
2977 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2978 if ($age > 60*60*24*7*2) {
2979 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2980 $co{'age_string_age'} = $co{'age_string'};
2982 $co{'age_string_date'} = $co{'age_string'};
2983 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2989 my ($commit_id) = @_;
2994 open my $fd, "-|", git_cmd
(), "rev-list",
3000 or die_error
(500, "Open git-rev-list failed");
3001 %co = parse_commit_text
(<$fd>, 1);
3008 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
3016 open my $fd, "-|", git_cmd
(), "rev-list",
3019 ("--max-count=" . $maxcount),
3020 ("--skip=" . $skip),
3024 ($filename ?
($filename) : ())
3025 or die_error
(500, "Open git-rev-list failed");
3026 while (my $line = <$fd>) {
3027 my %co = parse_commit_text
($line);
3032 return wantarray ?
@cos : \
@cos;
3035 # parse line of git-diff-tree "raw" output
3036 sub parse_difftree_raw_line
{
3040 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3041 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
3042 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
3043 $res{'from_mode'} = $1;
3044 $res{'to_mode'} = $2;
3045 $res{'from_id'} = $3;
3047 $res{'status'} = $5;
3048 $res{'similarity'} = $6;
3049 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
3050 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
3052 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
3055 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3056 # combined diff (for merge commit)
3057 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
3058 $res{'nparents'} = length($1);
3059 $res{'from_mode'} = [ split(' ', $2) ];
3060 $res{'to_mode'} = pop @
{$res{'from_mode'}};
3061 $res{'from_id'} = [ split(' ', $3) ];
3062 $res{'to_id'} = pop @
{$res{'from_id'}};
3063 $res{'status'} = [ split('', $4) ];
3064 $res{'to_file'} = unquote
($5);
3066 # 'c512b523472485aef4fff9e57b229d9d243c967f'
3067 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
3068 $res{'commit'} = $1;
3071 return wantarray ?
%res : \
%res;
3074 # wrapper: return parsed line of git-diff-tree "raw" output
3075 # (the argument might be raw line, or parsed info)
3076 sub parsed_difftree_line
{
3077 my $line_or_ref = shift;
3079 if (ref($line_or_ref) eq "HASH") {
3080 # pre-parsed (or generated by hand)
3081 return $line_or_ref;
3083 return parse_difftree_raw_line
($line_or_ref);
3087 # parse line of git-ls-tree output
3088 sub parse_ls_tree_line
{
3094 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
3095 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40}) +(-|[0-9]+)\t(.+)$/s;
3104 $res{'name'} = unquote
($5);
3107 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
3108 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
3116 $res{'name'} = unquote
($4);
3120 return wantarray ?
%res : \
%res;
3123 # generates _two_ hashes, references to which are passed as 2 and 3 argument
3124 sub parse_from_to_diffinfo
{
3125 my ($diffinfo, $from, $to, @parents) = @_;
3127 if ($diffinfo->{'nparents'}) {
3129 $from->{'file'} = [];
3130 $from->{'href'} = [];
3131 fill_from_file_info
($diffinfo, @parents)
3132 unless exists $diffinfo->{'from_file'};
3133 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
3134 $from->{'file'}[$i] =
3135 defined $diffinfo->{'from_file'}[$i] ?
3136 $diffinfo->{'from_file'}[$i] :
3137 $diffinfo->{'to_file'};
3138 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3139 $from->{'href'}[$i] = href
(action
=>"blob",
3140 hash_base
=>$parents[$i],
3141 hash
=>$diffinfo->{'from_id'}[$i],
3142 file_name
=>$from->{'file'}[$i]);
3144 $from->{'href'}[$i] = undef;
3148 # ordinary (not combined) diff
3149 $from->{'file'} = $diffinfo->{'from_file'};
3150 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3151 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
3152 hash
=>$diffinfo->{'from_id'},
3153 file_name
=>$from->{'file'});
3155 delete $from->{'href'};
3159 $to->{'file'} = $diffinfo->{'to_file'};
3160 if (!is_deleted
($diffinfo)) { # file exists in result
3161 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
3162 hash
=>$diffinfo->{'to_id'},
3163 file_name
=>$to->{'file'});
3165 delete $to->{'href'};
3169 ## ......................................................................
3170 ## parse to array of hashes functions
3172 sub git_get_heads_list
{
3173 my ($limit, @classes) = @_;
3174 @classes = ('heads') unless @classes;
3175 my @patterns = map { "refs/$_" } @classes;
3178 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3179 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
3180 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
3183 while (my $line = <$fd>) {
3187 my ($refinfo, $committerinfo) = split(/\0/, $line);
3188 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3189 my ($committer, $epoch, $tz) =
3190 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
3191 $ref_item{'fullname'} = $name;
3192 $name =~ s!^refs/(?:head|remote)s/!!;
3194 $ref_item{'name'} = $name;
3195 $ref_item{'id'} = $hash;
3196 $ref_item{'title'} = $title || '(no commit message)';
3197 $ref_item{'epoch'} = $epoch;
3199 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3201 $ref_item{'age'} = "unknown";
3204 push @headslist, \
%ref_item;
3208 return wantarray ?
@headslist : \
@headslist;
3211 sub git_get_tags_list
{
3215 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3216 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
3217 '--format=%(objectname) %(objecttype) %(refname) '.
3218 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3221 while (my $line = <$fd>) {
3225 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3226 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3227 my ($creator, $epoch, $tz) =
3228 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
3229 $ref_item{'fullname'} = $name;
3230 $name =~ s!^refs/tags/!!;
3232 $ref_item{'type'} = $type;
3233 $ref_item{'id'} = $id;
3234 $ref_item{'name'} = $name;
3235 if ($type eq "tag") {
3236 $ref_item{'subject'} = $title;
3237 $ref_item{'reftype'} = $reftype;
3238 $ref_item{'refid'} = $refid;
3240 $ref_item{'reftype'} = $type;
3241 $ref_item{'refid'} = $id;
3244 if ($type eq "tag" || $type eq "commit") {
3245 $ref_item{'epoch'} = $epoch;
3247 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3249 $ref_item{'age'} = "unknown";
3253 push @tagslist, \
%ref_item;
3257 return wantarray ?
@tagslist : \
@tagslist;
3260 ## ----------------------------------------------------------------------
3261 ## filesystem-related functions
3263 sub get_file_owner
{
3266 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3267 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3268 if (!defined $gcos) {
3272 $owner =~ s/[,;].*$//;
3273 return to_utf8
($owner);
3276 # assume that file exists
3278 my $filename = shift;
3280 open my $fd, '<', $filename;
3281 print map { to_utf8
($_) } <$fd>;
3285 ## ......................................................................
3286 ## mimetype related functions
3288 sub mimetype_guess_file
{
3289 my $filename = shift;
3290 my $mimemap = shift;
3291 -r
$mimemap or return undef;
3294 open(my $mh, '<', $mimemap) or return undef;
3296 next if m/^#/; # skip comments
3297 my ($mimetype, $exts) = split(/\t+/);
3298 if (defined $exts) {
3299 my @exts = split(/\s+/, $exts);
3300 foreach my $ext (@exts) {
3301 $mimemap{$ext} = $mimetype;
3307 $filename =~ /\.([^.]*)$/;
3308 return $mimemap{$1};
3311 sub mimetype_guess
{
3312 my $filename = shift;
3314 $filename =~ /\./ or return undef;
3316 if ($mimetypes_file) {
3317 my $file = $mimetypes_file;
3318 if ($file !~ m!^/!) { # if it is relative path
3319 # it is relative to project
3320 $file = "$projectroot/$project/$file";
3322 $mime = mimetype_guess_file
($filename, $file);
3324 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
3330 my $filename = shift;
3333 my $mime = mimetype_guess
($filename);
3334 $mime and return $mime;
3338 return $default_blob_plain_mimetype unless $fd;
3341 return 'text/plain';
3342 } elsif (! $filename) {
3343 return 'application/octet-stream';
3344 } elsif ($filename =~ m/\.png$/i) {
3346 } elsif ($filename =~ m/\.gif$/i) {
3348 } elsif ($filename =~ m/\.jpe?g$/i) {
3349 return 'image/jpeg';
3351 return 'application/octet-stream';
3355 sub blob_contenttype
{
3356 my ($fd, $file_name, $type) = @_;
3358 $type ||= blob_mimetype
($fd, $file_name);
3359 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3360 $type .= "; charset=$default_text_plain_charset";
3366 # guess file syntax for syntax highlighting; return undef if no highlighting
3367 # the name of syntax can (in the future) depend on syntax highlighter used
3368 sub guess_file_syntax
{
3369 my ($highlight, $mimetype, $file_name) = @_;
3370 return undef unless ($highlight && defined $file_name);
3371 my $basename = basename
($file_name, '.in');
3372 return $highlight_basename{$basename}
3373 if exists $highlight_basename{$basename};
3375 $basename =~ /\.([^.]*)$/;
3376 my $ext = $1 or return undef;
3377 return $highlight_ext{$ext}
3378 if exists $highlight_ext{$ext};
3383 # run highlighter and return FD of its output,
3384 # or return original FD if no highlighting
3385 sub run_highlighter
{
3386 my ($fd, $highlight, $syntax) = @_;
3387 return $fd unless ($highlight && defined $syntax);
3390 or die_error
(404, "Reading blob failed");
3391 open $fd, quote_command
(git_cmd
(), "cat-file", "blob", $hash)." | ".
3392 quote_command
($highlight_bin).
3393 " --xhtml --fragment --syntax $syntax |"
3394 or die_error
(500, "Couldn't open file or run syntax highlighter");
3398 ## ======================================================================
3399 ## functions printing HTML: header, footer, error page
3401 sub get_page_title
{
3402 my $title = to_utf8
($site_name);
3404 return $title unless (defined $project);
3405 $title .= " - " . to_utf8
($project);
3407 return $title unless (defined $action);
3408 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
3410 return $title unless (defined $file_name);
3411 $title .= " - " . esc_path
($file_name);
3412 if ($action eq "tree" && $file_name !~ m
|/$|) {
3419 sub git_header_html
{
3420 my $status = shift || "200 OK";
3421 my $expires = shift;
3424 my $title = get_page_title
();
3426 # require explicit support from the UA if we are to send the page as
3427 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
3428 # we have to do this because MSIE sometimes globs '*/*', pretending to
3429 # support xhtml+xml but choking when it gets what it asked for.
3430 if (defined $cgi->http('HTTP_ACCEPT') &&
3431 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
3432 $cgi->Accept('application/xhtml+xml') != 0) {
3433 $content_type = 'application/xhtml+xml';
3435 $content_type = 'text/html';
3437 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
3438 -status
=> $status, -expires
=> $expires)
3439 unless ($opts{'-no_http_header'});
3440 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
3442 <?xml version="1.0" encoding="utf-8"?>
3443 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3444 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
3445 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
3446 <!-- git core binaries version $git_version -->
3448 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
3449 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
3450 <meta name="robots" content="index, nofollow"/>
3451 <title>$title</title>
3453 # the stylesheet, favicon etc urls won't work correctly with path_info
3454 # unless we set the appropriate base URL
3455 if ($ENV{'PATH_INFO'}) {
3456 print "<base href=\"".esc_url
($base_url)."\" />\n";
3458 # print out each stylesheet that exist, providing backwards capability
3459 # for those people who defined $stylesheet in a config file
3460 if (defined $stylesheet) {
3461 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
3463 foreach my $stylesheet (@stylesheets) {
3464 next unless $stylesheet;
3465 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
3468 if (defined $project) {
3469 my %href_params = get_feed_info
();
3470 if (!exists $href_params{'-title'}) {
3471 $href_params{'-title'} = 'log';
3474 foreach my $format qw(RSS Atom) {
3475 my $type = lc($format);
3477 '-rel' => 'alternate',
3478 '-title' => "$project - $href_params{'-title'} - $format feed",
3479 '-type' => "application/$type+xml"
3482 $href_params{'action'} = $type;
3483 $link_attr{'-href'} = href
(%href_params);
3485 "rel=\"$link_attr{'-rel'}\" ".
3486 "title=\"$link_attr{'-title'}\" ".
3487 "href=\"$link_attr{'-href'}\" ".
3488 "type=\"$link_attr{'-type'}\" ".
3491 $href_params{'extra_options'} = '--no-merges';
3492 $link_attr{'-href'} = href
(%href_params);
3493 $link_attr{'-title'} .= ' (no merges)';
3495 "rel=\"$link_attr{'-rel'}\" ".
3496 "title=\"$link_attr{'-title'}\" ".
3497 "href=\"$link_attr{'-href'}\" ".
3498 "type=\"$link_attr{'-type'}\" ".
3503 printf('<link rel="alternate" title="%s projects list" '.
3504 'href="%s" type="text/plain; charset=utf-8" />'."\n",
3505 $site_name, href
(project
=>undef, action
=>"project_index"));
3506 printf('<link rel="alternate" title="%s projects feeds" '.
3507 'href="%s" type="text/x-opml" />'."\n",
3508 $site_name, href
(project
=>undef, action
=>"opml"));
3510 if (defined $favicon) {
3511 print qq(<link rel
="shortcut icon" href
="$favicon" type
="image/png" />\n);
3517 if (defined $site_header && -f
$site_header) {
3518 insert_file
($site_header);
3521 print "<div class=\"page_header\">\n" .
3522 $cgi->a({-href
=> esc_url
($logo_url),
3523 -title
=> $logo_label},
3524 qq(<img src
="$logo" width
="72" height
="27" alt
="git" class="logo"/>));
3525 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
3526 if (defined $project) {
3527 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
3528 if (defined $action) {
3529 my $action_print = $action ;
3530 if (defined $opts{-action_extra
}) {
3531 $action_print = $cgi->a({-href
=> href
(action
=>$action)},
3534 print " / $action_print";
3536 if (defined $opts{-action_extra
}) {
3537 print " / $opts{-action_extra}";
3543 my $have_search = gitweb_check_feature
('search');
3544 if (defined $project && $have_search) {
3545 if (!defined $searchtext) {
3549 if (defined $hash_base) {
3550 $search_hash = $hash_base;
3551 } elsif (defined $hash) {
3552 $search_hash = $hash;
3554 $search_hash = "HEAD";
3556 my $action = $my_uri;
3557 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3558 if ($use_pathinfo) {
3559 $action .= "/".esc_url
($project);
3561 print $cgi->startform(-method
=> "get", -action
=> $action) .
3562 "<div class=\"search\">\n" .
3564 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3565 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3566 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3567 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3568 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3569 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3571 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
3572 "<span title=\"Extended regular expression\">" .
3573 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3574 -checked
=> $search_use_regexp) .
3577 $cgi->end_form() . "\n";
3581 sub git_footer_html
{
3582 my $feed_class = 'rss_logo';
3584 print "<div class=\"page_footer\">\n";
3585 if (defined $project) {
3586 my $descr = git_get_project_description
($project);
3587 if (defined $descr) {
3588 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3591 my %href_params = get_feed_info
();
3592 if (!%href_params) {
3593 $feed_class .= ' generic';
3595 $href_params{'-title'} ||= 'log';
3597 foreach my $format qw(RSS Atom) {
3598 $href_params{'action'} = lc($format);
3599 print $cgi->a({-href
=> href
(%href_params),
3600 -title
=> "$href_params{'-title'} $format feed",
3601 -class => $feed_class}, $format)."\n";
3605 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3606 -class => $feed_class}, "OPML") . " ";
3607 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3608 -class => $feed_class}, "TXT") . "\n";
3610 print "</div>\n"; # class="page_footer"
3612 if (defined $t0 && gitweb_check_feature
('timed')) {
3613 print "<div id=\"generating_info\">\n";
3614 print 'This page took '.
3615 '<span id="generating_time" class="time_span">'.
3616 Time
::HiRes
::tv_interval
($t0, [Time
::HiRes
::gettimeofday
()]).
3619 '<span id="generating_cmd">'.
3620 $number_of_git_cmds.
3621 '</span> git commands '.
3623 print "</div>\n"; # class="page_footer"
3626 if (defined $site_footer && -f
$site_footer) {
3627 insert_file
($site_footer);
3630 print qq!<script type
="text/javascript" src
="$javascript"></script
>\n!;
3631 if (defined $action &&
3632 $action eq 'blame_incremental') {
3633 print qq!<script type
="text/javascript">\n!.
3634 qq!startBlame
("!. href(action=>"blame_data
", -replay=>1) .qq!",\n!.
3635 qq! "!. href() .qq!");\n!.
3637 } elsif (gitweb_check_feature
('javascript-actions')) {
3638 print qq!<script type
="text/javascript">\n!.
3639 qq!window
.onload
= fixLinks
;\n!.
3647 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
3648 # Example: die_error(404, 'Hash not found')
3649 # By convention, use the following status codes (as defined in RFC 2616):
3650 # 400: Invalid or missing CGI parameters, or
3651 # requested object exists but has wrong type.
3652 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
3653 # this server or project.
3654 # 404: Requested object/revision/project doesn't exist.
3655 # 500: The server isn't configured properly, or
3656 # an internal error occurred (e.g. failed assertions caused by bugs), or
3657 # an unknown error occurred (e.g. the git binary died unexpectedly).
3658 # 503: The server is currently unavailable (because it is overloaded,
3659 # or down for maintenance). Generally, this is a temporary state.
3661 my $status = shift || 500;
3662 my $error = esc_html
(shift) || "Internal Server Error";
3666 my %http_responses = (
3667 400 => '400 Bad Request',
3668 403 => '403 Forbidden',
3669 404 => '404 Not Found',
3670 500 => '500 Internal Server Error',
3671 503 => '503 Service Unavailable',
3673 git_header_html
($http_responses{$status}, undef, %opts);
3675 <div class="page_body">
3680 if (defined $extra) {
3688 unless ($opts{'-error_handler'});
3691 ## ----------------------------------------------------------------------
3692 ## functions printing or outputting HTML: navigation
3694 sub git_print_page_nav
{
3695 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3696 $extra = '' if !defined $extra; # pager or formats
3698 my @navs = qw(summary shortlog log commit commitdiff tree);
3700 @navs = grep { $_ ne $suppress } @navs;
3703 my %arg = map { $_ => {action
=>$_} } @navs;
3704 if (defined $head) {
3705 for (qw(commit commitdiff)) {
3706 $arg{$_}{'hash'} = $head;
3708 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3709 for (qw(shortlog log)) {
3710 $arg{$_}{'hash'} = $head;
3715 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3716 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3718 my @actions = gitweb_get_feature
('actions');
3721 'n' => $project, # project name
3722 'f' => $git_dir, # project path within filesystem
3723 'h' => $treehead || '', # current hash ('h' parameter)
3724 'b' => $treebase || '', # hash base ('hb' parameter)
3727 my ($label, $link, $pos) = splice(@actions,0,3);
3729 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
3731 $link =~ s/%([%nfhb])/$repl{$1}/g;
3732 $arg{$label}{'_href'} = $link;
3735 print "<div class=\"page_nav\">\n" .
3737 map { $_ eq $current ?
3738 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
3740 print "<br/>\n$extra<br/>\n" .
3744 # returns a submenu for the nagivation of the refs views (tags, heads,
3745 # remotes) with the current view disabled and the remotes view only
3746 # available if the feature is enabled
3747 sub format_ref_views
{
3749 my @ref_views = qw{tags heads
};
3750 push @ref_views, 'remotes' if gitweb_check_feature
('remote_heads');
3751 return join " | ", map {
3752 $_ eq $current ?
$_ :
3753 $cgi->a({-href
=> href
(action
=>$_)}, $_)
3757 sub format_paging_nav
{
3758 my ($action, $page, $has_next_link) = @_;
3764 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)}, "first") .
3766 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
3767 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
3769 $paging_nav .= "first ⋅ prev";
3772 if ($has_next_link) {
3773 $paging_nav .= " ⋅ " .
3774 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
3775 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
3777 $paging_nav .= " ⋅ next";
3783 ## ......................................................................
3784 ## functions printing or outputting HTML: div
3786 sub git_print_header_div
{
3787 my ($action, $title, $hash, $hash_base) = @_;
3790 $args{'action'} = $action;
3791 $args{'hash'} = $hash if $hash;
3792 $args{'hash_base'} = $hash_base if $hash_base;
3794 print "<div class=\"header\">\n" .
3795 $cgi->a({-href
=> href
(%args), -class => "title"},
3796 $title ?
$title : $action) .
3800 sub print_local_time
{
3801 print format_local_time
(@_);
3804 sub format_local_time
{
3807 if ($date{'hour_local'} < 6) {
3808 $localtime .= sprintf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3809 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3811 $localtime .= sprintf(" (%02d:%02d %s)",
3812 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3818 # Outputs the author name and date in long form
3819 sub git_print_authorship
{
3822 my $tag = $opts{-tag
} || 'div';
3823 my $author = $co->{'author_name'};
3825 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
3826 print "<$tag class=\"author_date\">" .
3827 format_search_author
($author, "author", esc_html
($author)) .
3829 print_local_time
(%ad) if ($opts{-localtime});
3830 print "]" . git_get_avatar
($co->{'author_email'}, -pad_before
=> 1)
3834 # Outputs table rows containing the full author or committer information,
3835 # in the format expected for 'commit' view (& similar).
3836 # Parameters are a commit hash reference, followed by the list of people
3837 # to output information for. If the list is empty it defaults to both
3838 # author and committer.
3839 sub git_print_authorship_rows
{
3841 # too bad we can't use @people = @_ || ('author', 'committer')
3843 @people = ('author', 'committer') unless @people;
3844 foreach my $who (@people) {
3845 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
3846 print "<tr><td>$who</td><td>" .
3847 format_search_author
($co->{"${who}_name"}, $who,
3848 esc_html
($co->{"${who}_name"})) . " " .
3849 format_search_author
($co->{"${who}_email"}, $who,
3850 esc_html
("<" . $co->{"${who}_email"} . ">")) .
3851 "</td><td rowspan=\"2\">" .
3852 git_get_avatar
($co->{"${who}_email"}, -size
=> 'double') .
3855 "<td></td><td> $wd{'rfc2822'}";
3856 print_local_time
(%wd);
3862 sub git_print_page_path
{
3868 print "<div class=\"page_path\">";
3869 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
3870 -title
=> 'tree root'}, to_utf8
("[$project]"));
3872 if (defined $name) {
3873 my @dirname = split '/', $name;
3874 my $basename = pop @dirname;
3877 foreach my $dir (@dirname) {
3878 $fullname .= ($fullname ?
'/' : '') . $dir;
3879 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
3881 -title
=> $fullname}, esc_path
($dir));
3884 if (defined $type && $type eq 'blob') {
3885 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
3887 -title
=> $name}, esc_path
($basename));
3888 } elsif (defined $type && $type eq 'tree') {
3889 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
3891 -title
=> $name}, esc_path
($basename));
3894 print esc_path
($basename);
3897 print "<br/></div>\n";
3904 if ($opts{'-remove_title'}) {
3905 # remove title, i.e. first line of log
3908 # remove leading empty lines
3909 while (defined $log->[0] && $log->[0] eq "") {
3916 foreach my $line (@
$log) {
3917 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3920 if (! $opts{'-remove_signoff'}) {
3921 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
3924 # remove signoff lines
3931 # print only one empty line
3932 # do not print empty line after signoff
3934 next if ($empty || $signoff);
3940 print format_log_line_html
($line) . "<br/>\n";
3943 if ($opts{'-final_empty_line'}) {
3944 # end with single empty line
3945 print "<br/>\n" unless $empty;
3949 # return link target (what link points to)
3950 sub git_get_link_target
{
3955 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
3959 $link_target = <$fd>;
3964 return $link_target;
3967 # given link target, and the directory (basedir) the link is in,
3968 # return target of link relative to top directory (top tree);
3969 # return undef if it is not possible (including absolute links).
3970 sub normalize_link_target
{
3971 my ($link_target, $basedir) = @_;
3973 # absolute symlinks (beginning with '/') cannot be normalized
3974 return if (substr($link_target, 0, 1) eq '/');
3976 # normalize link target to path from top (root) tree (dir)
3979 $path = $basedir . '/' . $link_target;
3981 # we are in top (root) tree (dir)
3982 $path = $link_target;
3985 # remove //, /./, and /../
3987 foreach my $part (split('/', $path)) {
3988 # discard '.' and ''
3989 next if (!$part || $part eq '.');
3991 if ($part eq '..') {
3995 # link leads outside repository (outside top dir)
3999 push @path_parts, $part;
4002 $path = join('/', @path_parts);
4007 # print tree entry (row of git_tree), but without encompassing <tr> element
4008 sub git_print_tree_entry
{
4009 my ($t, $basedir, $hash_base, $have_blame) = @_;
4012 $base_key{'hash_base'} = $hash_base if defined $hash_base;
4014 # The format of a table row is: mode list link. Where mode is
4015 # the mode of the entry, list is the name of the entry, an href,
4016 # and link is the action links of the entry.
4018 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
4019 if (exists $t->{'size'}) {
4020 print "<td class=\"size\">$t->{'size'}</td>\n";
4022 if ($t->{'type'} eq "blob") {
4023 print "<td class=\"list\">" .
4024 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4025 file_name
=>"$basedir$t->{'name'}", %base_key),
4026 -class => "list"}, esc_path
($t->{'name'}));
4027 if (S_ISLNK
(oct $t->{'mode'})) {
4028 my $link_target = git_get_link_target
($t->{'hash'});
4030 my $norm_target = normalize_link_target
($link_target, $basedir);
4031 if (defined $norm_target) {
4033 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
4034 file_name
=>$norm_target),
4035 -title
=> $norm_target}, esc_path
($link_target));
4037 print " -> " . esc_path
($link_target);
4042 print "<td class=\"link\">";
4043 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4044 file_name
=>"$basedir$t->{'name'}", %base_key)},
4048 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
4049 file_name
=>"$basedir$t->{'name'}", %base_key)},
4052 if (defined $hash_base) {
4054 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4055 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
4059 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
4060 file_name
=>"$basedir$t->{'name'}")},
4064 } elsif ($t->{'type'} eq "tree") {
4065 print "<td class=\"list\">";
4066 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4067 file_name
=>"$basedir$t->{'name'}",
4069 esc_path
($t->{'name'}));
4071 print "<td class=\"link\">";
4072 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4073 file_name
=>"$basedir$t->{'name'}",
4076 if (defined $hash_base) {
4078 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4079 file_name
=>"$basedir$t->{'name'}")},
4084 # unknown object: we can only present history for it
4085 # (this includes 'commit' object, i.e. submodule support)
4086 print "<td class=\"list\">" .
4087 esc_path
($t->{'name'}) .
4089 print "<td class=\"link\">";
4090 if (defined $hash_base) {
4091 print $cgi->a({-href
=> href
(action
=>"history",
4092 hash_base
=>$hash_base,
4093 file_name
=>"$basedir$t->{'name'}")},
4100 ## ......................................................................
4101 ## functions printing large fragments of HTML
4103 # get pre-image filenames for merge (combined) diff
4104 sub fill_from_file_info
{
4105 my ($diff, @parents) = @_;
4107 $diff->{'from_file'} = [ ];
4108 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4109 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4110 if ($diff->{'status'}[$i] eq 'R' ||
4111 $diff->{'status'}[$i] eq 'C') {
4112 $diff->{'from_file'}[$i] =
4113 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
4120 # is current raw difftree line of file deletion
4122 my $diffinfo = shift;
4124 return $diffinfo->{'to_id'} eq ('0' x
40);
4127 # does patch correspond to [previous] difftree raw line
4128 # $diffinfo - hashref of parsed raw diff format
4129 # $patchinfo - hashref of parsed patch diff format
4130 # (the same keys as in $diffinfo)
4131 sub is_patch_split
{
4132 my ($diffinfo, $patchinfo) = @_;
4134 return defined $diffinfo && defined $patchinfo
4135 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4139 sub git_difftree_body
{
4140 my ($difftree, $hash, @parents) = @_;
4141 my ($parent) = $parents[0];
4142 my $have_blame = gitweb_check_feature
('blame');
4143 print "<div class=\"list_head\">\n";
4144 if ($#{$difftree} > 10) {
4145 print(($#{$difftree} + 1) . " files changed:\n");
4149 print "<table class=\"" .
4150 (@parents > 1 ?
"combined " : "") .
4153 # header only for combined diff in 'commitdiff' view
4154 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
4157 print "<thead><tr>\n" .
4158 "<th></th><th></th>\n"; # filename, patchN link
4159 for (my $i = 0; $i < @parents; $i++) {
4160 my $par = $parents[$i];
4162 $cgi->a({-href
=> href
(action
=>"commitdiff",
4163 hash
=>$hash, hash_parent
=>$par),
4164 -title
=> 'commitdiff to parent number ' .
4165 ($i+1) . ': ' . substr($par,0,7)},
4169 print "</tr></thead>\n<tbody>\n";
4174 foreach my $line (@
{$difftree}) {
4175 my $diff = parsed_difftree_line
($line);
4178 print "<tr class=\"dark\">\n";
4180 print "<tr class=\"light\">\n";
4184 if (exists $diff->{'nparents'}) { # combined diff
4186 fill_from_file_info
($diff, @parents)
4187 unless exists $diff->{'from_file'};
4189 if (!is_deleted
($diff)) {
4190 # file exists in the result (child) commit
4192 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4193 file_name
=>$diff->{'to_file'},
4195 -class => "list"}, esc_path
($diff->{'to_file'})) .
4199 esc_path
($diff->{'to_file'}) .
4203 if ($action eq 'commitdiff') {
4206 print "<td class=\"link\">" .
4207 $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4212 my $has_history = 0;
4213 my $not_deleted = 0;
4214 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4215 my $hash_parent = $parents[$i];
4216 my $from_hash = $diff->{'from_id'}[$i];
4217 my $from_path = $diff->{'from_file'}[$i];
4218 my $status = $diff->{'status'}[$i];
4220 $has_history ||= ($status ne 'A');
4221 $not_deleted ||= ($status ne 'D');
4223 if ($status eq 'A') {
4224 print "<td class=\"link\" align=\"right\"> | </td>\n";
4225 } elsif ($status eq 'D') {
4226 print "<td class=\"link\">" .
4227 $cgi->a({-href
=> href
(action
=>"blob",
4230 file_name
=>$from_path)},
4234 if ($diff->{'to_id'} eq $from_hash) {
4235 print "<td class=\"link nochange\">";
4237 print "<td class=\"link\">";
4239 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4240 hash
=>$diff->{'to_id'},
4241 hash_parent
=>$from_hash,
4243 hash_parent_base
=>$hash_parent,
4244 file_name
=>$diff->{'to_file'},
4245 file_parent
=>$from_path)},
4251 print "<td class=\"link\">";
4253 print $cgi->a({-href
=> href
(action
=>"blob",
4254 hash
=>$diff->{'to_id'},
4255 file_name
=>$diff->{'to_file'},
4258 print " | " if ($has_history);
4261 print $cgi->a({-href
=> href
(action
=>"history",
4262 file_name
=>$diff->{'to_file'},
4269 next; # instead of 'else' clause, to avoid extra indent
4271 # else ordinary diff
4273 my ($to_mode_oct, $to_mode_str, $to_file_type);
4274 my ($from_mode_oct, $from_mode_str, $from_file_type);
4275 if ($diff->{'to_mode'} ne ('0' x
6)) {
4276 $to_mode_oct = oct $diff->{'to_mode'};
4277 if (S_ISREG
($to_mode_oct)) { # only for regular file
4278 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4280 $to_file_type = file_type
($diff->{'to_mode'});
4282 if ($diff->{'from_mode'} ne ('0' x
6)) {
4283 $from_mode_oct = oct $diff->{'from_mode'};
4284 if (S_ISREG
($to_mode_oct)) { # only for regular file
4285 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4287 $from_file_type = file_type
($diff->{'from_mode'});
4290 if ($diff->{'status'} eq "A") { # created
4291 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4292 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4293 $mode_chng .= "]</span>";
4295 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4296 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4297 -class => "list"}, esc_path
($diff->{'file'}));
4299 print "<td>$mode_chng</td>\n";
4300 print "<td class=\"link\">";
4301 if ($action eq 'commitdiff') {
4304 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
4307 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4308 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4312 } elsif ($diff->{'status'} eq "D") { # deleted
4313 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4315 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4316 hash_base
=>$parent, file_name
=>$diff->{'file'}),
4317 -class => "list"}, esc_path
($diff->{'file'}));
4319 print "<td>$mode_chng</td>\n";
4320 print "<td class=\"link\">";
4321 if ($action eq 'commitdiff') {
4324 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
4327 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4328 hash_base
=>$parent, file_name
=>$diff->{'file'})},
4331 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
4332 file_name
=>$diff->{'file'})},
4335 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
4336 file_name
=>$diff->{'file'})},
4340 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4341 my $mode_chnge = "";
4342 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4343 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4344 if ($from_file_type ne $to_file_type) {
4345 $mode_chnge .= " from $from_file_type to $to_file_type";
4347 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4348 if ($from_mode_str && $to_mode_str) {
4349 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4350 } elsif ($to_mode_str) {
4351 $mode_chnge .= " mode: $to_mode_str";
4354 $mode_chnge .= "]</span>\n";
4357 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4358 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4359 -class => "list"}, esc_path
($diff->{'file'}));
4361 print "<td>$mode_chnge</td>\n";
4362 print "<td class=\"link\">";
4363 if ($action eq 'commitdiff') {
4366 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4368 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4369 # "commit" view and modified file (not onlu mode changed)
4370 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4371 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4372 hash_base
=>$hash, hash_parent_base
=>$parent,
4373 file_name
=>$diff->{'file'})},
4377 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4378 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4381 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4382 file_name
=>$diff->{'file'})},
4385 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4386 file_name
=>$diff->{'file'})},
4390 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4391 my %status_name = ('R' => 'moved', 'C' => 'copied');
4392 my $nstatus = $status_name{$diff->{'status'}};
4394 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4395 # mode also for directories, so we cannot use $to_mode_str
4396 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4399 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
4400 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
4401 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
4402 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4403 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
4404 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
4405 -class => "list"}, esc_path
($diff->{'from_file'})) .
4406 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4407 "<td class=\"link\">";
4408 if ($action eq 'commitdiff') {
4411 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4413 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4414 # "commit" view and modified file (not only pure rename or copy)
4415 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4416 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4417 hash_base
=>$hash, hash_parent_base
=>$parent,
4418 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
4422 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4423 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
4426 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4427 file_name
=>$diff->{'to_file'})},
4430 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4431 file_name
=>$diff->{'to_file'})},
4435 } # we should not encounter Unmerged (U) or Unknown (X) status
4438 print "</tbody>" if $has_header;
4442 sub git_patchset_body
{
4443 my ($fd, $difftree, $hash, @hash_parents) = @_;
4444 my ($hash_parent) = $hash_parents[0];
4446 my $is_combined = (@hash_parents > 1);
4448 my $patch_number = 0;
4454 print "<div class=\"patchset\">\n";
4456 # skip to first patch
4457 while ($patch_line = <$fd>) {
4460 last if ($patch_line =~ m/^diff /);
4464 while ($patch_line) {
4466 # parse "git diff" header line
4467 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
4468 # $1 is from_name, which we do not use
4469 $to_name = unquote
($2);
4470 $to_name =~ s!^b/!!;
4471 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
4472 # $1 is 'cc' or 'combined', which we do not use
4473 $to_name = unquote
($2);
4478 # check if current patch belong to current raw line
4479 # and parse raw git-diff line if needed
4480 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
4481 # this is continuation of a split patch
4482 print "<div class=\"patch cont\">\n";
4484 # advance raw git-diff output if needed
4485 $patch_idx++ if defined $diffinfo;
4487 # read and prepare patch information
4488 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4490 # compact combined diff output can have some patches skipped
4491 # find which patch (using pathname of result) we are at now;
4493 while ($to_name ne $diffinfo->{'to_file'}) {
4494 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4495 format_diff_cc_simplified
($diffinfo, @hash_parents) .
4496 "</div>\n"; # class="patch"
4501 last if $patch_idx > $#$difftree;
4502 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4506 # modifies %from, %to hashes
4507 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
4509 # this is first patch for raw difftree line with $patch_idx index
4510 # we index @$difftree array from 0, but number patches from 1
4511 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
4515 #assert($patch_line =~ m/^diff /) if DEBUG;
4516 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
4518 # print "git diff" header
4519 print format_git_diff_header_line
($patch_line, $diffinfo,
4522 # print extended diff header
4523 print "<div class=\"diff extended_header\">\n";
4525 while ($patch_line = <$fd>) {
4528 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
4530 print format_extended_diff_header_line
($patch_line, $diffinfo,
4533 print "</div>\n"; # class="diff extended_header"
4535 # from-file/to-file diff header
4536 if (! $patch_line) {
4537 print "</div>\n"; # class="patch"
4540 next PATCH
if ($patch_line =~ m/^diff /);
4541 #assert($patch_line =~ m/^---/) if DEBUG;
4543 my $last_patch_line = $patch_line;
4544 $patch_line = <$fd>;
4546 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
4548 print format_diff_from_to_header
($last_patch_line, $patch_line,
4549 $diffinfo, \
%from, \
%to,
4554 while ($patch_line = <$fd>) {
4557 next PATCH
if ($patch_line =~ m/^diff /);
4559 print format_diff_line
($patch_line, \
%from, \
%to);
4563 print "</div>\n"; # class="patch"
4566 # for compact combined (--cc) format, with chunk and patch simplification
4567 # the patchset might be empty, but there might be unprocessed raw lines
4568 for (++$patch_idx if $patch_number > 0;
4569 $patch_idx < @
$difftree;
4571 # read and prepare patch information
4572 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4574 # generate anchor for "patch" links in difftree / whatchanged part
4575 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4576 format_diff_cc_simplified
($diffinfo, @hash_parents) .
4577 "</div>\n"; # class="patch"
4582 if ($patch_number == 0) {
4583 if (@hash_parents > 1) {
4584 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
4586 print "<div class=\"diff nodifferences\">No differences found</div>\n";
4590 print "</div>\n"; # class="patchset"
4593 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4595 # fills project list info (age, description, owner, forks) for each
4596 # project in the list, removing invalid projects from returned list
4597 # NOTE: modifies $projlist, but does not remove entries from it
4598 sub fill_project_list_info
{
4599 my ($projlist, $check_forks) = @_;
4602 my $show_ctags = gitweb_check_feature
('ctags');
4604 foreach my $pr (@
$projlist) {
4605 my (@activity) = git_get_last_activity
($pr->{'path'});
4606 unless (@activity) {
4609 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
4610 if (!defined $pr->{'descr'}) {
4611 my $descr = git_get_project_description
($pr->{'path'}) || "";
4612 $descr = to_utf8
($descr);
4613 $pr->{'descr_long'} = $descr;
4614 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
4616 if (!defined $pr->{'owner'}) {
4617 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
4620 my $pname = $pr->{'path'};
4621 if (($pname =~ s/\.git$//) &&
4622 ($pname !~ /\/$/) &&
4623 (-d
"$projectroot/$pname")) {
4624 $pr->{'forks'} = "-d $projectroot/$pname";
4629 $show_ctags and $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
4630 push @projects, $pr;
4636 # print 'sort by' <th> element, generating 'sort by $name' replay link
4637 # if that order is not selected
4639 print format_sort_th
(@_);
4642 sub format_sort_th
{
4643 my ($name, $order, $header) = @_;
4645 $header ||= ucfirst($name);
4647 if ($order eq $name) {
4648 $sort_th .= "<th>$header</th>\n";
4650 $sort_th .= "<th>" .
4651 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
4652 -class => "header"}, $header) .
4659 sub git_project_list_body
{
4660 # actually uses global variable $project
4661 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
4663 my $check_forks = gitweb_check_feature
('forks');
4664 my @projects = fill_project_list_info
($projlist, $check_forks);
4666 $order ||= $default_projects_order;
4667 $from = 0 unless defined $from;
4668 $to = $#projects if (!defined $to || $#projects < $to);
4671 project
=> { key
=> 'path', type
=> 'str' },
4672 descr
=> { key
=> 'descr_long', type
=> 'str' },
4673 owner
=> { key
=> 'owner', type
=> 'str' },
4674 age
=> { key
=> 'age', type
=> 'num' }
4676 my $oi = $order_info{$order};
4677 if ($oi->{'type'} eq 'str') {
4678 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
4680 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
4683 my $show_ctags = gitweb_check_feature
('ctags');
4686 foreach my $p (@projects) {
4687 foreach my $ct (keys %{$p->{'ctags'}}) {
4688 $ctags{$ct} += $p->{'ctags'}->{$ct};
4691 my $cloud = git_populate_project_tagcloud
(\
%ctags);
4692 print git_show_project_tagcloud
($cloud, 64);
4695 print "<table class=\"project_list\">\n";
4696 unless ($no_header) {
4699 print "<th></th>\n";
4701 print_sort_th
('project', $order, 'Project');
4702 print_sort_th
('descr', $order, 'Description');
4703 print_sort_th
('owner', $order, 'Owner');
4704 print_sort_th
('age', $order, 'Last Change');
4705 print "<th></th>\n" . # for links
4709 my $tagfilter = $cgi->param('by_tag');
4710 for (my $i = $from; $i <= $to; $i++) {
4711 my $pr = $projects[$i];
4713 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
4714 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
4715 and not $pr->{'descr_long'} =~ /$searchtext/;
4716 # Weed out forks or non-matching entries of search
4718 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s
#\.git$#/#;
4719 $forkbase="^$forkbase" if $forkbase;
4720 next if not $searchtext and not $tagfilter and $show_ctags
4721 and $pr->{'path'} =~ m
#$forkbase.*/.*#; # regexp-safe
4725 print "<tr class=\"dark\">\n";
4727 print "<tr class=\"light\">\n";
4732 if ($pr->{'forks'}) {
4733 print "<!-- $pr->{'forks'} -->\n";
4734 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "+");
4738 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4739 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
4740 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4741 -class => "list", -title
=> $pr->{'descr_long'}},
4742 esc_html
($pr->{'descr'})) . "</td>\n" .
4743 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
4744 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
4745 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
4746 "<td class=\"link\">" .
4747 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
4748 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
4749 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
4750 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
4751 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
4755 if (defined $extra) {
4758 print "<td></td>\n";
4760 print "<td colspan=\"5\">$extra</td>\n" .
4767 # uses global variable $project
4768 my ($commitlist, $from, $to, $refs, $extra) = @_;
4770 $from = 0 unless defined $from;
4771 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4773 for (my $i = 0; $i <= $to; $i++) {
4774 my %co = %{$commitlist->[$i]};
4776 my $commit = $co{'id'};
4777 my $ref = format_ref_marker
($refs, $commit);
4778 my %ad = parse_date
($co{'author_epoch'});
4779 git_print_header_div
('commit',
4780 "<span class=\"age\">$co{'age_string'}</span>" .
4781 esc_html
($co{'title'}) . $ref,
4783 print "<div class=\"title_text\">\n" .
4784 "<div class=\"log_link\">\n" .
4785 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
4787 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
4789 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
4792 git_print_authorship
(\
%co, -tag
=> 'span');
4793 print "<br/>\n</div>\n";
4795 print "<div class=\"log_body\">\n";
4796 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
4800 print "<div class=\"page_nav\">\n";
4806 sub git_shortlog_body
{
4807 # uses global variable $project
4808 my ($commitlist, $from, $to, $refs, $extra) = @_;
4810 $from = 0 unless defined $from;
4811 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4813 print "<table class=\"shortlog\">\n";
4815 for (my $i = $from; $i <= $to; $i++) {
4816 my %co = %{$commitlist->[$i]};
4817 my $commit = $co{'id'};
4818 my $ref = format_ref_marker
($refs, $commit);
4820 print "<tr class=\"dark\">\n";
4822 print "<tr class=\"light\">\n";
4825 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4826 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4827 format_author_html
('td', \
%co, 10) . "<td>";
4828 print format_subject_html
($co{'title'}, $co{'title_short'},
4829 href
(action
=>"commit", hash
=>$commit), $ref);
4831 "<td class=\"link\">" .
4832 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
4833 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
4834 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
4835 my $snapshot_links = format_snapshot_links
($commit);
4836 if (defined $snapshot_links) {
4837 print " | " . $snapshot_links;
4842 if (defined $extra) {
4844 "<td colspan=\"4\">$extra</td>\n" .
4850 sub git_history_body
{
4851 # Warning: assumes constant type (blob or tree) during history
4852 my ($commitlist, $from, $to, $refs, $extra,
4853 $file_name, $file_hash, $ftype) = @_;
4855 $from = 0 unless defined $from;
4856 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
4858 print "<table class=\"history\">\n";
4860 for (my $i = $from; $i <= $to; $i++) {
4861 my %co = %{$commitlist->[$i]};
4865 my $commit = $co{'id'};
4867 my $ref = format_ref_marker
($refs, $commit);
4870 print "<tr class=\"dark\">\n";
4872 print "<tr class=\"light\">\n";
4875 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4876 # shortlog: format_author_html('td', \%co, 10)
4877 format_author_html
('td', \
%co, 15, 3) . "<td>";
4878 # originally git_history used chop_str($co{'title'}, 50)
4879 print format_subject_html
($co{'title'}, $co{'title_short'},
4880 href
(action
=>"commit", hash
=>$commit), $ref);
4882 "<td class=\"link\">" .
4883 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
4884 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
4886 if ($ftype eq 'blob') {
4887 my $blob_current = $file_hash;
4888 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
4889 if (defined $blob_current && defined $blob_parent &&
4890 $blob_current ne $blob_parent) {
4892 $cgi->a({-href
=> href
(action
=>"blobdiff",
4893 hash
=>$blob_current, hash_parent
=>$blob_parent,
4894 hash_base
=>$hash_base, hash_parent_base
=>$commit,
4895 file_name
=>$file_name)},
4902 if (defined $extra) {
4904 "<td colspan=\"4\">$extra</td>\n" .
4911 # uses global variable $project
4912 my ($taglist, $from, $to, $extra) = @_;
4913 $from = 0 unless defined $from;
4914 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
4916 print "<table class=\"tags\">\n";
4918 for (my $i = $from; $i <= $to; $i++) {
4919 my $entry = $taglist->[$i];
4921 my $comment = $tag{'subject'};
4923 if (defined $comment) {
4924 $comment_short = chop_str
($comment, 30, 5);
4927 print "<tr class=\"dark\">\n";
4929 print "<tr class=\"light\">\n";
4932 if (defined $tag{'age'}) {
4933 print "<td><i>$tag{'age'}</i></td>\n";
4935 print "<td></td>\n";
4938 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
4939 -class => "list name"}, esc_html
($tag{'name'})) .
4942 if (defined $comment) {
4943 print format_subject_html
($comment, $comment_short,
4944 href
(action
=>"tag", hash
=>$tag{'id'}));
4947 "<td class=\"selflink\">";
4948 if ($tag{'type'} eq "tag") {
4949 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
4954 "<td class=\"link\">" . " | " .
4955 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
4956 if ($tag{'reftype'} eq "commit") {
4957 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
4958 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
4959 } elsif ($tag{'reftype'} eq "blob") {
4960 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
4965 if (defined $extra) {
4967 "<td colspan=\"5\">$extra</td>\n" .
4973 sub git_heads_body
{
4974 # uses global variable $project
4975 my ($headlist, $head, $from, $to, $extra) = @_;
4976 $from = 0 unless defined $from;
4977 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4979 print "<table class=\"heads\">\n";
4981 for (my $i = $from; $i <= $to; $i++) {
4982 my $entry = $headlist->[$i];
4984 my $curr = $ref{'id'} eq $head;
4986 print "<tr class=\"dark\">\n";
4988 print "<tr class=\"light\">\n";
4991 print "<td><i>$ref{'age'}</i></td>\n" .
4992 ($curr ?
"<td class=\"current_head\">" : "<td>") .
4993 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
4994 -class => "list name"},esc_html
($ref{'name'})) .
4996 "<td class=\"link\">" .
4997 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
4998 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
4999 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'fullname'})}, "tree") .
5003 if (defined $extra) {
5005 "<td colspan=\"3\">$extra</td>\n" .
5011 sub git_search_grep_body
{
5012 my ($commitlist, $from, $to, $extra) = @_;
5013 $from = 0 unless defined $from;
5014 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5016 print "<table class=\"commit_search\">\n";
5018 for (my $i = $from; $i <= $to; $i++) {
5019 my %co = %{$commitlist->[$i]};
5023 my $commit = $co{'id'};
5025 print "<tr class=\"dark\">\n";
5027 print "<tr class=\"light\">\n";
5030 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5031 format_author_html
('td', \
%co, 15, 5) .
5033 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5034 -class => "list subject"},
5035 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5036 my $comment = $co{'comment'};
5037 foreach my $line (@
$comment) {
5038 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5039 my ($lead, $match, $trail) = ($1, $2, $3);
5040 $match = chop_str
($match, 70, 5, 'center');
5041 my $contextlen = int((80 - length($match))/2);
5042 $contextlen = 30 if ($contextlen > 30);
5043 $lead = chop_str
($lead, $contextlen, 10, 'left');
5044 $trail = chop_str
($trail, $contextlen, 10, 'right');
5046 $lead = esc_html
($lead);
5047 $match = esc_html
($match);
5048 $trail = esc_html
($trail);
5050 print "$lead<span class=\"match\">$match</span>$trail<br />";
5054 "<td class=\"link\">" .
5055 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5057 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
5059 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5063 if (defined $extra) {
5065 "<td colspan=\"3\">$extra</td>\n" .
5071 ## ======================================================================
5072 ## ======================================================================
5075 sub git_project_list
{
5076 my $order = $input_params{'order'};
5077 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5078 die_error
(400, "Unknown order parameter");
5081 my @list = git_get_projects_list
();
5083 die_error
(404, "No projects found");
5087 if (defined $home_text && -f
$home_text) {
5088 print "<div class=\"index_include\">\n";
5089 insert_file
($home_text);
5092 print $cgi->startform(-method
=> "get") .
5093 "<p class=\"projsearch\">Search:\n" .
5094 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
5096 $cgi->end_form() . "\n";
5097 git_project_list_body
(\
@list, $order);
5102 my $order = $input_params{'order'};
5103 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5104 die_error
(400, "Unknown order parameter");
5107 my @list = git_get_projects_list
($project);
5109 die_error
(404, "No forks found");
5113 git_print_page_nav
('','');
5114 git_print_header_div
('summary', "$project forks");
5115 git_project_list_body
(\
@list, $order);
5119 sub git_project_index
{
5120 my @projects = git_get_projects_list
($project);
5123 -type
=> 'text/plain',
5124 -charset
=> 'utf-8',
5125 -content_disposition
=> 'inline; filename="index.aux"');
5127 foreach my $pr (@projects) {
5128 if (!exists $pr->{'owner'}) {
5129 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
5132 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
5133 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
5134 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5135 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5139 print "$path $owner\n";
5144 my $descr = git_get_project_description
($project) || "none";
5145 my %co = parse_commit
("HEAD");
5146 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
5147 my $head = $co{'id'};
5148 my $remote_heads = gitweb_check_feature
('remote_heads');
5150 my $owner = git_get_project_owner
($project);
5152 my $refs = git_get_references
();
5153 # These get_*_list functions return one more to allow us to see if
5154 # there are more ...
5155 my @taglist = git_get_tags_list
(16);
5156 my @headlist = git_get_heads_list
(16);
5157 my @remotelist = $remote_heads ? git_get_heads_list
(16, 'remotes') : ();
5159 my $check_forks = gitweb_check_feature
('forks');
5162 @forklist = git_get_projects_list
($project);
5166 git_print_page_nav
('summary','', $head);
5168 print "<div class=\"title\"> </div>\n";
5169 print "<table class=\"projects_list\">\n" .
5170 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
5171 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
5172 if (defined $cd{'rfc2822'}) {
5173 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
5176 # use per project git URL list in $projectroot/$project/cloneurl
5177 # or make project git URL from git base URL and project name
5178 my $url_tag = "URL";
5179 my @url_list = git_get_project_url_list
($project);
5180 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
5181 foreach my $git_url (@url_list) {
5182 next unless $git_url;
5183 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
5188 my $show_ctags = gitweb_check_feature
('ctags');
5190 my $ctags = git_get_project_ctags
($project);
5191 my $cloud = git_populate_project_tagcloud
($ctags);
5192 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
5193 print "</td>\n<td>" unless %$ctags;
5194 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
5195 print "</td>\n<td>" if %$ctags;
5196 print git_show_project_tagcloud
($cloud, 48);
5202 # If XSS prevention is on, we don't include README.html.
5203 # TODO: Allow a readme in some safe format.
5204 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
5205 print "<div class=\"title\">readme</div>\n" .
5206 "<div class=\"readme\">\n";
5207 insert_file
("$projectroot/$project/README.html");
5208 print "\n</div>\n"; # class="readme"
5211 # we need to request one more than 16 (0..15) to check if
5213 my @commitlist = $head ? parse_commits
($head, 17) : ();
5215 git_print_header_div
('shortlog');
5216 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
5217 $#commitlist <= 15 ?
undef :
5218 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
5222 git_print_header_div
('tags');
5223 git_tags_body
(\
@taglist, 0, 15,
5224 $#taglist <= 15 ?
undef :
5225 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
5229 git_print_header_div
('heads');
5230 git_heads_body
(\
@headlist, $head, 0, 15,
5231 $#headlist <= 15 ?
undef :
5232 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
5236 git_print_header_div
('remotes');
5237 git_heads_body
(\
@remotelist, $head, 0, 15,
5238 $#remotelist <= 15 ?
undef :
5239 $cgi->a({-href
=> href
(action
=>"remotes")}, "..."));
5243 git_print_header_div
('forks');
5244 git_project_list_body
(\
@forklist, 'age', 0, 15,
5245 $#forklist <= 15 ?
undef :
5246 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
5254 my %tag = parse_tag
($hash);
5257 die_error
(404, "Unknown tag object");
5260 my $head = git_get_head_hash
($project);
5262 git_print_page_nav
('','', $head,undef,$head);
5263 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
5264 print "<div class=\"title_text\">\n" .
5265 "<table class=\"object_header\">\n" .
5267 "<td>object</td>\n" .
5268 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
5269 $tag{'object'}) . "</td>\n" .
5270 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
5271 $tag{'type'}) . "</td>\n" .
5273 if (defined($tag{'author'})) {
5274 git_print_authorship_rows
(\
%tag, 'author');
5276 print "</table>\n\n" .
5278 print "<div class=\"page_body\">";
5279 my $comment = $tag{'comment'};
5280 foreach my $line (@
$comment) {
5282 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
5288 sub git_blame_common
{
5289 my $format = shift || 'porcelain';
5290 if ($format eq 'porcelain' && $cgi->param('js')) {
5291 $format = 'incremental';
5292 $action = 'blame_incremental'; # for page title etc
5296 gitweb_check_feature
('blame')
5297 or die_error
(403, "Blame view not allowed");
5300 die_error
(400, "No file name given") unless $file_name;
5301 $hash_base ||= git_get_head_hash
($project);
5302 die_error
(404, "Couldn't find base commit") unless $hash_base;
5303 my %co = parse_commit
($hash_base)
5304 or die_error
(404, "Commit not found");
5306 if (!defined $hash) {
5307 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
5308 or die_error
(404, "Error looking up file");
5310 $ftype = git_get_type
($hash);
5311 if ($ftype !~ "blob") {
5312 die_error
(400, "Object is not a blob");
5317 if ($format eq 'incremental') {
5318 # get file contents (as base)
5319 open $fd, "-|", git_cmd
(), 'cat-file', 'blob', $hash
5320 or die_error
(500, "Open git-cat-file failed");
5321 } elsif ($format eq 'data') {
5322 # run git-blame --incremental
5323 open $fd, "-|", git_cmd
(), "blame", "--incremental",
5324 $hash_base, "--", $file_name
5325 or die_error
(500, "Open git-blame --incremental failed");
5327 # run git-blame --porcelain
5328 open $fd, "-|", git_cmd
(), "blame", '-p',
5329 $hash_base, '--', $file_name
5330 or die_error
(500, "Open git-blame --porcelain failed");
5333 # incremental blame data returns early
5334 if ($format eq 'data') {
5336 -type
=>"text/plain", -charset
=> "utf-8",
5337 -status
=> "200 OK");
5338 local $| = 1; # output autoflush
5341 or print "ERROR $!\n";
5344 if (defined $t0 && gitweb_check_feature
('timed')) {
5346 Time
::HiRes
::tv_interval
($t0, [Time
::HiRes
::gettimeofday
()]).
5347 ' '.$number_of_git_cmds;
5357 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
5360 if ($format eq 'incremental') {
5362 $cgi->a({-href
=> href
(action
=>"blame", javascript
=>0, -replay
=>1)},
5363 "blame") . " (non-incremental)";
5366 $cgi->a({-href
=> href
(action
=>"blame_incremental", -replay
=>1)},
5367 "blame") . " (incremental)";
5371 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5374 $cgi->a({-href
=> href
(action
=>$action, file_name
=>$file_name)},
5376 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5377 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5378 git_print_page_path
($file_name, $ftype, $hash_base);
5381 if ($format eq 'incremental') {
5382 print "<noscript>\n<div class=\"error\"><center><b>\n".
5383 "This page requires JavaScript to run.\n Use ".
5384 $cgi->a({-href
=> href
(action
=>'blame',javascript
=>0,-replay
=>1)},
5387 "</b></center></div>\n</noscript>\n";
5389 print qq!<div id
="progress_bar" style
="width: 100%; background-color: yellow"></div
>\n!;
5392 print qq!<div
class="page_body">\n!;
5393 print qq!<div id
="progress_info">... / ...</div
>\n!
5394 if ($format eq 'incremental');
5395 print qq!<table id
="blame_table" class="blame" width
="100%">\n!.
5396 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
5398 qq!<tr
><th
>Commit
</th><th>Line</th
><th
>Data
</th></tr
>\n!.
5402 my @rev_color = qw(light dark);
5403 my $num_colors = scalar(@rev_color);
5404 my $current_color = 0;
5406 if ($format eq 'incremental') {
5407 my $color_class = $rev_color[$current_color];
5412 while (my $line = <$fd>) {
5416 print qq!<tr id
="l$linenr" class="$color_class">!.
5417 qq!<td
class="sha1"><a href
=""> </a></td
>!.
5418 qq!<td
class="linenr">!.
5419 qq!<a
class="linenr" href
="">$linenr</a></td
>!;
5420 print qq!<td
class="pre">! . esc_html
($line) . "</td>\n";
5424 } else { # porcelain, i.e. ordinary blame
5425 my %metainfo = (); # saves information about commits
5429 while (my $line = <$fd>) {
5431 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
5432 # no <lines in group> for subsequent lines in group of lines
5433 my ($full_rev, $orig_lineno, $lineno, $group_size) =
5434 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
5435 if (!exists $metainfo{$full_rev}) {
5436 $metainfo{$full_rev} = { 'nprevious' => 0 };
5438 my $meta = $metainfo{$full_rev};
5440 while ($data = <$fd>) {
5442 last if ($data =~ s/^\t//); # contents of line
5443 if ($data =~ /^(\S+)(?: (.*))?$/) {
5444 $meta->{$1} = $2 unless exists $meta->{$1};
5446 if ($data =~ /^previous /) {
5447 $meta->{'nprevious'}++;
5450 my $short_rev = substr($full_rev, 0, 8);
5451 my $author = $meta->{'author'};
5453 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
5454 my $date = $date{'iso-tz'};
5456 $current_color = ($current_color + 1) % $num_colors;
5458 my $tr_class = $rev_color[$current_color];
5459 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
5460 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
5461 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
5462 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
5464 print "<td class=\"sha1\"";
5465 print " title=\"". esc_html
($author) . ", $date\"";
5466 print " rowspan=\"$group_size\"" if ($group_size > 1);
5468 print $cgi->a({-href
=> href
(action
=>"commit",
5470 file_name
=>$file_name)},
5471 esc_html
($short_rev));
5472 if ($group_size >= 2) {
5473 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
5474 if (@author_initials) {
5476 esc_html
(join('', @author_initials));
5482 # 'previous' <sha1 of parent commit> <filename at commit>
5483 if (exists $meta->{'previous'} &&
5484 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
5485 $meta->{'parent'} = $1;
5486 $meta->{'file_parent'} = unquote
($2);
5489 exists($meta->{'parent'}) ?
5490 $meta->{'parent'} : $full_rev;
5491 my $linenr_filename =
5492 exists($meta->{'file_parent'}) ?
5493 $meta->{'file_parent'} : unquote
($meta->{'filename'});
5494 my $blamed = href
(action
=> 'blame',
5495 file_name
=> $linenr_filename,
5496 hash_base
=> $linenr_commit);
5497 print "<td class=\"linenr\">";
5498 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
5499 -class => "linenr" },
5502 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
5510 "</table>\n"; # class="blame"
5511 print "</div>\n"; # class="blame_body"
5513 or print "Reading blob failed\n";
5522 sub git_blame_incremental
{
5523 git_blame_common
('incremental');
5526 sub git_blame_data
{
5527 git_blame_common
('data');
5531 my $head = git_get_head_hash
($project);
5533 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('tags'));
5534 git_print_header_div
('summary', $project);
5536 my @tagslist = git_get_tags_list
();
5538 git_tags_body
(\
@tagslist);
5544 my $head = git_get_head_hash
($project);
5546 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('heads'));
5547 git_print_header_div
('summary', $project);
5549 my @headslist = git_get_heads_list
();
5551 git_heads_body
(\
@headslist, $head);
5557 gitweb_check_feature
('remote_heads')
5558 or die_error
(403, "Remote heads view is disabled");
5560 my $head = git_get_head_hash
($project);
5562 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('remotes'));
5563 git_print_header_div
('summary', $project);
5565 my @remotelist = git_get_heads_list
(undef, 'remotes');
5567 git_heads_body
(\
@remotelist, $head);
5572 sub git_blob_plain
{
5576 if (!defined $hash) {
5577 if (defined $file_name) {
5578 my $base = $hash_base || git_get_head_hash
($project);
5579 $hash = git_get_hash_by_path
($base, $file_name, "blob")
5580 or die_error
(404, "Cannot find file");
5582 die_error
(400, "No file name defined");
5584 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5585 # blobs defined by non-textual hash id's can be cached
5589 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
5590 or die_error
(500, "Open git-cat-file blob '$hash' failed");
5592 # content-type (can include charset)
5593 $type = blob_contenttype
($fd, $file_name, $type);
5595 # "save as" filename, even when no $file_name is given
5596 my $save_as = "$hash";
5597 if (defined $file_name) {
5598 $save_as = $file_name;
5599 } elsif ($type =~ m/^text\//) {
5603 # With XSS prevention on, blobs of all types except a few known safe
5604 # ones are served with "Content-Disposition: attachment" to make sure
5605 # they don't run in our security domain. For certain image types,
5606 # blob view writes an <img> tag referring to blob_plain view, and we
5607 # want to be sure not to break that by serving the image as an
5608 # attachment (though Firefox 3 doesn't seem to care).
5609 my $sandbox = $prevent_xss &&
5610 $type !~ m!^(?:text/plain|image/(?:gif|png|jpeg))$!;
5614 -expires
=> $expires,
5615 -content_disposition
=>
5616 ($sandbox ?
'attachment' : 'inline')
5617 . '; filename="' . $save_as . '"');
5619 binmode STDOUT
, ':raw';
5621 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
5628 if (!defined $hash) {
5629 if (defined $file_name) {
5630 my $base = $hash_base || git_get_head_hash
($project);
5631 $hash = git_get_hash_by_path
($base, $file_name, "blob")
5632 or die_error
(404, "Cannot find file");
5634 die_error
(400, "No file name defined");
5636 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5637 # blobs defined by non-textual hash id's can be cached
5641 my $have_blame = gitweb_check_feature
('blame');
5642 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
5643 or die_error
(500, "Couldn't cat $file_name, $hash");
5644 my $mimetype = blob_mimetype
($fd, $file_name);
5645 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
5646 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
5648 return git_blob_plain
($mimetype);
5650 # we can have blame only for text/* mimetype
5651 $have_blame &&= ($mimetype =~ m!^text/!);
5653 my $highlight = gitweb_check_feature
('highlight');
5654 my $syntax = guess_file_syntax
($highlight, $mimetype, $file_name);
5655 $fd = run_highlighter
($fd, $highlight, $syntax)
5658 git_header_html
(undef, $expires);
5659 my $formats_nav = '';
5660 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5661 if (defined $file_name) {
5664 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
5669 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5672 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
5675 $cgi->a({-href
=> href
(action
=>"blob",
5676 hash_base
=>"HEAD", file_name
=>$file_name)},
5680 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
5683 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5684 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5686 print "<div class=\"page_nav\">\n" .
5687 "<br/><br/></div>\n" .
5688 "<div class=\"title\">$hash</div>\n";
5690 git_print_page_path
($file_name, "blob", $hash_base);
5691 print "<div class=\"page_body\">\n";
5692 if ($mimetype =~ m!^image/!) {
5693 print qq!<img type
="$mimetype"!;
5695 print qq! alt
="$file_name" title
="$file_name"!;
5698 href(action=>"blob_plain
", hash=>$hash,
5699 hash_base=>$hash_base, file_name=>$file_name) .
5703 while (my $line = <$fd>) {
5706 $line = untabify
($line);
5707 printf qq!<div
class="pre"><a id
="l%i" href
="%s#l%i" class="linenr">%4i</a> %s</div
>\n!,
5708 $nr, href
(-replay
=> 1), $nr, $nr, $syntax ?
$line : esc_html
($line, -nbsp
=>1);
5712 or print "Reading blob failed.\n";
5718 if (!defined $hash_base) {
5719 $hash_base = "HEAD";
5721 if (!defined $hash) {
5722 if (defined $file_name) {
5723 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
5728 die_error
(404, "No such tree") unless defined($hash);
5730 my $show_sizes = gitweb_check_feature
('show-sizes');
5731 my $have_blame = gitweb_check_feature
('blame');
5736 open my $fd, "-|", git_cmd
(), "ls-tree", '-z',
5737 ($show_sizes ?
'-l' : ()), @extra_options, $hash
5738 or die_error
(500, "Open git-ls-tree failed");
5739 @entries = map { chomp; $_ } <$fd>;
5741 or die_error
(404, "Reading tree failed");
5744 my $refs = git_get_references
();
5745 my $ref = format_ref_marker
($refs, $hash_base);
5748 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5750 if (defined $file_name) {
5752 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5754 $cgi->a({-href
=> href
(action
=>"tree",
5755 hash_base
=>"HEAD", file_name
=>$file_name)},
5758 my $snapshot_links = format_snapshot_links
($hash);
5759 if (defined $snapshot_links) {
5760 # FIXME: Should be available when we have no hash base as well.
5761 push @views_nav, $snapshot_links;
5763 git_print_page_nav
('tree','', $hash_base, undef, undef,
5764 join(' | ', @views_nav));
5765 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
5768 print "<div class=\"page_nav\">\n";
5769 print "<br/><br/></div>\n";
5770 print "<div class=\"title\">$hash</div>\n";
5772 if (defined $file_name) {
5773 $basedir = $file_name;
5774 if ($basedir ne '' && substr($basedir, -1) ne '/') {
5777 git_print_page_path
($file_name, 'tree', $hash_base);
5779 print "<div class=\"page_body\">\n";
5780 print "<table class=\"tree\">\n";
5782 # '..' (top directory) link if possible
5783 if (defined $hash_base &&
5784 defined $file_name && $file_name =~ m![^/]+$!) {
5786 print "<tr class=\"dark\">\n";
5788 print "<tr class=\"light\">\n";
5792 my $up = $file_name;
5793 $up =~ s!/?[^/]+$!!;
5794 undef $up unless $up;
5795 # based on git_print_tree_entry
5796 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
5797 print '<td class="size"> </td>'."\n" if $show_sizes;
5798 print '<td class="list">';
5799 print $cgi->a({-href
=> href
(action
=>"tree",
5800 hash_base
=>$hash_base,
5804 print "<td class=\"link\"></td>\n";
5808 foreach my $line (@entries) {
5809 my %t = parse_ls_tree_line
($line, -z
=> 1, -l
=> $show_sizes);
5812 print "<tr class=\"dark\">\n";
5814 print "<tr class=\"light\">\n";
5818 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
5822 print "</table>\n" .
5828 my ($project, $hash) = @_;
5830 # path/to/project.git -> project
5831 # path/to/project/.git -> project
5832 my $name = to_utf8
($project);
5833 $name =~ s
,([^/])/*\
.git
$,$1,;
5834 $name = basename
($name);
5836 $name =~ s/[[:cntrl:]]/?/g;
5839 if ($hash =~ /^[0-9a-fA-F]+$/) {
5840 # shorten SHA-1 hash
5841 my $full_hash = git_get_full_hash
($project, $hash);
5842 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
5843 $ver = git_get_short_hash
($project, $hash);
5845 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
5846 # tags don't need shortened SHA-1 hash
5849 # branches and other need shortened SHA-1 hash
5850 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
5853 $ver .= '-' . git_get_short_hash
($project, $hash);
5855 # in case of hierarchical branch names
5858 # name = project-version_string
5859 $name = "$name-$ver";
5861 return wantarray ?
($name, $name) : $name;
5865 my $format = $input_params{'snapshot_format'};
5866 if (!@snapshot_fmts) {
5867 die_error
(403, "Snapshots not allowed");
5869 # default to first supported snapshot format
5870 $format ||= $snapshot_fmts[0];
5871 if ($format !~ m/^[a-z0-9]+$/) {
5872 die_error
(400, "Invalid snapshot format parameter");
5873 } elsif (!exists($known_snapshot_formats{$format})) {
5874 die_error
(400, "Unknown snapshot format");
5875 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
5876 die_error
(403, "Snapshot format not allowed");
5877 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
5878 die_error
(403, "Unsupported snapshot format");
5881 my $type = git_get_type
("$hash^{}");
5883 die_error
(404, 'Object does not exist');
5884 } elsif ($type eq 'blob') {
5885 die_error
(400, 'Object is not a tree-ish');
5888 my ($name, $prefix) = snapshot_name
($project, $hash);
5889 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
5890 my $cmd = quote_command
(
5891 git_cmd
(), 'archive',
5892 "--format=$known_snapshot_formats{$format}{'format'}",
5893 "--prefix=$prefix/", $hash);
5894 if (exists $known_snapshot_formats{$format}{'compressor'}) {
5895 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
5898 $filename =~ s/(["\\])/\\$1/g;
5900 -type
=> $known_snapshot_formats{$format}{'type'},
5901 -content_disposition
=> 'inline; filename="' . $filename . '"',
5902 -status
=> '200 OK');
5904 open my $fd, "-|", $cmd
5905 or die_error
(500, "Execute git-archive failed");
5906 binmode STDOUT
, ':raw';
5908 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
5912 sub git_log_generic
{
5913 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
5915 my $head = git_get_head_hash
($project);
5916 if (!defined $base) {
5919 if (!defined $page) {
5922 my $refs = git_get_references
();
5924 my $commit_hash = $base;
5925 if (defined $parent) {
5926 $commit_hash = "$parent..$base";
5929 parse_commits
($commit_hash, 101, (100 * $page),
5930 defined $file_name ?
($file_name, "--full-history") : ());
5933 if (!defined $file_hash && defined $file_name) {
5934 # some commits could have deleted file in question,
5935 # and not have it in tree, but one of them has to have it
5936 for (my $i = 0; $i < @commitlist; $i++) {
5937 $file_hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
5938 last if defined $file_hash;
5941 if (defined $file_hash) {
5942 $ftype = git_get_type
($file_hash);
5944 if (defined $file_name && !defined $ftype) {
5945 die_error
(500, "Unknown type of object");
5948 if (defined $file_name) {
5949 %co = parse_commit
($base)
5950 or die_error
(404, "Unknown commit object");
5954 my $paging_nav = format_paging_nav
($fmt_name, $page, $#commitlist >= 100);
5956 if ($#commitlist >= 100) {
5958 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5959 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5961 my $patch_max = gitweb_get_feature
('patches');
5962 if ($patch_max && !defined $file_name) {
5963 if ($patch_max < 0 || @commitlist <= $patch_max) {
5964 $paging_nav .= " ⋅ " .
5965 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
5971 git_print_page_nav
($fmt_name,'', $hash,$hash,$hash, $paging_nav);
5972 if (defined $file_name) {
5973 git_print_header_div
('commit', esc_html
($co{'title'}), $base);
5975 git_print_header_div
('summary', $project)
5977 git_print_page_path
($file_name, $ftype, $hash_base)
5978 if (defined $file_name);
5980 $body_subr->(\
@commitlist, 0, 99, $refs, $next_link,
5981 $file_name, $file_hash, $ftype);
5987 git_log_generic
('log', \
&git_log_body
,
5988 $hash, $hash_parent);
5992 $hash ||= $hash_base || "HEAD";
5993 my %co = parse_commit
($hash)
5994 or die_error
(404, "Unknown commit object");
5996 my $parent = $co{'parent'};
5997 my $parents = $co{'parents'}; # listref
5999 # we need to prepare $formats_nav before any parameter munging
6001 if (!defined $parent) {
6003 $formats_nav .= '(initial)';
6004 } elsif (@
$parents == 1) {
6005 # single parent commit
6008 $cgi->a({-href
=> href
(action
=>"commit",
6010 esc_html
(substr($parent, 0, 7))) .
6017 $cgi->a({-href
=> href
(action
=>"commit",
6019 esc_html
(substr($_, 0, 7)));
6023 if (gitweb_check_feature
('patches') && @
$parents <= 1) {
6024 $formats_nav .= " | " .
6025 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6029 if (!defined $parent) {
6033 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
6035 (@
$parents <= 1 ?
$parent : '-c'),
6037 or die_error
(500, "Open git-diff-tree failed");
6038 @difftree = map { chomp; $_ } <$fd>;
6039 close $fd or die_error
(404, "Reading git-diff-tree failed");
6041 # non-textual hash id's can be cached
6043 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6046 my $refs = git_get_references
();
6047 my $ref = format_ref_marker
($refs, $co{'id'});
6049 git_header_html
(undef, $expires);
6050 git_print_page_nav
('commit', '',
6051 $hash, $co{'tree'}, $hash,
6054 if (defined $co{'parent'}) {
6055 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
6057 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
6059 print "<div class=\"title_text\">\n" .
6060 "<table class=\"object_header\">\n";
6061 git_print_authorship_rows
(\
%co);
6062 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
6065 "<td class=\"sha1\">" .
6066 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
6067 class => "list"}, $co{'tree'}) .
6069 "<td class=\"link\">" .
6070 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
6072 my $snapshot_links = format_snapshot_links
($hash);
6073 if (defined $snapshot_links) {
6074 print " | " . $snapshot_links;
6079 foreach my $par (@
$parents) {
6082 "<td class=\"sha1\">" .
6083 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
6084 class => "list"}, $par) .
6086 "<td class=\"link\">" .
6087 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
6089 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
6096 print "<div class=\"page_body\">\n";
6097 git_print_log
($co{'comment'});
6100 git_difftree_body
(\
@difftree, $hash, @
$parents);
6106 # object is defined by:
6107 # - hash or hash_base alone
6108 # - hash_base and file_name
6111 # - hash or hash_base alone
6112 if ($hash || ($hash_base && !defined $file_name)) {
6113 my $object_id = $hash || $hash_base;
6115 open my $fd, "-|", quote_command
(
6116 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
6117 or die_error
(404, "Object does not exist");
6121 or die_error
(404, "Object does not exist");
6123 # - hash_base and file_name
6124 } elsif ($hash_base && defined $file_name) {
6125 $file_name =~ s
,/+$,,;
6127 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
6128 or die_error
(404, "Base object does not exist");
6130 # here errors should not hapen
6131 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
6132 or die_error
(500, "Open git-ls-tree failed");
6136 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
6137 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
6138 die_error
(404, "File or directory for given base does not exist");
6143 die_error
(400, "Not enough information to find object");
6146 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
6147 hash
=>$hash, hash_base
=>$hash_base,
6148 file_name
=>$file_name),
6149 -status
=> '302 Found');
6153 my $format = shift || 'html';
6160 # preparing $fd and %diffinfo for git_patchset_body
6162 if (defined $hash_base && defined $hash_parent_base) {
6163 if (defined $file_name) {
6165 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6166 $hash_parent_base, $hash_base,
6167 "--", (defined $file_parent ?
$file_parent : ()), $file_name
6168 or die_error
(500, "Open git-diff-tree failed");
6169 @difftree = map { chomp; $_ } <$fd>;
6171 or die_error
(404, "Reading git-diff-tree failed");
6173 or die_error
(404, "Blob diff not found");
6175 } elsif (defined $hash &&
6176 $hash =~ /[0-9a-fA-F]{40}/) {
6177 # try to find filename from $hash
6179 # read filtered raw output
6180 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6181 $hash_parent_base, $hash_base, "--"
6182 or die_error
(500, "Open git-diff-tree failed");
6184 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
6186 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
6187 map { chomp; $_ } <$fd>;
6189 or die_error
(404, "Reading git-diff-tree failed");
6191 or die_error
(404, "Blob diff not found");
6194 die_error
(400, "Missing one of the blob diff parameters");
6197 if (@difftree > 1) {
6198 die_error
(400, "Ambiguous blob diff specification");
6201 %diffinfo = parse_difftree_raw_line
($difftree[0]);
6202 $file_parent ||= $diffinfo{'from_file'} || $file_name;
6203 $file_name ||= $diffinfo{'to_file'};
6205 $hash_parent ||= $diffinfo{'from_id'};
6206 $hash ||= $diffinfo{'to_id'};
6208 # non-textual hash id's can be cached
6209 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
6210 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
6215 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6216 '-p', ($format eq 'html' ?
"--full-index" : ()),
6217 $hash_parent_base, $hash_base,
6218 "--", (defined $file_parent ?
$file_parent : ()), $file_name
6219 or die_error
(500, "Open git-diff-tree failed");
6222 # old/legacy style URI -- not generated anymore since 1.4.3.
6224 die_error
('404 Not Found', "Missing one of the blob diff parameters")
6228 if ($format eq 'html') {
6230 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
6232 git_header_html
(undef, $expires);
6233 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6234 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6235 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6237 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
6238 print "<div class=\"title\">$hash vs $hash_parent</div>\n";
6240 if (defined $file_name) {
6241 git_print_page_path
($file_name, "blob", $hash_base);
6243 print "<div class=\"page_path\"></div>\n";
6246 } elsif ($format eq 'plain') {
6248 -type
=> 'text/plain',
6249 -charset
=> 'utf-8',
6250 -expires
=> $expires,
6251 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
6253 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6256 die_error
(400, "Unknown blobdiff format");
6260 if ($format eq 'html') {
6261 print "<div class=\"page_body\">\n";
6263 git_patchset_body
($fd, [ \
%diffinfo ], $hash_base, $hash_parent_base);
6266 print "</div>\n"; # class="page_body"
6270 while (my $line = <$fd>) {
6271 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
6272 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
6276 last if $line =~ m!^\+\+\+!;
6284 sub git_blobdiff_plain
{
6285 git_blobdiff
('plain');
6288 sub git_commitdiff
{
6290 my $format = $params{-format
} || 'html';
6292 my ($patch_max) = gitweb_get_feature
('patches');
6293 if ($format eq 'patch') {
6294 die_error
(403, "Patch view not allowed") unless $patch_max;
6297 $hash ||= $hash_base || "HEAD";
6298 my %co = parse_commit
($hash)
6299 or die_error
(404, "Unknown commit object");
6301 # choose format for commitdiff for merge
6302 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
6303 $hash_parent = '--cc';
6305 # we need to prepare $formats_nav before almost any parameter munging
6307 if ($format eq 'html') {
6309 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
6311 if ($patch_max && @
{$co{'parents'}} <= 1) {
6312 $formats_nav .= " | " .
6313 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6317 if (defined $hash_parent &&
6318 $hash_parent ne '-c' && $hash_parent ne '--cc') {
6319 # commitdiff with two commits given
6320 my $hash_parent_short = $hash_parent;
6321 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
6322 $hash_parent_short = substr($hash_parent, 0, 7);
6326 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
6327 if ($co{'parents'}[$i] eq $hash_parent) {
6328 $formats_nav .= ' parent ' . ($i+1);
6332 $formats_nav .= ': ' .
6333 $cgi->a({-href
=> href
(action
=>"commitdiff",
6334 hash
=>$hash_parent)},
6335 esc_html
($hash_parent_short)) .
6337 } elsif (!$co{'parent'}) {
6339 $formats_nav .= ' (initial)';
6340 } elsif (scalar @
{$co{'parents'}} == 1) {
6341 # single parent commit
6344 $cgi->a({-href
=> href
(action
=>"commitdiff",
6345 hash
=>$co{'parent'})},
6346 esc_html
(substr($co{'parent'}, 0, 7))) .
6350 if ($hash_parent eq '--cc') {
6351 $formats_nav .= ' | ' .
6352 $cgi->a({-href
=> href
(action
=>"commitdiff",
6353 hash
=>$hash, hash_parent
=>'-c')},
6355 } else { # $hash_parent eq '-c'
6356 $formats_nav .= ' | ' .
6357 $cgi->a({-href
=> href
(action
=>"commitdiff",
6358 hash
=>$hash, hash_parent
=>'--cc')},
6364 $cgi->a({-href
=> href
(action
=>"commitdiff",
6366 esc_html
(substr($_, 0, 7)));
6367 } @
{$co{'parents'}} ) .
6372 my $hash_parent_param = $hash_parent;
6373 if (!defined $hash_parent_param) {
6374 # --cc for multiple parents, --root for parentless
6375 $hash_parent_param =
6376 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
6382 if ($format eq 'html') {
6383 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6384 "--no-commit-id", "--patch-with-raw", "--full-index",
6385 $hash_parent_param, $hash, "--"
6386 or die_error
(500, "Open git-diff-tree failed");
6388 while (my $line = <$fd>) {
6390 # empty line ends raw part of diff-tree output
6392 push @difftree, scalar parse_difftree_raw_line
($line);
6395 } elsif ($format eq 'plain') {
6396 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6397 '-p', $hash_parent_param, $hash, "--"
6398 or die_error
(500, "Open git-diff-tree failed");
6399 } elsif ($format eq 'patch') {
6400 # For commit ranges, we limit the output to the number of
6401 # patches specified in the 'patches' feature.
6402 # For single commits, we limit the output to a single patch,
6403 # diverging from the git-format-patch default.
6404 my @commit_spec = ();
6406 if ($patch_max > 0) {
6407 push @commit_spec, "-$patch_max";
6409 push @commit_spec, '-n', "$hash_parent..$hash";
6411 if ($params{-single
}) {
6412 push @commit_spec, '-1';
6414 if ($patch_max > 0) {
6415 push @commit_spec, "-$patch_max";
6417 push @commit_spec, "-n";
6419 push @commit_spec, '--root', $hash;
6421 open $fd, "-|", git_cmd
(), "format-patch", @diff_opts,
6422 '--encoding=utf8', '--stdout', @commit_spec
6423 or die_error
(500, "Open git-format-patch failed");
6425 die_error
(400, "Unknown commitdiff format");
6428 # non-textual hash id's can be cached
6430 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6434 # write commit message
6435 if ($format eq 'html') {
6436 my $refs = git_get_references
();
6437 my $ref = format_ref_marker
($refs, $co{'id'});
6439 git_header_html
(undef, $expires);
6440 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
6441 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
6442 print "<div class=\"title_text\">\n" .
6443 "<table class=\"object_header\">\n";
6444 git_print_authorship_rows
(\
%co);
6447 print "<div class=\"page_body\">\n";
6448 if (@
{$co{'comment'}} > 1) {
6449 print "<div class=\"log\">\n";
6450 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
6451 print "</div>\n"; # class="log"
6454 } elsif ($format eq 'plain') {
6455 my $refs = git_get_references
("tags");
6456 my $tagname = git_get_rev_name_tags
($hash);
6457 my $filename = basename
($project) . "-$hash.patch";
6460 -type
=> 'text/plain',
6461 -charset
=> 'utf-8',
6462 -expires
=> $expires,
6463 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
6464 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
6465 print "From: " . to_utf8
($co{'author'}) . "\n";
6466 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
6467 print "Subject: " . to_utf8
($co{'title'}) . "\n";
6469 print "X-Git-Tag: $tagname\n" if $tagname;
6470 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6472 foreach my $line (@
{$co{'comment'}}) {
6473 print to_utf8
($line) . "\n";
6476 } elsif ($format eq 'patch') {
6477 my $filename = basename
($project) . "-$hash.patch";
6480 -type
=> 'text/plain',
6481 -charset
=> 'utf-8',
6482 -expires
=> $expires,
6483 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
6487 if ($format eq 'html') {
6488 my $use_parents = !defined $hash_parent ||
6489 $hash_parent eq '-c' || $hash_parent eq '--cc';
6490 git_difftree_body
(\
@difftree, $hash,
6491 $use_parents ? @
{$co{'parents'}} : $hash_parent);
6494 git_patchset_body
($fd, \
@difftree, $hash,
6495 $use_parents ? @
{$co{'parents'}} : $hash_parent);
6497 print "</div>\n"; # class="page_body"
6500 } elsif ($format eq 'plain') {
6504 or print "Reading git-diff-tree failed\n";
6505 } elsif ($format eq 'patch') {
6509 or print "Reading git-format-patch failed\n";
6513 sub git_commitdiff_plain
{
6514 git_commitdiff
(-format
=> 'plain');
6517 # format-patch-style patches
6519 git_commitdiff
(-format
=> 'patch', -single
=> 1);
6523 git_commitdiff
(-format
=> 'patch');
6527 git_log_generic
('history', \
&git_history_body
,
6528 $hash_base, $hash_parent_base,
6533 gitweb_check_feature
('search') or die_error
(403, "Search is disabled");
6534 if (!defined $searchtext) {
6535 die_error
(400, "Text field is empty");
6537 if (!defined $hash) {
6538 $hash = git_get_head_hash
($project);
6540 my %co = parse_commit
($hash);
6542 die_error
(404, "Unknown commit object");
6544 if (!defined $page) {
6548 $searchtype ||= 'commit';
6549 if ($searchtype eq 'pickaxe') {
6550 # pickaxe may take all resources of your box and run for several minutes
6551 # with every query - so decide by yourself how public you make this feature
6552 gitweb_check_feature
('pickaxe')
6553 or die_error
(403, "Pickaxe is disabled");
6555 if ($searchtype eq 'grep') {
6556 gitweb_check_feature
('grep')
6557 or die_error
(403, "Grep is disabled");
6562 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
6564 if ($searchtype eq 'commit') {
6565 $greptype = "--grep=";
6566 } elsif ($searchtype eq 'author') {
6567 $greptype = "--author=";
6568 } elsif ($searchtype eq 'committer') {
6569 $greptype = "--committer=";
6571 $greptype .= $searchtext;
6572 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
6573 $greptype, '--regexp-ignore-case',
6574 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
6576 my $paging_nav = '';
6579 $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
6580 searchtext
=>$searchtext,
6581 searchtype
=>$searchtype)},
6583 $paging_nav .= " ⋅ " .
6584 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
6585 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
6587 $paging_nav .= "first";
6588 $paging_nav .= " ⋅ prev";
6591 if ($#commitlist >= 100) {
6593 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6594 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
6595 $paging_nav .= " ⋅ $next_link";
6597 $paging_nav .= " ⋅ next";
6600 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
6601 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6602 if ($page == 0 && !@commitlist) {
6603 print "<p>No match.</p>\n";
6605 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
6609 if ($searchtype eq 'pickaxe') {
6610 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
6611 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6613 print "<table class=\"pickaxe search\">\n";
6616 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
6617 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
6618 ($search_use_regexp ?
'--pickaxe-regex' : ());
6621 while (my $line = <$fd>) {
6625 my %set = parse_difftree_raw_line
($line);
6626 if (defined $set{'commit'}) {
6627 # finish previous commit
6630 "<td class=\"link\">" .
6631 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
6633 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
6639 print "<tr class=\"dark\">\n";
6641 print "<tr class=\"light\">\n";
6644 %co = parse_commit
($set{'commit'});
6645 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
6646 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
6647 "<td><i>$author</i></td>\n" .
6649 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
6650 -class => "list subject"},
6651 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
6652 } elsif (defined $set{'to_id'}) {
6653 next if ($set{'to_id'} =~ m/^0{40}$/);
6655 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
6656 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
6658 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
6664 # finish last commit (warning: repetition!)
6667 "<td class=\"link\">" .
6668 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
6670 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
6678 if ($searchtype eq 'grep') {
6679 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
6680 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6682 print "<table class=\"grep_search\">\n";
6686 open my $fd, "-|", git_cmd
(), 'grep', '-n',
6687 $search_use_regexp ?
('-E', '-i') : '-F',
6688 $searchtext, $co{'tree'};
6690 while (my $line = <$fd>) {
6692 my ($file, $lno, $ltext, $binary);
6693 last if ($matches++ > 1000);
6694 if ($line =~ /^Binary file (.+) matches$/) {
6698 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
6700 if ($file ne $lastfile) {
6701 $lastfile and print "</td></tr>\n";
6703 print "<tr class=\"dark\">\n";
6705 print "<tr class=\"light\">\n";
6707 print "<td class=\"list\">".
6708 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
6709 file_name
=>"$file"),
6710 -class => "list"}, esc_path
($file));
6711 print "</td><td>\n";
6715 print "<div class=\"binary\">Binary file</div>\n";
6717 $ltext = untabify
($ltext);
6718 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
6719 $ltext = esc_html
($1, -nbsp
=>1);
6720 $ltext .= '<span class="match">';
6721 $ltext .= esc_html
($2, -nbsp
=>1);
6722 $ltext .= '</span>';
6723 $ltext .= esc_html
($3, -nbsp
=>1);
6725 $ltext = esc_html
($ltext, -nbsp
=>1);
6727 print "<div class=\"pre\">" .
6728 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
6729 file_name
=>"$file").'#l'.$lno,
6730 -class => "linenr"}, sprintf('%4i', $lno))
6731 . ' ' . $ltext . "</div>\n";
6735 print "</td></tr>\n";
6736 if ($matches > 1000) {
6737 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
6740 print "<div class=\"diff nodifferences\">No matches found</div>\n";
6749 sub git_search_help
{
6751 git_print_page_nav
('','', $hash,$hash,$hash);
6753 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
6754 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
6755 the pattern entered is recognized as the POSIX extended
6756 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
6759 <dt><b>commit</b></dt>
6760 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
6762 my $have_grep = gitweb_check_feature
('grep');
6765 <dt><b>grep</b></dt>
6766 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
6767 a different one) are searched for the given pattern. On large trees, this search can take
6768 a while and put some strain on the server, so please use it with some consideration. Note that
6769 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
6770 case-sensitive.</dd>
6774 <dt><b>author</b></dt>
6775 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
6776 <dt><b>committer</b></dt>
6777 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
6779 my $have_pickaxe = gitweb_check_feature
('pickaxe');
6780 if ($have_pickaxe) {
6782 <dt><b>pickaxe</b></dt>
6783 <dd>All commits that caused the string to appear or disappear from any file (changes that
6784 added, removed or "modified" the string) will be listed. This search can take a while and
6785 takes a lot of strain on the server, so please use it wisely. Note that since you may be
6786 interested even in changes just changing the case as well, this search is case sensitive.</dd>
6794 git_log_generic
('shortlog', \
&git_shortlog_body
,
6795 $hash, $hash_parent);
6798 ## ......................................................................
6799 ## feeds (RSS, Atom; OPML)
6802 my $format = shift || 'atom';
6803 my $have_blame = gitweb_check_feature
('blame');
6805 # Atom: http://www.atomenabled.org/developers/syndication/
6806 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
6807 if ($format ne 'rss' && $format ne 'atom') {
6808 die_error
(400, "Unknown web feed format");
6811 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
6812 my $head = $hash || 'HEAD';
6813 my @commitlist = parse_commits
($head, 150, 0, $file_name);
6817 my $content_type = "application/$format+xml";
6818 if (defined $cgi->http('HTTP_ACCEPT') &&
6819 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
6820 # browser (feed reader) prefers text/xml
6821 $content_type = 'text/xml';
6823 if (defined($commitlist[0])) {
6824 %latest_commit = %{$commitlist[0]};
6825 my $latest_epoch = $latest_commit{'committer_epoch'};
6826 %latest_date = parse_date
($latest_epoch);
6827 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
6828 if (defined $if_modified) {
6830 if (eval { require HTTP
::Date
; 1; }) {
6831 $since = HTTP
::Date
::str2time
($if_modified);
6832 } elsif (eval { require Time
::ParseDate
; 1; }) {
6833 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
6835 if (defined $since && $latest_epoch <= $since) {
6837 -type
=> $content_type,
6838 -charset
=> 'utf-8',
6839 -last_modified
=> $latest_date{'rfc2822'},
6840 -status
=> '304 Not Modified');
6845 -type
=> $content_type,
6846 -charset
=> 'utf-8',
6847 -last_modified
=> $latest_date{'rfc2822'});
6850 -type
=> $content_type,
6851 -charset
=> 'utf-8');
6854 # Optimization: skip generating the body if client asks only
6855 # for Last-Modified date.
6856 return if ($cgi->request_method() eq 'HEAD');
6859 my $title = "$site_name - $project/$action";
6860 my $feed_type = 'log';
6861 if (defined $hash) {
6862 $title .= " - '$hash'";
6863 $feed_type = 'branch log';
6864 if (defined $file_name) {
6865 $title .= " :: $file_name";
6866 $feed_type = 'history';
6868 } elsif (defined $file_name) {
6869 $title .= " - $file_name";
6870 $feed_type = 'history';
6872 $title .= " $feed_type";
6873 my $descr = git_get_project_description
($project);
6874 if (defined $descr) {
6875 $descr = esc_html
($descr);
6877 $descr = "$project " .
6878 ($format eq 'rss' ?
'RSS' : 'Atom') .
6881 my $owner = git_get_project_owner
($project);
6882 $owner = esc_html
($owner);
6886 if (defined $file_name) {
6887 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
6888 } elsif (defined $hash) {
6889 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
6891 $alt_url = href
(-full
=>1, action
=>"summary");
6893 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
6894 if ($format eq 'rss') {
6896 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
6899 print "<title>$title</title>\n" .
6900 "<link>$alt_url</link>\n" .
6901 "<description>$descr</description>\n" .
6902 "<language>en</language>\n" .
6903 # project owner is responsible for 'editorial' content
6904 "<managingEditor>$owner</managingEditor>\n";
6905 if (defined $logo || defined $favicon) {
6906 # prefer the logo to the favicon, since RSS
6907 # doesn't allow both
6908 my $img = esc_url
($logo || $favicon);
6910 "<url>$img</url>\n" .
6911 "<title>$title</title>\n" .
6912 "<link>$alt_url</link>\n" .
6916 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
6917 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
6919 print "<generator>gitweb v.$version/$git_version</generator>\n";
6920 } elsif ($format eq 'atom') {
6922 <feed xmlns="http://www.w3.org/2005/Atom">
6924 print "<title>$title</title>\n" .
6925 "<subtitle>$descr</subtitle>\n" .
6926 '<link rel="alternate" type="text/html" href="' .
6927 $alt_url . '" />' . "\n" .
6928 '<link rel="self" type="' . $content_type . '" href="' .
6929 $cgi->self_url() . '" />' . "\n" .
6930 "<id>" . href
(-full
=>1) . "</id>\n" .
6931 # use project owner for feed author
6932 "<author><name>$owner</name></author>\n";
6933 if (defined $favicon) {
6934 print "<icon>" . esc_url
($favicon) . "</icon>\n";
6936 if (defined $logo_url) {
6937 # not twice as wide as tall: 72 x 27 pixels
6938 print "<logo>" . esc_url
($logo) . "</logo>\n";
6940 if (! %latest_date) {
6941 # dummy date to keep the feed valid until commits trickle in:
6942 print "<updated>1970-01-01T00:00:00Z</updated>\n";
6944 print "<updated>$latest_date{'iso-8601'}</updated>\n";
6946 print "<generator version='$version/$git_version'>gitweb</generator>\n";
6950 for (my $i = 0; $i <= $#commitlist; $i++) {
6951 my %co = %{$commitlist[$i]};
6952 my $commit = $co{'id'};
6953 # we read 150, we always show 30 and the ones more recent than 48 hours
6954 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
6957 my %cd = parse_date
($co{'author_epoch'});
6959 # get list of changed files
6960 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6961 $co{'parent'} || "--root",
6962 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
6964 my @difftree = map { chomp; $_ } <$fd>;
6968 # print element (entry, item)
6969 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
6970 if ($format eq 'rss') {
6972 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
6973 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
6974 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
6975 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
6976 "<link>$co_url</link>\n" .
6977 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
6978 "<content:encoded>" .
6980 } elsif ($format eq 'atom') {
6982 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
6983 "<updated>$cd{'iso-8601'}</updated>\n" .
6985 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
6986 if ($co{'author_email'}) {
6987 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
6989 print "</author>\n" .
6990 # use committer for contributor
6992 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
6993 if ($co{'committer_email'}) {
6994 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
6996 print "</contributor>\n" .
6997 "<published>$cd{'iso-8601'}</published>\n" .
6998 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
6999 "<id>$co_url</id>\n" .
7000 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
7001 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
7003 my $comment = $co{'comment'};
7005 foreach my $line (@
$comment) {
7006 $line = esc_html
($line);
7009 print "</pre><ul>\n";
7010 foreach my $difftree_line (@difftree) {
7011 my %difftree = parse_difftree_raw_line
($difftree_line);
7012 next if !$difftree{'from_id'};
7014 my $file = $difftree{'file'} || $difftree{'to_file'};
7018 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
7019 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
7020 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
7021 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
7022 -title
=> "diff"}, 'D');
7024 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
7025 file_name
=>$file, hash_base
=>$commit),
7026 -title
=> "blame"}, 'B');
7028 # if this is not a feed of a file history
7029 if (!defined $file_name || $file_name ne $file) {
7030 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
7031 file_name
=>$file, hash
=>$commit),
7032 -title
=> "history"}, 'H');
7034 $file = esc_path
($file);
7038 if ($format eq 'rss') {
7039 print "</ul>]]>\n" .
7040 "</content:encoded>\n" .
7042 } elsif ($format eq 'atom') {
7043 print "</ul>\n</div>\n" .
7050 if ($format eq 'rss') {
7051 print "</channel>\n</rss>\n";
7052 } elsif ($format eq 'atom') {
7066 my @list = git_get_projects_list
();
7069 -type
=> 'text/xml',
7070 -charset
=> 'utf-8',
7071 -content_disposition
=> 'inline; filename="opml.xml"');
7074 <?xml version="1.0" encoding="utf-8"?>
7075 <opml version="1.0">
7077 <title>$site_name OPML Export</title>
7080 <outline text="git RSS feeds">
7083 foreach my $pr (@list) {
7085 my $head = git_get_head_hash
($proj{'path'});
7086 if (!defined $head) {
7089 $git_dir = "$projectroot/$proj{'path'}";
7090 my %co = parse_commit
($head);
7095 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
7096 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
7097 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
7098 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";