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) {
3535 my $have_search = gitweb_check_feature
('search');
3536 if (defined $project && $have_search) {
3537 if (!defined $searchtext) {
3541 if (defined $hash_base) {
3542 $search_hash = $hash_base;
3543 } elsif (defined $hash) {
3544 $search_hash = $hash;
3546 $search_hash = "HEAD";
3548 my $action = $my_uri;
3549 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3550 if ($use_pathinfo) {
3551 $action .= "/".esc_url
($project);
3553 print $cgi->startform(-method
=> "get", -action
=> $action) .
3554 "<div class=\"search\">\n" .
3556 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3557 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3558 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3559 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3560 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3561 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3563 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
3564 "<span title=\"Extended regular expression\">" .
3565 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3566 -checked
=> $search_use_regexp) .
3569 $cgi->end_form() . "\n";
3573 sub git_footer_html
{
3574 my $feed_class = 'rss_logo';
3576 print "<div class=\"page_footer\">\n";
3577 if (defined $project) {
3578 my $descr = git_get_project_description
($project);
3579 if (defined $descr) {
3580 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3583 my %href_params = get_feed_info
();
3584 if (!%href_params) {
3585 $feed_class .= ' generic';
3587 $href_params{'-title'} ||= 'log';
3589 foreach my $format qw(RSS Atom) {
3590 $href_params{'action'} = lc($format);
3591 print $cgi->a({-href
=> href
(%href_params),
3592 -title
=> "$href_params{'-title'} $format feed",
3593 -class => $feed_class}, $format)."\n";
3597 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3598 -class => $feed_class}, "OPML") . " ";
3599 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3600 -class => $feed_class}, "TXT") . "\n";
3602 print "</div>\n"; # class="page_footer"
3604 if (defined $t0 && gitweb_check_feature
('timed')) {
3605 print "<div id=\"generating_info\">\n";
3606 print 'This page took '.
3607 '<span id="generating_time" class="time_span">'.
3608 Time
::HiRes
::tv_interval
($t0, [Time
::HiRes
::gettimeofday
()]).
3611 '<span id="generating_cmd">'.
3612 $number_of_git_cmds.
3613 '</span> git commands '.
3615 print "</div>\n"; # class="page_footer"
3618 if (defined $site_footer && -f
$site_footer) {
3619 insert_file
($site_footer);
3622 print qq!<script type
="text/javascript" src
="$javascript"></script
>\n!;
3623 if (defined $action &&
3624 $action eq 'blame_incremental') {
3625 print qq!<script type
="text/javascript">\n!.
3626 qq!startBlame
("!. href(action=>"blame_data
", -replay=>1) .qq!",\n!.
3627 qq! "!. href() .qq!");\n!.
3629 } elsif (gitweb_check_feature
('javascript-actions')) {
3630 print qq!<script type
="text/javascript">\n!.
3631 qq!window
.onload
= fixLinks
;\n!.
3639 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
3640 # Example: die_error(404, 'Hash not found')
3641 # By convention, use the following status codes (as defined in RFC 2616):
3642 # 400: Invalid or missing CGI parameters, or
3643 # requested object exists but has wrong type.
3644 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
3645 # this server or project.
3646 # 404: Requested object/revision/project doesn't exist.
3647 # 500: The server isn't configured properly, or
3648 # an internal error occurred (e.g. failed assertions caused by bugs), or
3649 # an unknown error occurred (e.g. the git binary died unexpectedly).
3650 # 503: The server is currently unavailable (because it is overloaded,
3651 # or down for maintenance). Generally, this is a temporary state.
3653 my $status = shift || 500;
3654 my $error = esc_html
(shift) || "Internal Server Error";
3658 my %http_responses = (
3659 400 => '400 Bad Request',
3660 403 => '403 Forbidden',
3661 404 => '404 Not Found',
3662 500 => '500 Internal Server Error',
3663 503 => '503 Service Unavailable',
3665 git_header_html
($http_responses{$status}, undef, %opts);
3667 <div class="page_body">
3672 if (defined $extra) {
3680 unless ($opts{'-error_handler'});
3683 ## ----------------------------------------------------------------------
3684 ## functions printing or outputting HTML: navigation
3686 sub git_print_page_nav
{
3687 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3688 $extra = '' if !defined $extra; # pager or formats
3690 my @navs = qw(summary shortlog log commit commitdiff tree);
3692 @navs = grep { $_ ne $suppress } @navs;
3695 my %arg = map { $_ => {action
=>$_} } @navs;
3696 if (defined $head) {
3697 for (qw(commit commitdiff)) {
3698 $arg{$_}{'hash'} = $head;
3700 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3701 for (qw(shortlog log)) {
3702 $arg{$_}{'hash'} = $head;
3707 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3708 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3710 my @actions = gitweb_get_feature
('actions');
3713 'n' => $project, # project name
3714 'f' => $git_dir, # project path within filesystem
3715 'h' => $treehead || '', # current hash ('h' parameter)
3716 'b' => $treebase || '', # hash base ('hb' parameter)
3719 my ($label, $link, $pos) = splice(@actions,0,3);
3721 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
3723 $link =~ s/%([%nfhb])/$repl{$1}/g;
3724 $arg{$label}{'_href'} = $link;
3727 print "<div class=\"page_nav\">\n" .
3729 map { $_ eq $current ?
3730 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
3732 print "<br/>\n$extra<br/>\n" .
3736 sub format_paging_nav
{
3737 my ($action, $page, $has_next_link) = @_;
3743 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)}, "first") .
3745 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
3746 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
3748 $paging_nav .= "first ⋅ prev";
3751 if ($has_next_link) {
3752 $paging_nav .= " ⋅ " .
3753 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
3754 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
3756 $paging_nav .= " ⋅ next";
3762 ## ......................................................................
3763 ## functions printing or outputting HTML: div
3765 sub git_print_header_div
{
3766 my ($action, $title, $hash, $hash_base) = @_;
3769 $args{'action'} = $action;
3770 $args{'hash'} = $hash if $hash;
3771 $args{'hash_base'} = $hash_base if $hash_base;
3773 print "<div class=\"header\">\n" .
3774 $cgi->a({-href
=> href
(%args), -class => "title"},
3775 $title ?
$title : $action) .
3779 sub print_local_time
{
3780 print format_local_time
(@_);
3783 sub format_local_time
{
3786 if ($date{'hour_local'} < 6) {
3787 $localtime .= sprintf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3788 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3790 $localtime .= sprintf(" (%02d:%02d %s)",
3791 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3797 # Outputs the author name and date in long form
3798 sub git_print_authorship
{
3801 my $tag = $opts{-tag
} || 'div';
3802 my $author = $co->{'author_name'};
3804 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
3805 print "<$tag class=\"author_date\">" .
3806 format_search_author
($author, "author", esc_html
($author)) .
3808 print_local_time
(%ad) if ($opts{-localtime});
3809 print "]" . git_get_avatar
($co->{'author_email'}, -pad_before
=> 1)
3813 # Outputs table rows containing the full author or committer information,
3814 # in the format expected for 'commit' view (& similar).
3815 # Parameters are a commit hash reference, followed by the list of people
3816 # to output information for. If the list is empty it defaults to both
3817 # author and committer.
3818 sub git_print_authorship_rows
{
3820 # too bad we can't use @people = @_ || ('author', 'committer')
3822 @people = ('author', 'committer') unless @people;
3823 foreach my $who (@people) {
3824 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
3825 print "<tr><td>$who</td><td>" .
3826 format_search_author
($co->{"${who}_name"}, $who,
3827 esc_html
($co->{"${who}_name"})) . " " .
3828 format_search_author
($co->{"${who}_email"}, $who,
3829 esc_html
("<" . $co->{"${who}_email"} . ">")) .
3830 "</td><td rowspan=\"2\">" .
3831 git_get_avatar
($co->{"${who}_email"}, -size
=> 'double') .
3834 "<td></td><td> $wd{'rfc2822'}";
3835 print_local_time
(%wd);
3841 sub git_print_page_path
{
3847 print "<div class=\"page_path\">";
3848 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
3849 -title
=> 'tree root'}, to_utf8
("[$project]"));
3851 if (defined $name) {
3852 my @dirname = split '/', $name;
3853 my $basename = pop @dirname;
3856 foreach my $dir (@dirname) {
3857 $fullname .= ($fullname ?
'/' : '') . $dir;
3858 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
3860 -title
=> $fullname}, esc_path
($dir));
3863 if (defined $type && $type eq 'blob') {
3864 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
3866 -title
=> $name}, esc_path
($basename));
3867 } elsif (defined $type && $type eq 'tree') {
3868 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
3870 -title
=> $name}, esc_path
($basename));
3873 print esc_path
($basename);
3876 print "<br/></div>\n";
3883 if ($opts{'-remove_title'}) {
3884 # remove title, i.e. first line of log
3887 # remove leading empty lines
3888 while (defined $log->[0] && $log->[0] eq "") {
3895 foreach my $line (@
$log) {
3896 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3899 if (! $opts{'-remove_signoff'}) {
3900 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
3903 # remove signoff lines
3910 # print only one empty line
3911 # do not print empty line after signoff
3913 next if ($empty || $signoff);
3919 print format_log_line_html
($line) . "<br/>\n";
3922 if ($opts{'-final_empty_line'}) {
3923 # end with single empty line
3924 print "<br/>\n" unless $empty;
3928 # return link target (what link points to)
3929 sub git_get_link_target
{
3934 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
3938 $link_target = <$fd>;
3943 return $link_target;
3946 # given link target, and the directory (basedir) the link is in,
3947 # return target of link relative to top directory (top tree);
3948 # return undef if it is not possible (including absolute links).
3949 sub normalize_link_target
{
3950 my ($link_target, $basedir) = @_;
3952 # absolute symlinks (beginning with '/') cannot be normalized
3953 return if (substr($link_target, 0, 1) eq '/');
3955 # normalize link target to path from top (root) tree (dir)
3958 $path = $basedir . '/' . $link_target;
3960 # we are in top (root) tree (dir)
3961 $path = $link_target;
3964 # remove //, /./, and /../
3966 foreach my $part (split('/', $path)) {
3967 # discard '.' and ''
3968 next if (!$part || $part eq '.');
3970 if ($part eq '..') {
3974 # link leads outside repository (outside top dir)
3978 push @path_parts, $part;
3981 $path = join('/', @path_parts);
3986 # print tree entry (row of git_tree), but without encompassing <tr> element
3987 sub git_print_tree_entry
{
3988 my ($t, $basedir, $hash_base, $have_blame) = @_;
3991 $base_key{'hash_base'} = $hash_base if defined $hash_base;
3993 # The format of a table row is: mode list link. Where mode is
3994 # the mode of the entry, list is the name of the entry, an href,
3995 # and link is the action links of the entry.
3997 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
3998 if (exists $t->{'size'}) {
3999 print "<td class=\"size\">$t->{'size'}</td>\n";
4001 if ($t->{'type'} eq "blob") {
4002 print "<td class=\"list\">" .
4003 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4004 file_name
=>"$basedir$t->{'name'}", %base_key),
4005 -class => "list"}, esc_path
($t->{'name'}));
4006 if (S_ISLNK
(oct $t->{'mode'})) {
4007 my $link_target = git_get_link_target
($t->{'hash'});
4009 my $norm_target = normalize_link_target
($link_target, $basedir);
4010 if (defined $norm_target) {
4012 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
4013 file_name
=>$norm_target),
4014 -title
=> $norm_target}, esc_path
($link_target));
4016 print " -> " . esc_path
($link_target);
4021 print "<td class=\"link\">";
4022 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4023 file_name
=>"$basedir$t->{'name'}", %base_key)},
4027 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
4028 file_name
=>"$basedir$t->{'name'}", %base_key)},
4031 if (defined $hash_base) {
4033 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4034 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
4038 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
4039 file_name
=>"$basedir$t->{'name'}")},
4043 } elsif ($t->{'type'} eq "tree") {
4044 print "<td class=\"list\">";
4045 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4046 file_name
=>"$basedir$t->{'name'}",
4048 esc_path
($t->{'name'}));
4050 print "<td class=\"link\">";
4051 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4052 file_name
=>"$basedir$t->{'name'}",
4055 if (defined $hash_base) {
4057 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4058 file_name
=>"$basedir$t->{'name'}")},
4063 # unknown object: we can only present history for it
4064 # (this includes 'commit' object, i.e. submodule support)
4065 print "<td class=\"list\">" .
4066 esc_path
($t->{'name'}) .
4068 print "<td class=\"link\">";
4069 if (defined $hash_base) {
4070 print $cgi->a({-href
=> href
(action
=>"history",
4071 hash_base
=>$hash_base,
4072 file_name
=>"$basedir$t->{'name'}")},
4079 ## ......................................................................
4080 ## functions printing large fragments of HTML
4082 # get pre-image filenames for merge (combined) diff
4083 sub fill_from_file_info
{
4084 my ($diff, @parents) = @_;
4086 $diff->{'from_file'} = [ ];
4087 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4088 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4089 if ($diff->{'status'}[$i] eq 'R' ||
4090 $diff->{'status'}[$i] eq 'C') {
4091 $diff->{'from_file'}[$i] =
4092 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
4099 # is current raw difftree line of file deletion
4101 my $diffinfo = shift;
4103 return $diffinfo->{'to_id'} eq ('0' x
40);
4106 # does patch correspond to [previous] difftree raw line
4107 # $diffinfo - hashref of parsed raw diff format
4108 # $patchinfo - hashref of parsed patch diff format
4109 # (the same keys as in $diffinfo)
4110 sub is_patch_split
{
4111 my ($diffinfo, $patchinfo) = @_;
4113 return defined $diffinfo && defined $patchinfo
4114 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4118 sub git_difftree_body
{
4119 my ($difftree, $hash, @parents) = @_;
4120 my ($parent) = $parents[0];
4121 my $have_blame = gitweb_check_feature
('blame');
4122 print "<div class=\"list_head\">\n";
4123 if ($#{$difftree} > 10) {
4124 print(($#{$difftree} + 1) . " files changed:\n");
4128 print "<table class=\"" .
4129 (@parents > 1 ?
"combined " : "") .
4132 # header only for combined diff in 'commitdiff' view
4133 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
4136 print "<thead><tr>\n" .
4137 "<th></th><th></th>\n"; # filename, patchN link
4138 for (my $i = 0; $i < @parents; $i++) {
4139 my $par = $parents[$i];
4141 $cgi->a({-href
=> href
(action
=>"commitdiff",
4142 hash
=>$hash, hash_parent
=>$par),
4143 -title
=> 'commitdiff to parent number ' .
4144 ($i+1) . ': ' . substr($par,0,7)},
4148 print "</tr></thead>\n<tbody>\n";
4153 foreach my $line (@
{$difftree}) {
4154 my $diff = parsed_difftree_line
($line);
4157 print "<tr class=\"dark\">\n";
4159 print "<tr class=\"light\">\n";
4163 if (exists $diff->{'nparents'}) { # combined diff
4165 fill_from_file_info
($diff, @parents)
4166 unless exists $diff->{'from_file'};
4168 if (!is_deleted
($diff)) {
4169 # file exists in the result (child) commit
4171 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4172 file_name
=>$diff->{'to_file'},
4174 -class => "list"}, esc_path
($diff->{'to_file'})) .
4178 esc_path
($diff->{'to_file'}) .
4182 if ($action eq 'commitdiff') {
4185 print "<td class=\"link\">" .
4186 $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4191 my $has_history = 0;
4192 my $not_deleted = 0;
4193 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4194 my $hash_parent = $parents[$i];
4195 my $from_hash = $diff->{'from_id'}[$i];
4196 my $from_path = $diff->{'from_file'}[$i];
4197 my $status = $diff->{'status'}[$i];
4199 $has_history ||= ($status ne 'A');
4200 $not_deleted ||= ($status ne 'D');
4202 if ($status eq 'A') {
4203 print "<td class=\"link\" align=\"right\"> | </td>\n";
4204 } elsif ($status eq 'D') {
4205 print "<td class=\"link\">" .
4206 $cgi->a({-href
=> href
(action
=>"blob",
4209 file_name
=>$from_path)},
4213 if ($diff->{'to_id'} eq $from_hash) {
4214 print "<td class=\"link nochange\">";
4216 print "<td class=\"link\">";
4218 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4219 hash
=>$diff->{'to_id'},
4220 hash_parent
=>$from_hash,
4222 hash_parent_base
=>$hash_parent,
4223 file_name
=>$diff->{'to_file'},
4224 file_parent
=>$from_path)},
4230 print "<td class=\"link\">";
4232 print $cgi->a({-href
=> href
(action
=>"blob",
4233 hash
=>$diff->{'to_id'},
4234 file_name
=>$diff->{'to_file'},
4237 print " | " if ($has_history);
4240 print $cgi->a({-href
=> href
(action
=>"history",
4241 file_name
=>$diff->{'to_file'},
4248 next; # instead of 'else' clause, to avoid extra indent
4250 # else ordinary diff
4252 my ($to_mode_oct, $to_mode_str, $to_file_type);
4253 my ($from_mode_oct, $from_mode_str, $from_file_type);
4254 if ($diff->{'to_mode'} ne ('0' x
6)) {
4255 $to_mode_oct = oct $diff->{'to_mode'};
4256 if (S_ISREG
($to_mode_oct)) { # only for regular file
4257 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4259 $to_file_type = file_type
($diff->{'to_mode'});
4261 if ($diff->{'from_mode'} ne ('0' x
6)) {
4262 $from_mode_oct = oct $diff->{'from_mode'};
4263 if (S_ISREG
($to_mode_oct)) { # only for regular file
4264 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4266 $from_file_type = file_type
($diff->{'from_mode'});
4269 if ($diff->{'status'} eq "A") { # created
4270 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4271 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4272 $mode_chng .= "]</span>";
4274 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4275 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4276 -class => "list"}, esc_path
($diff->{'file'}));
4278 print "<td>$mode_chng</td>\n";
4279 print "<td class=\"link\">";
4280 if ($action eq 'commitdiff') {
4283 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
4286 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4287 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4291 } elsif ($diff->{'status'} eq "D") { # deleted
4292 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4294 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4295 hash_base
=>$parent, file_name
=>$diff->{'file'}),
4296 -class => "list"}, esc_path
($diff->{'file'}));
4298 print "<td>$mode_chng</td>\n";
4299 print "<td class=\"link\">";
4300 if ($action eq 'commitdiff') {
4303 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
4306 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4307 hash_base
=>$parent, file_name
=>$diff->{'file'})},
4310 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
4311 file_name
=>$diff->{'file'})},
4314 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
4315 file_name
=>$diff->{'file'})},
4319 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4320 my $mode_chnge = "";
4321 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4322 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4323 if ($from_file_type ne $to_file_type) {
4324 $mode_chnge .= " from $from_file_type to $to_file_type";
4326 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4327 if ($from_mode_str && $to_mode_str) {
4328 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4329 } elsif ($to_mode_str) {
4330 $mode_chnge .= " mode: $to_mode_str";
4333 $mode_chnge .= "]</span>\n";
4336 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4337 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4338 -class => "list"}, esc_path
($diff->{'file'}));
4340 print "<td>$mode_chnge</td>\n";
4341 print "<td class=\"link\">";
4342 if ($action eq 'commitdiff') {
4345 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4347 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4348 # "commit" view and modified file (not onlu mode changed)
4349 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4350 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4351 hash_base
=>$hash, hash_parent_base
=>$parent,
4352 file_name
=>$diff->{'file'})},
4356 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4357 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4360 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4361 file_name
=>$diff->{'file'})},
4364 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4365 file_name
=>$diff->{'file'})},
4369 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4370 my %status_name = ('R' => 'moved', 'C' => 'copied');
4371 my $nstatus = $status_name{$diff->{'status'}};
4373 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4374 # mode also for directories, so we cannot use $to_mode_str
4375 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4378 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
4379 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
4380 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
4381 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4382 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
4383 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
4384 -class => "list"}, esc_path
($diff->{'from_file'})) .
4385 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4386 "<td class=\"link\">";
4387 if ($action eq 'commitdiff') {
4390 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4392 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4393 # "commit" view and modified file (not only pure rename or copy)
4394 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4395 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4396 hash_base
=>$hash, hash_parent_base
=>$parent,
4397 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
4401 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4402 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
4405 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4406 file_name
=>$diff->{'to_file'})},
4409 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4410 file_name
=>$diff->{'to_file'})},
4414 } # we should not encounter Unmerged (U) or Unknown (X) status
4417 print "</tbody>" if $has_header;
4421 sub git_patchset_body
{
4422 my ($fd, $difftree, $hash, @hash_parents) = @_;
4423 my ($hash_parent) = $hash_parents[0];
4425 my $is_combined = (@hash_parents > 1);
4427 my $patch_number = 0;
4433 print "<div class=\"patchset\">\n";
4435 # skip to first patch
4436 while ($patch_line = <$fd>) {
4439 last if ($patch_line =~ m/^diff /);
4443 while ($patch_line) {
4445 # parse "git diff" header line
4446 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
4447 # $1 is from_name, which we do not use
4448 $to_name = unquote
($2);
4449 $to_name =~ s!^b/!!;
4450 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
4451 # $1 is 'cc' or 'combined', which we do not use
4452 $to_name = unquote
($2);
4457 # check if current patch belong to current raw line
4458 # and parse raw git-diff line if needed
4459 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
4460 # this is continuation of a split patch
4461 print "<div class=\"patch cont\">\n";
4463 # advance raw git-diff output if needed
4464 $patch_idx++ if defined $diffinfo;
4466 # read and prepare patch information
4467 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4469 # compact combined diff output can have some patches skipped
4470 # find which patch (using pathname of result) we are at now;
4472 while ($to_name ne $diffinfo->{'to_file'}) {
4473 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4474 format_diff_cc_simplified
($diffinfo, @hash_parents) .
4475 "</div>\n"; # class="patch"
4480 last if $patch_idx > $#$difftree;
4481 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4485 # modifies %from, %to hashes
4486 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
4488 # this is first patch for raw difftree line with $patch_idx index
4489 # we index @$difftree array from 0, but number patches from 1
4490 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
4494 #assert($patch_line =~ m/^diff /) if DEBUG;
4495 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
4497 # print "git diff" header
4498 print format_git_diff_header_line
($patch_line, $diffinfo,
4501 # print extended diff header
4502 print "<div class=\"diff extended_header\">\n";
4504 while ($patch_line = <$fd>) {
4507 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
4509 print format_extended_diff_header_line
($patch_line, $diffinfo,
4512 print "</div>\n"; # class="diff extended_header"
4514 # from-file/to-file diff header
4515 if (! $patch_line) {
4516 print "</div>\n"; # class="patch"
4519 next PATCH
if ($patch_line =~ m/^diff /);
4520 #assert($patch_line =~ m/^---/) if DEBUG;
4522 my $last_patch_line = $patch_line;
4523 $patch_line = <$fd>;
4525 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
4527 print format_diff_from_to_header
($last_patch_line, $patch_line,
4528 $diffinfo, \
%from, \
%to,
4533 while ($patch_line = <$fd>) {
4536 next PATCH
if ($patch_line =~ m/^diff /);
4538 print format_diff_line
($patch_line, \
%from, \
%to);
4542 print "</div>\n"; # class="patch"
4545 # for compact combined (--cc) format, with chunk and patch simplification
4546 # the patchset might be empty, but there might be unprocessed raw lines
4547 for (++$patch_idx if $patch_number > 0;
4548 $patch_idx < @
$difftree;
4550 # read and prepare patch information
4551 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4553 # generate anchor for "patch" links in difftree / whatchanged part
4554 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4555 format_diff_cc_simplified
($diffinfo, @hash_parents) .
4556 "</div>\n"; # class="patch"
4561 if ($patch_number == 0) {
4562 if (@hash_parents > 1) {
4563 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
4565 print "<div class=\"diff nodifferences\">No differences found</div>\n";
4569 print "</div>\n"; # class="patchset"
4572 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4574 # fills project list info (age, description, owner, forks) for each
4575 # project in the list, removing invalid projects from returned list
4576 # NOTE: modifies $projlist, but does not remove entries from it
4577 sub fill_project_list_info
{
4578 my ($projlist, $check_forks) = @_;
4581 my $show_ctags = gitweb_check_feature
('ctags');
4583 foreach my $pr (@
$projlist) {
4584 my (@activity) = git_get_last_activity
($pr->{'path'});
4585 unless (@activity) {
4588 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
4589 if (!defined $pr->{'descr'}) {
4590 my $descr = git_get_project_description
($pr->{'path'}) || "";
4591 $descr = to_utf8
($descr);
4592 $pr->{'descr_long'} = $descr;
4593 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
4595 if (!defined $pr->{'owner'}) {
4596 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
4599 my $pname = $pr->{'path'};
4600 if (($pname =~ s/\.git$//) &&
4601 ($pname !~ /\/$/) &&
4602 (-d
"$projectroot/$pname")) {
4603 $pr->{'forks'} = "-d $projectroot/$pname";
4608 $show_ctags and $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
4609 push @projects, $pr;
4615 # print 'sort by' <th> element, generating 'sort by $name' replay link
4616 # if that order is not selected
4618 print format_sort_th
(@_);
4621 sub format_sort_th
{
4622 my ($name, $order, $header) = @_;
4624 $header ||= ucfirst($name);
4626 if ($order eq $name) {
4627 $sort_th .= "<th>$header</th>\n";
4629 $sort_th .= "<th>" .
4630 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
4631 -class => "header"}, $header) .
4638 sub git_project_list_body
{
4639 # actually uses global variable $project
4640 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
4642 my $check_forks = gitweb_check_feature
('forks');
4643 my @projects = fill_project_list_info
($projlist, $check_forks);
4645 $order ||= $default_projects_order;
4646 $from = 0 unless defined $from;
4647 $to = $#projects if (!defined $to || $#projects < $to);
4650 project
=> { key
=> 'path', type
=> 'str' },
4651 descr
=> { key
=> 'descr_long', type
=> 'str' },
4652 owner
=> { key
=> 'owner', type
=> 'str' },
4653 age
=> { key
=> 'age', type
=> 'num' }
4655 my $oi = $order_info{$order};
4656 if ($oi->{'type'} eq 'str') {
4657 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
4659 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
4662 my $show_ctags = gitweb_check_feature
('ctags');
4665 foreach my $p (@projects) {
4666 foreach my $ct (keys %{$p->{'ctags'}}) {
4667 $ctags{$ct} += $p->{'ctags'}->{$ct};
4670 my $cloud = git_populate_project_tagcloud
(\
%ctags);
4671 print git_show_project_tagcloud
($cloud, 64);
4674 print "<table class=\"project_list\">\n";
4675 unless ($no_header) {
4678 print "<th></th>\n";
4680 print_sort_th
('project', $order, 'Project');
4681 print_sort_th
('descr', $order, 'Description');
4682 print_sort_th
('owner', $order, 'Owner');
4683 print_sort_th
('age', $order, 'Last Change');
4684 print "<th></th>\n" . # for links
4688 my $tagfilter = $cgi->param('by_tag');
4689 for (my $i = $from; $i <= $to; $i++) {
4690 my $pr = $projects[$i];
4692 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
4693 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
4694 and not $pr->{'descr_long'} =~ /$searchtext/;
4695 # Weed out forks or non-matching entries of search
4697 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s
#\.git$#/#;
4698 $forkbase="^$forkbase" if $forkbase;
4699 next if not $searchtext and not $tagfilter and $show_ctags
4700 and $pr->{'path'} =~ m
#$forkbase.*/.*#; # regexp-safe
4704 print "<tr class=\"dark\">\n";
4706 print "<tr class=\"light\">\n";
4711 if ($pr->{'forks'}) {
4712 print "<!-- $pr->{'forks'} -->\n";
4713 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "+");
4717 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4718 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
4719 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4720 -class => "list", -title
=> $pr->{'descr_long'}},
4721 esc_html
($pr->{'descr'})) . "</td>\n" .
4722 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
4723 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
4724 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
4725 "<td class=\"link\">" .
4726 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
4727 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
4728 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
4729 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
4730 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
4734 if (defined $extra) {
4737 print "<td></td>\n";
4739 print "<td colspan=\"5\">$extra</td>\n" .
4746 # uses global variable $project
4747 my ($commitlist, $from, $to, $refs, $extra) = @_;
4749 $from = 0 unless defined $from;
4750 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4752 for (my $i = 0; $i <= $to; $i++) {
4753 my %co = %{$commitlist->[$i]};
4755 my $commit = $co{'id'};
4756 my $ref = format_ref_marker
($refs, $commit);
4757 my %ad = parse_date
($co{'author_epoch'});
4758 git_print_header_div
('commit',
4759 "<span class=\"age\">$co{'age_string'}</span>" .
4760 esc_html
($co{'title'}) . $ref,
4762 print "<div class=\"title_text\">\n" .
4763 "<div class=\"log_link\">\n" .
4764 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
4766 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
4768 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
4771 git_print_authorship
(\
%co, -tag
=> 'span');
4772 print "<br/>\n</div>\n";
4774 print "<div class=\"log_body\">\n";
4775 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
4779 print "<div class=\"page_nav\">\n";
4785 sub git_shortlog_body
{
4786 # uses global variable $project
4787 my ($commitlist, $from, $to, $refs, $extra) = @_;
4789 $from = 0 unless defined $from;
4790 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4792 print "<table class=\"shortlog\">\n";
4794 for (my $i = $from; $i <= $to; $i++) {
4795 my %co = %{$commitlist->[$i]};
4796 my $commit = $co{'id'};
4797 my $ref = format_ref_marker
($refs, $commit);
4799 print "<tr class=\"dark\">\n";
4801 print "<tr class=\"light\">\n";
4804 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4805 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4806 format_author_html
('td', \
%co, 10) . "<td>";
4807 print format_subject_html
($co{'title'}, $co{'title_short'},
4808 href
(action
=>"commit", hash
=>$commit), $ref);
4810 "<td class=\"link\">" .
4811 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
4812 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
4813 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
4814 my $snapshot_links = format_snapshot_links
($commit);
4815 if (defined $snapshot_links) {
4816 print " | " . $snapshot_links;
4821 if (defined $extra) {
4823 "<td colspan=\"4\">$extra</td>\n" .
4829 sub git_history_body
{
4830 # Warning: assumes constant type (blob or tree) during history
4831 my ($commitlist, $from, $to, $refs, $extra,
4832 $file_name, $file_hash, $ftype) = @_;
4834 $from = 0 unless defined $from;
4835 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
4837 print "<table class=\"history\">\n";
4839 for (my $i = $from; $i <= $to; $i++) {
4840 my %co = %{$commitlist->[$i]};
4844 my $commit = $co{'id'};
4846 my $ref = format_ref_marker
($refs, $commit);
4849 print "<tr class=\"dark\">\n";
4851 print "<tr class=\"light\">\n";
4854 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4855 # shortlog: format_author_html('td', \%co, 10)
4856 format_author_html
('td', \
%co, 15, 3) . "<td>";
4857 # originally git_history used chop_str($co{'title'}, 50)
4858 print format_subject_html
($co{'title'}, $co{'title_short'},
4859 href
(action
=>"commit", hash
=>$commit), $ref);
4861 "<td class=\"link\">" .
4862 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
4863 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
4865 if ($ftype eq 'blob') {
4866 my $blob_current = $file_hash;
4867 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
4868 if (defined $blob_current && defined $blob_parent &&
4869 $blob_current ne $blob_parent) {
4871 $cgi->a({-href
=> href
(action
=>"blobdiff",
4872 hash
=>$blob_current, hash_parent
=>$blob_parent,
4873 hash_base
=>$hash_base, hash_parent_base
=>$commit,
4874 file_name
=>$file_name)},
4881 if (defined $extra) {
4883 "<td colspan=\"4\">$extra</td>\n" .
4890 # uses global variable $project
4891 my ($taglist, $from, $to, $extra) = @_;
4892 $from = 0 unless defined $from;
4893 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
4895 print "<table class=\"tags\">\n";
4897 for (my $i = $from; $i <= $to; $i++) {
4898 my $entry = $taglist->[$i];
4900 my $comment = $tag{'subject'};
4902 if (defined $comment) {
4903 $comment_short = chop_str
($comment, 30, 5);
4906 print "<tr class=\"dark\">\n";
4908 print "<tr class=\"light\">\n";
4911 if (defined $tag{'age'}) {
4912 print "<td><i>$tag{'age'}</i></td>\n";
4914 print "<td></td>\n";
4917 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
4918 -class => "list name"}, esc_html
($tag{'name'})) .
4921 if (defined $comment) {
4922 print format_subject_html
($comment, $comment_short,
4923 href
(action
=>"tag", hash
=>$tag{'id'}));
4926 "<td class=\"selflink\">";
4927 if ($tag{'type'} eq "tag") {
4928 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
4933 "<td class=\"link\">" . " | " .
4934 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
4935 if ($tag{'reftype'} eq "commit") {
4936 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
4937 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
4938 } elsif ($tag{'reftype'} eq "blob") {
4939 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
4944 if (defined $extra) {
4946 "<td colspan=\"5\">$extra</td>\n" .
4952 sub git_heads_body
{
4953 # uses global variable $project
4954 my ($headlist, $head, $from, $to, $extra) = @_;
4955 $from = 0 unless defined $from;
4956 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4958 print "<table class=\"heads\">\n";
4960 for (my $i = $from; $i <= $to; $i++) {
4961 my $entry = $headlist->[$i];
4963 my $curr = $ref{'id'} eq $head;
4965 print "<tr class=\"dark\">\n";
4967 print "<tr class=\"light\">\n";
4970 print "<td><i>$ref{'age'}</i></td>\n" .
4971 ($curr ?
"<td class=\"current_head\">" : "<td>") .
4972 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
4973 -class => "list name"},esc_html
($ref{'name'})) .
4975 "<td class=\"link\">" .
4976 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
4977 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
4978 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'fullname'})}, "tree") .
4982 if (defined $extra) {
4984 "<td colspan=\"3\">$extra</td>\n" .
4990 sub git_search_grep_body
{
4991 my ($commitlist, $from, $to, $extra) = @_;
4992 $from = 0 unless defined $from;
4993 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4995 print "<table class=\"commit_search\">\n";
4997 for (my $i = $from; $i <= $to; $i++) {
4998 my %co = %{$commitlist->[$i]};
5002 my $commit = $co{'id'};
5004 print "<tr class=\"dark\">\n";
5006 print "<tr class=\"light\">\n";
5009 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5010 format_author_html
('td', \
%co, 15, 5) .
5012 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5013 -class => "list subject"},
5014 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5015 my $comment = $co{'comment'};
5016 foreach my $line (@
$comment) {
5017 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5018 my ($lead, $match, $trail) = ($1, $2, $3);
5019 $match = chop_str
($match, 70, 5, 'center');
5020 my $contextlen = int((80 - length($match))/2);
5021 $contextlen = 30 if ($contextlen > 30);
5022 $lead = chop_str
($lead, $contextlen, 10, 'left');
5023 $trail = chop_str
($trail, $contextlen, 10, 'right');
5025 $lead = esc_html
($lead);
5026 $match = esc_html
($match);
5027 $trail = esc_html
($trail);
5029 print "$lead<span class=\"match\">$match</span>$trail<br />";
5033 "<td class=\"link\">" .
5034 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5036 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
5038 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5042 if (defined $extra) {
5044 "<td colspan=\"3\">$extra</td>\n" .
5050 ## ======================================================================
5051 ## ======================================================================
5054 sub git_project_list
{
5055 my $order = $input_params{'order'};
5056 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5057 die_error
(400, "Unknown order parameter");
5060 my @list = git_get_projects_list
();
5062 die_error
(404, "No projects found");
5066 if (defined $home_text && -f
$home_text) {
5067 print "<div class=\"index_include\">\n";
5068 insert_file
($home_text);
5071 print $cgi->startform(-method
=> "get") .
5072 "<p class=\"projsearch\">Search:\n" .
5073 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
5075 $cgi->end_form() . "\n";
5076 git_project_list_body
(\
@list, $order);
5081 my $order = $input_params{'order'};
5082 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5083 die_error
(400, "Unknown order parameter");
5086 my @list = git_get_projects_list
($project);
5088 die_error
(404, "No forks found");
5092 git_print_page_nav
('','');
5093 git_print_header_div
('summary', "$project forks");
5094 git_project_list_body
(\
@list, $order);
5098 sub git_project_index
{
5099 my @projects = git_get_projects_list
($project);
5102 -type
=> 'text/plain',
5103 -charset
=> 'utf-8',
5104 -content_disposition
=> 'inline; filename="index.aux"');
5106 foreach my $pr (@projects) {
5107 if (!exists $pr->{'owner'}) {
5108 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
5111 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
5112 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
5113 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5114 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5118 print "$path $owner\n";
5123 my $descr = git_get_project_description
($project) || "none";
5124 my %co = parse_commit
("HEAD");
5125 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
5126 my $head = $co{'id'};
5127 my $remote_heads = gitweb_check_feature
('remote_heads');
5129 my $owner = git_get_project_owner
($project);
5131 my $refs = git_get_references
();
5132 # These get_*_list functions return one more to allow us to see if
5133 # there are more ...
5134 my @taglist = git_get_tags_list
(16);
5135 my @headlist = git_get_heads_list
(16);
5136 my @remotelist = $remote_heads ? git_get_heads_list
(16, 'remotes') : ();
5138 my $check_forks = gitweb_check_feature
('forks');
5141 @forklist = git_get_projects_list
($project);
5145 git_print_page_nav
('summary','', $head);
5147 print "<div class=\"title\"> </div>\n";
5148 print "<table class=\"projects_list\">\n" .
5149 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
5150 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
5151 if (defined $cd{'rfc2822'}) {
5152 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
5155 # use per project git URL list in $projectroot/$project/cloneurl
5156 # or make project git URL from git base URL and project name
5157 my $url_tag = "URL";
5158 my @url_list = git_get_project_url_list
($project);
5159 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
5160 foreach my $git_url (@url_list) {
5161 next unless $git_url;
5162 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
5167 my $show_ctags = gitweb_check_feature
('ctags');
5169 my $ctags = git_get_project_ctags
($project);
5170 my $cloud = git_populate_project_tagcloud
($ctags);
5171 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
5172 print "</td>\n<td>" unless %$ctags;
5173 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
5174 print "</td>\n<td>" if %$ctags;
5175 print git_show_project_tagcloud
($cloud, 48);
5181 # If XSS prevention is on, we don't include README.html.
5182 # TODO: Allow a readme in some safe format.
5183 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
5184 print "<div class=\"title\">readme</div>\n" .
5185 "<div class=\"readme\">\n";
5186 insert_file
("$projectroot/$project/README.html");
5187 print "\n</div>\n"; # class="readme"
5190 # we need to request one more than 16 (0..15) to check if
5192 my @commitlist = $head ? parse_commits
($head, 17) : ();
5194 git_print_header_div
('shortlog');
5195 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
5196 $#commitlist <= 15 ?
undef :
5197 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
5201 git_print_header_div
('tags');
5202 git_tags_body
(\
@taglist, 0, 15,
5203 $#taglist <= 15 ?
undef :
5204 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
5208 git_print_header_div
('heads');
5209 git_heads_body
(\
@headlist, $head, 0, 15,
5210 $#headlist <= 15 ?
undef :
5211 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
5215 git_print_header_div
('remotes');
5216 git_heads_body
(\
@remotelist, $head, 0, 15,
5217 $#remotelist <= 15 ?
undef :
5218 $cgi->a({-href
=> href
(action
=>"remotes")}, "..."));
5222 git_print_header_div
('forks');
5223 git_project_list_body
(\
@forklist, 'age', 0, 15,
5224 $#forklist <= 15 ?
undef :
5225 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
5233 my %tag = parse_tag
($hash);
5236 die_error
(404, "Unknown tag object");
5239 my $head = git_get_head_hash
($project);
5241 git_print_page_nav
('','', $head,undef,$head);
5242 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
5243 print "<div class=\"title_text\">\n" .
5244 "<table class=\"object_header\">\n" .
5246 "<td>object</td>\n" .
5247 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
5248 $tag{'object'}) . "</td>\n" .
5249 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
5250 $tag{'type'}) . "</td>\n" .
5252 if (defined($tag{'author'})) {
5253 git_print_authorship_rows
(\
%tag, 'author');
5255 print "</table>\n\n" .
5257 print "<div class=\"page_body\">";
5258 my $comment = $tag{'comment'};
5259 foreach my $line (@
$comment) {
5261 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
5267 sub git_blame_common
{
5268 my $format = shift || 'porcelain';
5269 if ($format eq 'porcelain' && $cgi->param('js')) {
5270 $format = 'incremental';
5271 $action = 'blame_incremental'; # for page title etc
5275 gitweb_check_feature
('blame')
5276 or die_error
(403, "Blame view not allowed");
5279 die_error
(400, "No file name given") unless $file_name;
5280 $hash_base ||= git_get_head_hash
($project);
5281 die_error
(404, "Couldn't find base commit") unless $hash_base;
5282 my %co = parse_commit
($hash_base)
5283 or die_error
(404, "Commit not found");
5285 if (!defined $hash) {
5286 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
5287 or die_error
(404, "Error looking up file");
5289 $ftype = git_get_type
($hash);
5290 if ($ftype !~ "blob") {
5291 die_error
(400, "Object is not a blob");
5296 if ($format eq 'incremental') {
5297 # get file contents (as base)
5298 open $fd, "-|", git_cmd
(), 'cat-file', 'blob', $hash
5299 or die_error
(500, "Open git-cat-file failed");
5300 } elsif ($format eq 'data') {
5301 # run git-blame --incremental
5302 open $fd, "-|", git_cmd
(), "blame", "--incremental",
5303 $hash_base, "--", $file_name
5304 or die_error
(500, "Open git-blame --incremental failed");
5306 # run git-blame --porcelain
5307 open $fd, "-|", git_cmd
(), "blame", '-p',
5308 $hash_base, '--', $file_name
5309 or die_error
(500, "Open git-blame --porcelain failed");
5312 # incremental blame data returns early
5313 if ($format eq 'data') {
5315 -type
=>"text/plain", -charset
=> "utf-8",
5316 -status
=> "200 OK");
5317 local $| = 1; # output autoflush
5320 or print "ERROR $!\n";
5323 if (defined $t0 && gitweb_check_feature
('timed')) {
5325 Time
::HiRes
::tv_interval
($t0, [Time
::HiRes
::gettimeofday
()]).
5326 ' '.$number_of_git_cmds;
5336 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
5339 if ($format eq 'incremental') {
5341 $cgi->a({-href
=> href
(action
=>"blame", javascript
=>0, -replay
=>1)},
5342 "blame") . " (non-incremental)";
5345 $cgi->a({-href
=> href
(action
=>"blame_incremental", -replay
=>1)},
5346 "blame") . " (incremental)";
5350 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5353 $cgi->a({-href
=> href
(action
=>$action, file_name
=>$file_name)},
5355 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5356 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5357 git_print_page_path
($file_name, $ftype, $hash_base);
5360 if ($format eq 'incremental') {
5361 print "<noscript>\n<div class=\"error\"><center><b>\n".
5362 "This page requires JavaScript to run.\n Use ".
5363 $cgi->a({-href
=> href
(action
=>'blame',javascript
=>0,-replay
=>1)},
5366 "</b></center></div>\n</noscript>\n";
5368 print qq!<div id
="progress_bar" style
="width: 100%; background-color: yellow"></div
>\n!;
5371 print qq!<div
class="page_body">\n!;
5372 print qq!<div id
="progress_info">... / ...</div
>\n!
5373 if ($format eq 'incremental');
5374 print qq!<table id
="blame_table" class="blame" width
="100%">\n!.
5375 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
5377 qq!<tr
><th
>Commit
</th><th>Line</th
><th
>Data
</th></tr
>\n!.
5381 my @rev_color = qw(light dark);
5382 my $num_colors = scalar(@rev_color);
5383 my $current_color = 0;
5385 if ($format eq 'incremental') {
5386 my $color_class = $rev_color[$current_color];
5391 while (my $line = <$fd>) {
5395 print qq!<tr id
="l$linenr" class="$color_class">!.
5396 qq!<td
class="sha1"><a href
=""> </a></td
>!.
5397 qq!<td
class="linenr">!.
5398 qq!<a
class="linenr" href
="">$linenr</a></td
>!;
5399 print qq!<td
class="pre">! . esc_html
($line) . "</td>\n";
5403 } else { # porcelain, i.e. ordinary blame
5404 my %metainfo = (); # saves information about commits
5408 while (my $line = <$fd>) {
5410 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
5411 # no <lines in group> for subsequent lines in group of lines
5412 my ($full_rev, $orig_lineno, $lineno, $group_size) =
5413 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
5414 if (!exists $metainfo{$full_rev}) {
5415 $metainfo{$full_rev} = { 'nprevious' => 0 };
5417 my $meta = $metainfo{$full_rev};
5419 while ($data = <$fd>) {
5421 last if ($data =~ s/^\t//); # contents of line
5422 if ($data =~ /^(\S+)(?: (.*))?$/) {
5423 $meta->{$1} = $2 unless exists $meta->{$1};
5425 if ($data =~ /^previous /) {
5426 $meta->{'nprevious'}++;
5429 my $short_rev = substr($full_rev, 0, 8);
5430 my $author = $meta->{'author'};
5432 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
5433 my $date = $date{'iso-tz'};
5435 $current_color = ($current_color + 1) % $num_colors;
5437 my $tr_class = $rev_color[$current_color];
5438 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
5439 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
5440 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
5441 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
5443 print "<td class=\"sha1\"";
5444 print " title=\"". esc_html
($author) . ", $date\"";
5445 print " rowspan=\"$group_size\"" if ($group_size > 1);
5447 print $cgi->a({-href
=> href
(action
=>"commit",
5449 file_name
=>$file_name)},
5450 esc_html
($short_rev));
5451 if ($group_size >= 2) {
5452 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
5453 if (@author_initials) {
5455 esc_html
(join('', @author_initials));
5461 # 'previous' <sha1 of parent commit> <filename at commit>
5462 if (exists $meta->{'previous'} &&
5463 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
5464 $meta->{'parent'} = $1;
5465 $meta->{'file_parent'} = unquote
($2);
5468 exists($meta->{'parent'}) ?
5469 $meta->{'parent'} : $full_rev;
5470 my $linenr_filename =
5471 exists($meta->{'file_parent'}) ?
5472 $meta->{'file_parent'} : unquote
($meta->{'filename'});
5473 my $blamed = href
(action
=> 'blame',
5474 file_name
=> $linenr_filename,
5475 hash_base
=> $linenr_commit);
5476 print "<td class=\"linenr\">";
5477 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
5478 -class => "linenr" },
5481 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
5489 "</table>\n"; # class="blame"
5490 print "</div>\n"; # class="blame_body"
5492 or print "Reading blob failed\n";
5501 sub git_blame_incremental
{
5502 git_blame_common
('incremental');
5505 sub git_blame_data
{
5506 git_blame_common
('data');
5510 my $head = git_get_head_hash
($project);
5512 git_print_page_nav
('','', $head,undef,$head);
5513 git_print_header_div
('summary', $project);
5515 my @tagslist = git_get_tags_list
();
5517 git_tags_body
(\
@tagslist);
5523 my $head = git_get_head_hash
($project);
5525 git_print_page_nav
('','', $head,undef,$head);
5526 git_print_header_div
('summary', $project);
5528 my @headslist = git_get_heads_list
();
5530 git_heads_body
(\
@headslist, $head);
5536 gitweb_check_feature
('remote_heads')
5537 or die_error
(403, "Remote heads view is disabled");
5539 my $head = git_get_head_hash
($project);
5541 git_print_page_nav
('','', $head,undef,$head);
5542 git_print_header_div
('summary', $project);
5544 my @remotelist = git_get_heads_list
(undef, 'remotes');
5546 git_heads_body
(\
@remotelist, $head);
5551 sub git_blob_plain
{
5555 if (!defined $hash) {
5556 if (defined $file_name) {
5557 my $base = $hash_base || git_get_head_hash
($project);
5558 $hash = git_get_hash_by_path
($base, $file_name, "blob")
5559 or die_error
(404, "Cannot find file");
5561 die_error
(400, "No file name defined");
5563 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5564 # blobs defined by non-textual hash id's can be cached
5568 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
5569 or die_error
(500, "Open git-cat-file blob '$hash' failed");
5571 # content-type (can include charset)
5572 $type = blob_contenttype
($fd, $file_name, $type);
5574 # "save as" filename, even when no $file_name is given
5575 my $save_as = "$hash";
5576 if (defined $file_name) {
5577 $save_as = $file_name;
5578 } elsif ($type =~ m/^text\//) {
5582 # With XSS prevention on, blobs of all types except a few known safe
5583 # ones are served with "Content-Disposition: attachment" to make sure
5584 # they don't run in our security domain. For certain image types,
5585 # blob view writes an <img> tag referring to blob_plain view, and we
5586 # want to be sure not to break that by serving the image as an
5587 # attachment (though Firefox 3 doesn't seem to care).
5588 my $sandbox = $prevent_xss &&
5589 $type !~ m!^(?:text/plain|image/(?:gif|png|jpeg))$!;
5593 -expires
=> $expires,
5594 -content_disposition
=>
5595 ($sandbox ?
'attachment' : 'inline')
5596 . '; filename="' . $save_as . '"');
5598 binmode STDOUT
, ':raw';
5600 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
5607 if (!defined $hash) {
5608 if (defined $file_name) {
5609 my $base = $hash_base || git_get_head_hash
($project);
5610 $hash = git_get_hash_by_path
($base, $file_name, "blob")
5611 or die_error
(404, "Cannot find file");
5613 die_error
(400, "No file name defined");
5615 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5616 # blobs defined by non-textual hash id's can be cached
5620 my $have_blame = gitweb_check_feature
('blame');
5621 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
5622 or die_error
(500, "Couldn't cat $file_name, $hash");
5623 my $mimetype = blob_mimetype
($fd, $file_name);
5624 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
5625 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
5627 return git_blob_plain
($mimetype);
5629 # we can have blame only for text/* mimetype
5630 $have_blame &&= ($mimetype =~ m!^text/!);
5632 my $highlight = gitweb_check_feature
('highlight');
5633 my $syntax = guess_file_syntax
($highlight, $mimetype, $file_name);
5634 $fd = run_highlighter
($fd, $highlight, $syntax)
5637 git_header_html
(undef, $expires);
5638 my $formats_nav = '';
5639 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5640 if (defined $file_name) {
5643 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
5648 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5651 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
5654 $cgi->a({-href
=> href
(action
=>"blob",
5655 hash_base
=>"HEAD", file_name
=>$file_name)},
5659 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
5662 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5663 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5665 print "<div class=\"page_nav\">\n" .
5666 "<br/><br/></div>\n" .
5667 "<div class=\"title\">$hash</div>\n";
5669 git_print_page_path
($file_name, "blob", $hash_base);
5670 print "<div class=\"page_body\">\n";
5671 if ($mimetype =~ m!^image/!) {
5672 print qq!<img type
="$mimetype"!;
5674 print qq! alt
="$file_name" title
="$file_name"!;
5677 href(action=>"blob_plain
", hash=>$hash,
5678 hash_base=>$hash_base, file_name=>$file_name) .
5682 while (my $line = <$fd>) {
5685 $line = untabify
($line);
5686 printf qq!<div
class="pre"><a id
="l%i" href
="%s#l%i" class="linenr">%4i</a> %s</div
>\n!,
5687 $nr, href
(-replay
=> 1), $nr, $nr, $syntax ?
$line : esc_html
($line, -nbsp
=>1);
5691 or print "Reading blob failed.\n";
5697 if (!defined $hash_base) {
5698 $hash_base = "HEAD";
5700 if (!defined $hash) {
5701 if (defined $file_name) {
5702 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
5707 die_error
(404, "No such tree") unless defined($hash);
5709 my $show_sizes = gitweb_check_feature
('show-sizes');
5710 my $have_blame = gitweb_check_feature
('blame');
5715 open my $fd, "-|", git_cmd
(), "ls-tree", '-z',
5716 ($show_sizes ?
'-l' : ()), @extra_options, $hash
5717 or die_error
(500, "Open git-ls-tree failed");
5718 @entries = map { chomp; $_ } <$fd>;
5720 or die_error
(404, "Reading tree failed");
5723 my $refs = git_get_references
();
5724 my $ref = format_ref_marker
($refs, $hash_base);
5727 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5729 if (defined $file_name) {
5731 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5733 $cgi->a({-href
=> href
(action
=>"tree",
5734 hash_base
=>"HEAD", file_name
=>$file_name)},
5737 my $snapshot_links = format_snapshot_links
($hash);
5738 if (defined $snapshot_links) {
5739 # FIXME: Should be available when we have no hash base as well.
5740 push @views_nav, $snapshot_links;
5742 git_print_page_nav
('tree','', $hash_base, undef, undef,
5743 join(' | ', @views_nav));
5744 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
5747 print "<div class=\"page_nav\">\n";
5748 print "<br/><br/></div>\n";
5749 print "<div class=\"title\">$hash</div>\n";
5751 if (defined $file_name) {
5752 $basedir = $file_name;
5753 if ($basedir ne '' && substr($basedir, -1) ne '/') {
5756 git_print_page_path
($file_name, 'tree', $hash_base);
5758 print "<div class=\"page_body\">\n";
5759 print "<table class=\"tree\">\n";
5761 # '..' (top directory) link if possible
5762 if (defined $hash_base &&
5763 defined $file_name && $file_name =~ m![^/]+$!) {
5765 print "<tr class=\"dark\">\n";
5767 print "<tr class=\"light\">\n";
5771 my $up = $file_name;
5772 $up =~ s!/?[^/]+$!!;
5773 undef $up unless $up;
5774 # based on git_print_tree_entry
5775 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
5776 print '<td class="size"> </td>'."\n" if $show_sizes;
5777 print '<td class="list">';
5778 print $cgi->a({-href
=> href
(action
=>"tree",
5779 hash_base
=>$hash_base,
5783 print "<td class=\"link\"></td>\n";
5787 foreach my $line (@entries) {
5788 my %t = parse_ls_tree_line
($line, -z
=> 1, -l
=> $show_sizes);
5791 print "<tr class=\"dark\">\n";
5793 print "<tr class=\"light\">\n";
5797 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
5801 print "</table>\n" .
5807 my ($project, $hash) = @_;
5809 # path/to/project.git -> project
5810 # path/to/project/.git -> project
5811 my $name = to_utf8
($project);
5812 $name =~ s
,([^/])/*\
.git
$,$1,;
5813 $name = basename
($name);
5815 $name =~ s/[[:cntrl:]]/?/g;
5818 if ($hash =~ /^[0-9a-fA-F]+$/) {
5819 # shorten SHA-1 hash
5820 my $full_hash = git_get_full_hash
($project, $hash);
5821 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
5822 $ver = git_get_short_hash
($project, $hash);
5824 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
5825 # tags don't need shortened SHA-1 hash
5828 # branches and other need shortened SHA-1 hash
5829 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
5832 $ver .= '-' . git_get_short_hash
($project, $hash);
5834 # in case of hierarchical branch names
5837 # name = project-version_string
5838 $name = "$name-$ver";
5840 return wantarray ?
($name, $name) : $name;
5844 my $format = $input_params{'snapshot_format'};
5845 if (!@snapshot_fmts) {
5846 die_error
(403, "Snapshots not allowed");
5848 # default to first supported snapshot format
5849 $format ||= $snapshot_fmts[0];
5850 if ($format !~ m/^[a-z0-9]+$/) {
5851 die_error
(400, "Invalid snapshot format parameter");
5852 } elsif (!exists($known_snapshot_formats{$format})) {
5853 die_error
(400, "Unknown snapshot format");
5854 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
5855 die_error
(403, "Snapshot format not allowed");
5856 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
5857 die_error
(403, "Unsupported snapshot format");
5860 my $type = git_get_type
("$hash^{}");
5862 die_error
(404, 'Object does not exist');
5863 } elsif ($type eq 'blob') {
5864 die_error
(400, 'Object is not a tree-ish');
5867 my ($name, $prefix) = snapshot_name
($project, $hash);
5868 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
5869 my $cmd = quote_command
(
5870 git_cmd
(), 'archive',
5871 "--format=$known_snapshot_formats{$format}{'format'}",
5872 "--prefix=$prefix/", $hash);
5873 if (exists $known_snapshot_formats{$format}{'compressor'}) {
5874 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
5877 $filename =~ s/(["\\])/\\$1/g;
5879 -type
=> $known_snapshot_formats{$format}{'type'},
5880 -content_disposition
=> 'inline; filename="' . $filename . '"',
5881 -status
=> '200 OK');
5883 open my $fd, "-|", $cmd
5884 or die_error
(500, "Execute git-archive failed");
5885 binmode STDOUT
, ':raw';
5887 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
5891 sub git_log_generic
{
5892 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
5894 my $head = git_get_head_hash
($project);
5895 if (!defined $base) {
5898 if (!defined $page) {
5901 my $refs = git_get_references
();
5903 my $commit_hash = $base;
5904 if (defined $parent) {
5905 $commit_hash = "$parent..$base";
5908 parse_commits
($commit_hash, 101, (100 * $page),
5909 defined $file_name ?
($file_name, "--full-history") : ());
5912 if (!defined $file_hash && defined $file_name) {
5913 # some commits could have deleted file in question,
5914 # and not have it in tree, but one of them has to have it
5915 for (my $i = 0; $i < @commitlist; $i++) {
5916 $file_hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
5917 last if defined $file_hash;
5920 if (defined $file_hash) {
5921 $ftype = git_get_type
($file_hash);
5923 if (defined $file_name && !defined $ftype) {
5924 die_error
(500, "Unknown type of object");
5927 if (defined $file_name) {
5928 %co = parse_commit
($base)
5929 or die_error
(404, "Unknown commit object");
5933 my $paging_nav = format_paging_nav
($fmt_name, $page, $#commitlist >= 100);
5935 if ($#commitlist >= 100) {
5937 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5938 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5940 my $patch_max = gitweb_get_feature
('patches');
5941 if ($patch_max && !defined $file_name) {
5942 if ($patch_max < 0 || @commitlist <= $patch_max) {
5943 $paging_nav .= " ⋅ " .
5944 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
5950 git_print_page_nav
($fmt_name,'', $hash,$hash,$hash, $paging_nav);
5951 if (defined $file_name) {
5952 git_print_header_div
('commit', esc_html
($co{'title'}), $base);
5954 git_print_header_div
('summary', $project)
5956 git_print_page_path
($file_name, $ftype, $hash_base)
5957 if (defined $file_name);
5959 $body_subr->(\
@commitlist, 0, 99, $refs, $next_link,
5960 $file_name, $file_hash, $ftype);
5966 git_log_generic
('log', \
&git_log_body
,
5967 $hash, $hash_parent);
5971 $hash ||= $hash_base || "HEAD";
5972 my %co = parse_commit
($hash)
5973 or die_error
(404, "Unknown commit object");
5975 my $parent = $co{'parent'};
5976 my $parents = $co{'parents'}; # listref
5978 # we need to prepare $formats_nav before any parameter munging
5980 if (!defined $parent) {
5982 $formats_nav .= '(initial)';
5983 } elsif (@
$parents == 1) {
5984 # single parent commit
5987 $cgi->a({-href
=> href
(action
=>"commit",
5989 esc_html
(substr($parent, 0, 7))) .
5996 $cgi->a({-href
=> href
(action
=>"commit",
5998 esc_html
(substr($_, 0, 7)));
6002 if (gitweb_check_feature
('patches') && @
$parents <= 1) {
6003 $formats_nav .= " | " .
6004 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6008 if (!defined $parent) {
6012 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
6014 (@
$parents <= 1 ?
$parent : '-c'),
6016 or die_error
(500, "Open git-diff-tree failed");
6017 @difftree = map { chomp; $_ } <$fd>;
6018 close $fd or die_error
(404, "Reading git-diff-tree failed");
6020 # non-textual hash id's can be cached
6022 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6025 my $refs = git_get_references
();
6026 my $ref = format_ref_marker
($refs, $co{'id'});
6028 git_header_html
(undef, $expires);
6029 git_print_page_nav
('commit', '',
6030 $hash, $co{'tree'}, $hash,
6033 if (defined $co{'parent'}) {
6034 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
6036 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
6038 print "<div class=\"title_text\">\n" .
6039 "<table class=\"object_header\">\n";
6040 git_print_authorship_rows
(\
%co);
6041 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
6044 "<td class=\"sha1\">" .
6045 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
6046 class => "list"}, $co{'tree'}) .
6048 "<td class=\"link\">" .
6049 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
6051 my $snapshot_links = format_snapshot_links
($hash);
6052 if (defined $snapshot_links) {
6053 print " | " . $snapshot_links;
6058 foreach my $par (@
$parents) {
6061 "<td class=\"sha1\">" .
6062 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
6063 class => "list"}, $par) .
6065 "<td class=\"link\">" .
6066 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
6068 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
6075 print "<div class=\"page_body\">\n";
6076 git_print_log
($co{'comment'});
6079 git_difftree_body
(\
@difftree, $hash, @
$parents);
6085 # object is defined by:
6086 # - hash or hash_base alone
6087 # - hash_base and file_name
6090 # - hash or hash_base alone
6091 if ($hash || ($hash_base && !defined $file_name)) {
6092 my $object_id = $hash || $hash_base;
6094 open my $fd, "-|", quote_command
(
6095 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
6096 or die_error
(404, "Object does not exist");
6100 or die_error
(404, "Object does not exist");
6102 # - hash_base and file_name
6103 } elsif ($hash_base && defined $file_name) {
6104 $file_name =~ s
,/+$,,;
6106 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
6107 or die_error
(404, "Base object does not exist");
6109 # here errors should not hapen
6110 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
6111 or die_error
(500, "Open git-ls-tree failed");
6115 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
6116 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
6117 die_error
(404, "File or directory for given base does not exist");
6122 die_error
(400, "Not enough information to find object");
6125 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
6126 hash
=>$hash, hash_base
=>$hash_base,
6127 file_name
=>$file_name),
6128 -status
=> '302 Found');
6132 my $format = shift || 'html';
6139 # preparing $fd and %diffinfo for git_patchset_body
6141 if (defined $hash_base && defined $hash_parent_base) {
6142 if (defined $file_name) {
6144 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6145 $hash_parent_base, $hash_base,
6146 "--", (defined $file_parent ?
$file_parent : ()), $file_name
6147 or die_error
(500, "Open git-diff-tree failed");
6148 @difftree = map { chomp; $_ } <$fd>;
6150 or die_error
(404, "Reading git-diff-tree failed");
6152 or die_error
(404, "Blob diff not found");
6154 } elsif (defined $hash &&
6155 $hash =~ /[0-9a-fA-F]{40}/) {
6156 # try to find filename from $hash
6158 # read filtered raw output
6159 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6160 $hash_parent_base, $hash_base, "--"
6161 or die_error
(500, "Open git-diff-tree failed");
6163 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
6165 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
6166 map { chomp; $_ } <$fd>;
6168 or die_error
(404, "Reading git-diff-tree failed");
6170 or die_error
(404, "Blob diff not found");
6173 die_error
(400, "Missing one of the blob diff parameters");
6176 if (@difftree > 1) {
6177 die_error
(400, "Ambiguous blob diff specification");
6180 %diffinfo = parse_difftree_raw_line
($difftree[0]);
6181 $file_parent ||= $diffinfo{'from_file'} || $file_name;
6182 $file_name ||= $diffinfo{'to_file'};
6184 $hash_parent ||= $diffinfo{'from_id'};
6185 $hash ||= $diffinfo{'to_id'};
6187 # non-textual hash id's can be cached
6188 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
6189 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
6194 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6195 '-p', ($format eq 'html' ?
"--full-index" : ()),
6196 $hash_parent_base, $hash_base,
6197 "--", (defined $file_parent ?
$file_parent : ()), $file_name
6198 or die_error
(500, "Open git-diff-tree failed");
6201 # old/legacy style URI -- not generated anymore since 1.4.3.
6203 die_error
('404 Not Found', "Missing one of the blob diff parameters")
6207 if ($format eq 'html') {
6209 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
6211 git_header_html
(undef, $expires);
6212 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6213 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6214 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6216 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
6217 print "<div class=\"title\">$hash vs $hash_parent</div>\n";
6219 if (defined $file_name) {
6220 git_print_page_path
($file_name, "blob", $hash_base);
6222 print "<div class=\"page_path\"></div>\n";
6225 } elsif ($format eq 'plain') {
6227 -type
=> 'text/plain',
6228 -charset
=> 'utf-8',
6229 -expires
=> $expires,
6230 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
6232 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6235 die_error
(400, "Unknown blobdiff format");
6239 if ($format eq 'html') {
6240 print "<div class=\"page_body\">\n";
6242 git_patchset_body
($fd, [ \
%diffinfo ], $hash_base, $hash_parent_base);
6245 print "</div>\n"; # class="page_body"
6249 while (my $line = <$fd>) {
6250 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
6251 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
6255 last if $line =~ m!^\+\+\+!;
6263 sub git_blobdiff_plain
{
6264 git_blobdiff
('plain');
6267 sub git_commitdiff
{
6269 my $format = $params{-format
} || 'html';
6271 my ($patch_max) = gitweb_get_feature
('patches');
6272 if ($format eq 'patch') {
6273 die_error
(403, "Patch view not allowed") unless $patch_max;
6276 $hash ||= $hash_base || "HEAD";
6277 my %co = parse_commit
($hash)
6278 or die_error
(404, "Unknown commit object");
6280 # choose format for commitdiff for merge
6281 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
6282 $hash_parent = '--cc';
6284 # we need to prepare $formats_nav before almost any parameter munging
6286 if ($format eq 'html') {
6288 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
6290 if ($patch_max && @
{$co{'parents'}} <= 1) {
6291 $formats_nav .= " | " .
6292 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6296 if (defined $hash_parent &&
6297 $hash_parent ne '-c' && $hash_parent ne '--cc') {
6298 # commitdiff with two commits given
6299 my $hash_parent_short = $hash_parent;
6300 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
6301 $hash_parent_short = substr($hash_parent, 0, 7);
6305 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
6306 if ($co{'parents'}[$i] eq $hash_parent) {
6307 $formats_nav .= ' parent ' . ($i+1);
6311 $formats_nav .= ': ' .
6312 $cgi->a({-href
=> href
(action
=>"commitdiff",
6313 hash
=>$hash_parent)},
6314 esc_html
($hash_parent_short)) .
6316 } elsif (!$co{'parent'}) {
6318 $formats_nav .= ' (initial)';
6319 } elsif (scalar @
{$co{'parents'}} == 1) {
6320 # single parent commit
6323 $cgi->a({-href
=> href
(action
=>"commitdiff",
6324 hash
=>$co{'parent'})},
6325 esc_html
(substr($co{'parent'}, 0, 7))) .
6329 if ($hash_parent eq '--cc') {
6330 $formats_nav .= ' | ' .
6331 $cgi->a({-href
=> href
(action
=>"commitdiff",
6332 hash
=>$hash, hash_parent
=>'-c')},
6334 } else { # $hash_parent eq '-c'
6335 $formats_nav .= ' | ' .
6336 $cgi->a({-href
=> href
(action
=>"commitdiff",
6337 hash
=>$hash, hash_parent
=>'--cc')},
6343 $cgi->a({-href
=> href
(action
=>"commitdiff",
6345 esc_html
(substr($_, 0, 7)));
6346 } @
{$co{'parents'}} ) .
6351 my $hash_parent_param = $hash_parent;
6352 if (!defined $hash_parent_param) {
6353 # --cc for multiple parents, --root for parentless
6354 $hash_parent_param =
6355 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
6361 if ($format eq 'html') {
6362 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6363 "--no-commit-id", "--patch-with-raw", "--full-index",
6364 $hash_parent_param, $hash, "--"
6365 or die_error
(500, "Open git-diff-tree failed");
6367 while (my $line = <$fd>) {
6369 # empty line ends raw part of diff-tree output
6371 push @difftree, scalar parse_difftree_raw_line
($line);
6374 } elsif ($format eq 'plain') {
6375 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6376 '-p', $hash_parent_param, $hash, "--"
6377 or die_error
(500, "Open git-diff-tree failed");
6378 } elsif ($format eq 'patch') {
6379 # For commit ranges, we limit the output to the number of
6380 # patches specified in the 'patches' feature.
6381 # For single commits, we limit the output to a single patch,
6382 # diverging from the git-format-patch default.
6383 my @commit_spec = ();
6385 if ($patch_max > 0) {
6386 push @commit_spec, "-$patch_max";
6388 push @commit_spec, '-n', "$hash_parent..$hash";
6390 if ($params{-single
}) {
6391 push @commit_spec, '-1';
6393 if ($patch_max > 0) {
6394 push @commit_spec, "-$patch_max";
6396 push @commit_spec, "-n";
6398 push @commit_spec, '--root', $hash;
6400 open $fd, "-|", git_cmd
(), "format-patch", @diff_opts,
6401 '--encoding=utf8', '--stdout', @commit_spec
6402 or die_error
(500, "Open git-format-patch failed");
6404 die_error
(400, "Unknown commitdiff format");
6407 # non-textual hash id's can be cached
6409 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6413 # write commit message
6414 if ($format eq 'html') {
6415 my $refs = git_get_references
();
6416 my $ref = format_ref_marker
($refs, $co{'id'});
6418 git_header_html
(undef, $expires);
6419 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
6420 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
6421 print "<div class=\"title_text\">\n" .
6422 "<table class=\"object_header\">\n";
6423 git_print_authorship_rows
(\
%co);
6426 print "<div class=\"page_body\">\n";
6427 if (@
{$co{'comment'}} > 1) {
6428 print "<div class=\"log\">\n";
6429 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
6430 print "</div>\n"; # class="log"
6433 } elsif ($format eq 'plain') {
6434 my $refs = git_get_references
("tags");
6435 my $tagname = git_get_rev_name_tags
($hash);
6436 my $filename = basename
($project) . "-$hash.patch";
6439 -type
=> 'text/plain',
6440 -charset
=> 'utf-8',
6441 -expires
=> $expires,
6442 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
6443 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
6444 print "From: " . to_utf8
($co{'author'}) . "\n";
6445 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
6446 print "Subject: " . to_utf8
($co{'title'}) . "\n";
6448 print "X-Git-Tag: $tagname\n" if $tagname;
6449 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6451 foreach my $line (@
{$co{'comment'}}) {
6452 print to_utf8
($line) . "\n";
6455 } elsif ($format eq 'patch') {
6456 my $filename = basename
($project) . "-$hash.patch";
6459 -type
=> 'text/plain',
6460 -charset
=> 'utf-8',
6461 -expires
=> $expires,
6462 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
6466 if ($format eq 'html') {
6467 my $use_parents = !defined $hash_parent ||
6468 $hash_parent eq '-c' || $hash_parent eq '--cc';
6469 git_difftree_body
(\
@difftree, $hash,
6470 $use_parents ? @
{$co{'parents'}} : $hash_parent);
6473 git_patchset_body
($fd, \
@difftree, $hash,
6474 $use_parents ? @
{$co{'parents'}} : $hash_parent);
6476 print "</div>\n"; # class="page_body"
6479 } elsif ($format eq 'plain') {
6483 or print "Reading git-diff-tree failed\n";
6484 } elsif ($format eq 'patch') {
6488 or print "Reading git-format-patch failed\n";
6492 sub git_commitdiff_plain
{
6493 git_commitdiff
(-format
=> 'plain');
6496 # format-patch-style patches
6498 git_commitdiff
(-format
=> 'patch', -single
=> 1);
6502 git_commitdiff
(-format
=> 'patch');
6506 git_log_generic
('history', \
&git_history_body
,
6507 $hash_base, $hash_parent_base,
6512 gitweb_check_feature
('search') or die_error
(403, "Search is disabled");
6513 if (!defined $searchtext) {
6514 die_error
(400, "Text field is empty");
6516 if (!defined $hash) {
6517 $hash = git_get_head_hash
($project);
6519 my %co = parse_commit
($hash);
6521 die_error
(404, "Unknown commit object");
6523 if (!defined $page) {
6527 $searchtype ||= 'commit';
6528 if ($searchtype eq 'pickaxe') {
6529 # pickaxe may take all resources of your box and run for several minutes
6530 # with every query - so decide by yourself how public you make this feature
6531 gitweb_check_feature
('pickaxe')
6532 or die_error
(403, "Pickaxe is disabled");
6534 if ($searchtype eq 'grep') {
6535 gitweb_check_feature
('grep')
6536 or die_error
(403, "Grep is disabled");
6541 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
6543 if ($searchtype eq 'commit') {
6544 $greptype = "--grep=";
6545 } elsif ($searchtype eq 'author') {
6546 $greptype = "--author=";
6547 } elsif ($searchtype eq 'committer') {
6548 $greptype = "--committer=";
6550 $greptype .= $searchtext;
6551 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
6552 $greptype, '--regexp-ignore-case',
6553 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
6555 my $paging_nav = '';
6558 $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
6559 searchtext
=>$searchtext,
6560 searchtype
=>$searchtype)},
6562 $paging_nav .= " ⋅ " .
6563 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
6564 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
6566 $paging_nav .= "first";
6567 $paging_nav .= " ⋅ prev";
6570 if ($#commitlist >= 100) {
6572 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6573 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
6574 $paging_nav .= " ⋅ $next_link";
6576 $paging_nav .= " ⋅ next";
6579 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
6580 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6581 if ($page == 0 && !@commitlist) {
6582 print "<p>No match.</p>\n";
6584 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
6588 if ($searchtype eq 'pickaxe') {
6589 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
6590 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6592 print "<table class=\"pickaxe search\">\n";
6595 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
6596 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
6597 ($search_use_regexp ?
'--pickaxe-regex' : ());
6600 while (my $line = <$fd>) {
6604 my %set = parse_difftree_raw_line
($line);
6605 if (defined $set{'commit'}) {
6606 # finish previous commit
6609 "<td class=\"link\">" .
6610 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
6612 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
6618 print "<tr class=\"dark\">\n";
6620 print "<tr class=\"light\">\n";
6623 %co = parse_commit
($set{'commit'});
6624 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
6625 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
6626 "<td><i>$author</i></td>\n" .
6628 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
6629 -class => "list subject"},
6630 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
6631 } elsif (defined $set{'to_id'}) {
6632 next if ($set{'to_id'} =~ m/^0{40}$/);
6634 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
6635 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
6637 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
6643 # finish last commit (warning: repetition!)
6646 "<td class=\"link\">" .
6647 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
6649 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
6657 if ($searchtype eq 'grep') {
6658 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
6659 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6661 print "<table class=\"grep_search\">\n";
6665 open my $fd, "-|", git_cmd
(), 'grep', '-n',
6666 $search_use_regexp ?
('-E', '-i') : '-F',
6667 $searchtext, $co{'tree'};
6669 while (my $line = <$fd>) {
6671 my ($file, $lno, $ltext, $binary);
6672 last if ($matches++ > 1000);
6673 if ($line =~ /^Binary file (.+) matches$/) {
6677 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
6679 if ($file ne $lastfile) {
6680 $lastfile and print "</td></tr>\n";
6682 print "<tr class=\"dark\">\n";
6684 print "<tr class=\"light\">\n";
6686 print "<td class=\"list\">".
6687 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
6688 file_name
=>"$file"),
6689 -class => "list"}, esc_path
($file));
6690 print "</td><td>\n";
6694 print "<div class=\"binary\">Binary file</div>\n";
6696 $ltext = untabify
($ltext);
6697 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
6698 $ltext = esc_html
($1, -nbsp
=>1);
6699 $ltext .= '<span class="match">';
6700 $ltext .= esc_html
($2, -nbsp
=>1);
6701 $ltext .= '</span>';
6702 $ltext .= esc_html
($3, -nbsp
=>1);
6704 $ltext = esc_html
($ltext, -nbsp
=>1);
6706 print "<div class=\"pre\">" .
6707 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
6708 file_name
=>"$file").'#l'.$lno,
6709 -class => "linenr"}, sprintf('%4i', $lno))
6710 . ' ' . $ltext . "</div>\n";
6714 print "</td></tr>\n";
6715 if ($matches > 1000) {
6716 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
6719 print "<div class=\"diff nodifferences\">No matches found</div>\n";
6728 sub git_search_help
{
6730 git_print_page_nav
('','', $hash,$hash,$hash);
6732 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
6733 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
6734 the pattern entered is recognized as the POSIX extended
6735 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
6738 <dt><b>commit</b></dt>
6739 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
6741 my $have_grep = gitweb_check_feature
('grep');
6744 <dt><b>grep</b></dt>
6745 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
6746 a different one) are searched for the given pattern. On large trees, this search can take
6747 a while and put some strain on the server, so please use it with some consideration. Note that
6748 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
6749 case-sensitive.</dd>
6753 <dt><b>author</b></dt>
6754 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
6755 <dt><b>committer</b></dt>
6756 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
6758 my $have_pickaxe = gitweb_check_feature
('pickaxe');
6759 if ($have_pickaxe) {
6761 <dt><b>pickaxe</b></dt>
6762 <dd>All commits that caused the string to appear or disappear from any file (changes that
6763 added, removed or "modified" the string) will be listed. This search can take a while and
6764 takes a lot of strain on the server, so please use it wisely. Note that since you may be
6765 interested even in changes just changing the case as well, this search is case sensitive.</dd>
6773 git_log_generic
('shortlog', \
&git_shortlog_body
,
6774 $hash, $hash_parent);
6777 ## ......................................................................
6778 ## feeds (RSS, Atom; OPML)
6781 my $format = shift || 'atom';
6782 my $have_blame = gitweb_check_feature
('blame');
6784 # Atom: http://www.atomenabled.org/developers/syndication/
6785 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
6786 if ($format ne 'rss' && $format ne 'atom') {
6787 die_error
(400, "Unknown web feed format");
6790 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
6791 my $head = $hash || 'HEAD';
6792 my @commitlist = parse_commits
($head, 150, 0, $file_name);
6796 my $content_type = "application/$format+xml";
6797 if (defined $cgi->http('HTTP_ACCEPT') &&
6798 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
6799 # browser (feed reader) prefers text/xml
6800 $content_type = 'text/xml';
6802 if (defined($commitlist[0])) {
6803 %latest_commit = %{$commitlist[0]};
6804 my $latest_epoch = $latest_commit{'committer_epoch'};
6805 %latest_date = parse_date
($latest_epoch);
6806 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
6807 if (defined $if_modified) {
6809 if (eval { require HTTP
::Date
; 1; }) {
6810 $since = HTTP
::Date
::str2time
($if_modified);
6811 } elsif (eval { require Time
::ParseDate
; 1; }) {
6812 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
6814 if (defined $since && $latest_epoch <= $since) {
6816 -type
=> $content_type,
6817 -charset
=> 'utf-8',
6818 -last_modified
=> $latest_date{'rfc2822'},
6819 -status
=> '304 Not Modified');
6824 -type
=> $content_type,
6825 -charset
=> 'utf-8',
6826 -last_modified
=> $latest_date{'rfc2822'});
6829 -type
=> $content_type,
6830 -charset
=> 'utf-8');
6833 # Optimization: skip generating the body if client asks only
6834 # for Last-Modified date.
6835 return if ($cgi->request_method() eq 'HEAD');
6838 my $title = "$site_name - $project/$action";
6839 my $feed_type = 'log';
6840 if (defined $hash) {
6841 $title .= " - '$hash'";
6842 $feed_type = 'branch log';
6843 if (defined $file_name) {
6844 $title .= " :: $file_name";
6845 $feed_type = 'history';
6847 } elsif (defined $file_name) {
6848 $title .= " - $file_name";
6849 $feed_type = 'history';
6851 $title .= " $feed_type";
6852 my $descr = git_get_project_description
($project);
6853 if (defined $descr) {
6854 $descr = esc_html
($descr);
6856 $descr = "$project " .
6857 ($format eq 'rss' ?
'RSS' : 'Atom') .
6860 my $owner = git_get_project_owner
($project);
6861 $owner = esc_html
($owner);
6865 if (defined $file_name) {
6866 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
6867 } elsif (defined $hash) {
6868 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
6870 $alt_url = href
(-full
=>1, action
=>"summary");
6872 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
6873 if ($format eq 'rss') {
6875 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
6878 print "<title>$title</title>\n" .
6879 "<link>$alt_url</link>\n" .
6880 "<description>$descr</description>\n" .
6881 "<language>en</language>\n" .
6882 # project owner is responsible for 'editorial' content
6883 "<managingEditor>$owner</managingEditor>\n";
6884 if (defined $logo || defined $favicon) {
6885 # prefer the logo to the favicon, since RSS
6886 # doesn't allow both
6887 my $img = esc_url
($logo || $favicon);
6889 "<url>$img</url>\n" .
6890 "<title>$title</title>\n" .
6891 "<link>$alt_url</link>\n" .
6895 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
6896 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
6898 print "<generator>gitweb v.$version/$git_version</generator>\n";
6899 } elsif ($format eq 'atom') {
6901 <feed xmlns="http://www.w3.org/2005/Atom">
6903 print "<title>$title</title>\n" .
6904 "<subtitle>$descr</subtitle>\n" .
6905 '<link rel="alternate" type="text/html" href="' .
6906 $alt_url . '" />' . "\n" .
6907 '<link rel="self" type="' . $content_type . '" href="' .
6908 $cgi->self_url() . '" />' . "\n" .
6909 "<id>" . href
(-full
=>1) . "</id>\n" .
6910 # use project owner for feed author
6911 "<author><name>$owner</name></author>\n";
6912 if (defined $favicon) {
6913 print "<icon>" . esc_url
($favicon) . "</icon>\n";
6915 if (defined $logo_url) {
6916 # not twice as wide as tall: 72 x 27 pixels
6917 print "<logo>" . esc_url
($logo) . "</logo>\n";
6919 if (! %latest_date) {
6920 # dummy date to keep the feed valid until commits trickle in:
6921 print "<updated>1970-01-01T00:00:00Z</updated>\n";
6923 print "<updated>$latest_date{'iso-8601'}</updated>\n";
6925 print "<generator version='$version/$git_version'>gitweb</generator>\n";
6929 for (my $i = 0; $i <= $#commitlist; $i++) {
6930 my %co = %{$commitlist[$i]};
6931 my $commit = $co{'id'};
6932 # we read 150, we always show 30 and the ones more recent than 48 hours
6933 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
6936 my %cd = parse_date
($co{'author_epoch'});
6938 # get list of changed files
6939 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6940 $co{'parent'} || "--root",
6941 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
6943 my @difftree = map { chomp; $_ } <$fd>;
6947 # print element (entry, item)
6948 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
6949 if ($format eq 'rss') {
6951 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
6952 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
6953 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
6954 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
6955 "<link>$co_url</link>\n" .
6956 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
6957 "<content:encoded>" .
6959 } elsif ($format eq 'atom') {
6961 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
6962 "<updated>$cd{'iso-8601'}</updated>\n" .
6964 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
6965 if ($co{'author_email'}) {
6966 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
6968 print "</author>\n" .
6969 # use committer for contributor
6971 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
6972 if ($co{'committer_email'}) {
6973 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
6975 print "</contributor>\n" .
6976 "<published>$cd{'iso-8601'}</published>\n" .
6977 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
6978 "<id>$co_url</id>\n" .
6979 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
6980 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
6982 my $comment = $co{'comment'};
6984 foreach my $line (@
$comment) {
6985 $line = esc_html
($line);
6988 print "</pre><ul>\n";
6989 foreach my $difftree_line (@difftree) {
6990 my %difftree = parse_difftree_raw_line
($difftree_line);
6991 next if !$difftree{'from_id'};
6993 my $file = $difftree{'file'} || $difftree{'to_file'};
6997 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
6998 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
6999 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
7000 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
7001 -title
=> "diff"}, 'D');
7003 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
7004 file_name
=>$file, hash_base
=>$commit),
7005 -title
=> "blame"}, 'B');
7007 # if this is not a feed of a file history
7008 if (!defined $file_name || $file_name ne $file) {
7009 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
7010 file_name
=>$file, hash
=>$commit),
7011 -title
=> "history"}, 'H');
7013 $file = esc_path
($file);
7017 if ($format eq 'rss') {
7018 print "</ul>]]>\n" .
7019 "</content:encoded>\n" .
7021 } elsif ($format eq 'atom') {
7022 print "</ul>\n</div>\n" .
7029 if ($format eq 'rss') {
7030 print "</channel>\n</rss>\n";
7031 } elsif ($format eq 'atom') {
7045 my @list = git_get_projects_list
();
7048 -type
=> 'text/xml',
7049 -charset
=> 'utf-8',
7050 -content_disposition
=> 'inline; filename="opml.xml"');
7053 <?xml version="1.0" encoding="utf-8"?>
7054 <opml version="1.0">
7056 <title>$site_name OPML Export</title>
7059 <outline text="git RSS feeds">
7062 foreach my $pr (@list) {
7064 my $head = git_get_head_hash
($proj{'path'});
7065 if (!defined $head) {
7068 $git_dir = "$projectroot/$proj{'path'}";
7069 my %co = parse_commit
($head);
7074 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
7075 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
7076 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
7077 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";