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 # information about snapshot formats that gitweb is capable of serving
170 our %known_snapshot_formats = (
172 # 'display' => display name,
173 # 'type' => mime type,
174 # 'suffix' => filename suffix,
175 # 'format' => --format for git-archive,
176 # 'compressor' => [compressor command and arguments]
177 # (array reference, optional)
178 # 'disabled' => boolean (optional)}
181 'display' => 'tar.gz',
182 'type' => 'application/x-gzip',
183 'suffix' => '.tar.gz',
185 'compressor' => ['gzip']},
188 'display' => 'tar.bz2',
189 'type' => 'application/x-bzip2',
190 'suffix' => '.tar.bz2',
192 'compressor' => ['bzip2']},
195 'display' => 'tar.xz',
196 'type' => 'application/x-xz',
197 'suffix' => '.tar.xz',
199 'compressor' => ['xz'],
204 'type' => 'application/x-zip',
209 # Aliases so we understand old gitweb.snapshot values in repository
211 our %known_snapshot_format_aliases = (
216 # backward compatibility: legacy gitweb config support
217 'x-gzip' => undef, 'gz' => undef,
218 'x-bzip2' => undef, 'bz2' => undef,
219 'x-zip' => undef, '' => undef,
222 # Pixel sizes for icons and avatars. If the default font sizes or lineheights
223 # are changed, it may be appropriate to change these values too via
230 # Used to set the maximum load that we will still respond to gitweb queries.
231 # If server load exceed this value then return "503 server busy" error.
232 # If gitweb cannot determined server load, it is taken to be 0.
233 # Leave it undefined (or set to 'undef') to turn off load checking.
236 # configuration for 'highlight' (http://www.andre-simon.de/)
238 our %highlight_basename = (
241 'SConstruct' => 'py', # SCons equivalent of Makefile
242 'Makefile' => 'make',
245 our %highlight_ext = (
246 # main extensions, defining name of syntax;
247 # see files in /usr/share/highlight/langDefs/ directory
249 qw(py c cpp rb java css php sh pl js tex bib xml awk bat ini spec tcl),
250 # alternate extensions, see /etc/highlight/filetypes.conf
252 map { $_ => 'cpp' } qw(cxx c++ cc),
253 map { $_ => 'php' } qw(php3 php4),
254 map { $_ => 'pl' } qw(perl pm), # perhaps also 'cgi'
256 map { $_ => 'xml' } qw(xhtml html htm),
259 # You define site-wide feature defaults here; override them with
260 # $GITWEB_CONFIG as necessary.
263 # 'sub' => feature-sub (subroutine),
264 # 'override' => allow-override (boolean),
265 # 'default' => [ default options...] (array reference)}
267 # if feature is overridable (it means that allow-override has true value),
268 # then feature-sub will be called with default options as parameters;
269 # return value of feature-sub indicates if to enable specified feature
271 # if there is no 'sub' key (no feature-sub), then feature cannot be
274 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
275 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
278 # Enable the 'blame' blob view, showing the last commit that modified
279 # each line in the file. This can be very CPU-intensive.
281 # To enable system wide have in $GITWEB_CONFIG
282 # $feature{'blame'}{'default'} = [1];
283 # To have project specific config enable override in $GITWEB_CONFIG
284 # $feature{'blame'}{'override'} = 1;
285 # and in project config gitweb.blame = 0|1;
287 'sub' => sub { feature_bool
('blame', @_) },
291 # Enable the 'snapshot' link, providing a compressed archive of any
292 # tree. This can potentially generate high traffic if you have large
295 # Value is a list of formats defined in %known_snapshot_formats that
297 # To disable system wide have in $GITWEB_CONFIG
298 # $feature{'snapshot'}{'default'} = [];
299 # To have project specific config enable override in $GITWEB_CONFIG
300 # $feature{'snapshot'}{'override'} = 1;
301 # and in project config, a comma-separated list of formats or "none"
302 # to disable. Example: gitweb.snapshot = tbz2,zip;
304 'sub' => \
&feature_snapshot
,
306 'default' => ['tgz']},
308 # Enable text search, which will list the commits which match author,
309 # committer or commit text to a given string. Enabled by default.
310 # Project specific override is not supported.
315 # Enable grep search, which will list the files in currently selected
316 # tree containing the given string. Enabled by default. This can be
317 # potentially CPU-intensive, of course.
319 # To enable system wide have in $GITWEB_CONFIG
320 # $feature{'grep'}{'default'} = [1];
321 # To have project specific config enable override in $GITWEB_CONFIG
322 # $feature{'grep'}{'override'} = 1;
323 # and in project config gitweb.grep = 0|1;
325 'sub' => sub { feature_bool
('grep', @_) },
329 # Enable the pickaxe search, which will list the commits that modified
330 # a given string in a file. This can be practical and quite faster
331 # alternative to 'blame', but still potentially CPU-intensive.
333 # To enable system wide have in $GITWEB_CONFIG
334 # $feature{'pickaxe'}{'default'} = [1];
335 # To have project specific config enable override in $GITWEB_CONFIG
336 # $feature{'pickaxe'}{'override'} = 1;
337 # and in project config gitweb.pickaxe = 0|1;
339 'sub' => sub { feature_bool
('pickaxe', @_) },
343 # Enable showing size of blobs in a 'tree' view, in a separate
344 # column, similar to what 'ls -l' does. This cost a bit of IO.
346 # To disable system wide have in $GITWEB_CONFIG
347 # $feature{'show-sizes'}{'default'} = [0];
348 # To have project specific config enable override in $GITWEB_CONFIG
349 # $feature{'show-sizes'}{'override'} = 1;
350 # and in project config gitweb.showsizes = 0|1;
352 'sub' => sub { feature_bool
('showsizes', @_) },
356 # Make gitweb use an alternative format of the URLs which can be
357 # more readable and natural-looking: project name is embedded
358 # directly in the path and the query string contains other
359 # auxiliary information. All gitweb installations recognize
360 # URL in either format; this configures in which formats gitweb
363 # To enable system wide have in $GITWEB_CONFIG
364 # $feature{'pathinfo'}{'default'} = [1];
365 # Project specific override is not supported.
367 # Note that you will need to change the default location of CSS,
368 # favicon, logo and possibly other files to an absolute URL. Also,
369 # if gitweb.cgi serves as your indexfile, you will need to force
370 # $my_uri to contain the script name in your $GITWEB_CONFIG.
375 # Make gitweb consider projects in project root subdirectories
376 # to be forks of existing projects. Given project $projname.git,
377 # projects matching $projname/*.git will not be shown in the main
378 # projects list, instead a '+' mark will be added to $projname
379 # there and a 'forks' view will be enabled for the project, listing
380 # all the forks. If project list is taken from a file, forks have
381 # to be listed after the main project.
383 # To enable system wide have in $GITWEB_CONFIG
384 # $feature{'forks'}{'default'} = [1];
385 # Project specific override is not supported.
390 # Insert custom links to the action bar of all project pages.
391 # This enables you mainly to link to third-party scripts integrating
392 # into gitweb; e.g. git-browser for graphical history representation
393 # or custom web-based repository administration interface.
395 # The 'default' value consists of a list of triplets in the form
396 # (label, link, position) where position is the label after which
397 # to insert the link and link is a format string where %n expands
398 # to the project name, %f to the project path within the filesystem,
399 # %h to the current hash (h gitweb parameter) and %b to the current
400 # hash base (hb gitweb parameter); %% expands to %.
402 # To enable system wide have in $GITWEB_CONFIG e.g.
403 # $feature{'actions'}{'default'} = [('graphiclog',
404 # '/git-browser/by-commit.html?r=%n', 'summary')];
405 # Project specific override is not supported.
410 # Allow gitweb scan project content tags described in ctags/
411 # of project repository, and display the popular Web 2.0-ish
412 # "tag cloud" near the project list. Note that this is something
413 # COMPLETELY different from the normal Git tags.
415 # gitweb by itself can show existing tags, but it does not handle
416 # tagging itself; you need an external application for that.
417 # For an example script, check Girocco's cgi/tagproj.cgi.
418 # You may want to install the HTML::TagCloud Perl module to get
419 # a pretty tag cloud instead of just a list of tags.
421 # To enable system wide have in $GITWEB_CONFIG
422 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
423 # Project specific override is not supported.
428 # The maximum number of patches in a patchset generated in patch
429 # view. Set this to 0 or undef to disable patch view, or to a
430 # negative number to remove any limit.
432 # To disable system wide have in $GITWEB_CONFIG
433 # $feature{'patches'}{'default'} = [0];
434 # To have project specific config enable override in $GITWEB_CONFIG
435 # $feature{'patches'}{'override'} = 1;
436 # and in project config gitweb.patches = 0|n;
437 # where n is the maximum number of patches allowed in a patchset.
439 'sub' => \
&feature_patches
,
443 # Avatar support. When this feature is enabled, views such as
444 # shortlog or commit will display an avatar associated with
445 # the email of the committer(s) and/or author(s).
447 # Currently available providers are gravatar and picon.
448 # If an unknown provider is specified, the feature is disabled.
450 # Gravatar depends on Digest::MD5.
451 # Picon currently relies on the indiana.edu database.
453 # To enable system wide have in $GITWEB_CONFIG
454 # $feature{'avatar'}{'default'} = ['<provider>'];
455 # where <provider> is either gravatar or picon.
456 # To have project specific config enable override in $GITWEB_CONFIG
457 # $feature{'avatar'}{'override'} = 1;
458 # and in project config gitweb.avatar = <provider>;
460 'sub' => \
&feature_avatar
,
464 # Enable displaying how much time and how many git commands
465 # it took to generate and display page. Disabled by default.
466 # Project specific override is not supported.
471 # Enable turning some links into links to actions which require
472 # JavaScript to run (like 'blame_incremental'). Not enabled by
473 # default. Project specific override is currently not supported.
474 'javascript-actions' => {
478 # Syntax highlighting support. This is based on Daniel Svensson's
479 # and Sham Chukoury's work in gitweb-xmms2.git.
480 # It requires the 'highlight' program present in $PATH,
481 # and therefore is disabled by default.
483 # To enable system wide have in $GITWEB_CONFIG
484 # $feature{'highlight'}{'default'} = [1];
487 'sub' => sub { feature_bool
('highlight', @_) },
492 sub gitweb_get_feature
{
494 return unless exists $feature{$name};
495 my ($sub, $override, @defaults) = (
496 $feature{$name}{'sub'},
497 $feature{$name}{'override'},
498 @
{$feature{$name}{'default'}});
499 # project specific override is possible only if we have project
500 our $git_dir; # global variable, declared later
501 if (!$override || !defined $git_dir) {
505 warn "feature $name is not overridable";
508 return $sub->(@defaults);
511 # A wrapper to check if a given feature is enabled.
512 # With this, you can say
514 # my $bool_feat = gitweb_check_feature('bool_feat');
515 # gitweb_check_feature('bool_feat') or somecode;
519 # my ($bool_feat) = gitweb_get_feature('bool_feat');
520 # (gitweb_get_feature('bool_feat'))[0] or somecode;
522 sub gitweb_check_feature
{
523 return (gitweb_get_feature
(@_))[0];
529 my ($val) = git_get_project_config
($key, '--bool');
533 } elsif ($val eq 'true') {
535 } elsif ($val eq 'false') {
540 sub feature_snapshot
{
543 my ($val) = git_get_project_config
('snapshot');
546 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
552 sub feature_patches
{
553 my @val = (git_get_project_config
('patches', '--int'));
563 my @val = (git_get_project_config
('avatar'));
565 return @val ?
@val : @_;
568 # checking HEAD file with -e is fragile if the repository was
569 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
571 sub check_head_link
{
573 my $headfile = "$dir/HEAD";
574 return ((-e
$headfile) ||
575 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
578 sub check_export_ok
{
580 return (check_head_link
($dir) &&
581 (!$export_ok || -e
"$dir/$export_ok") &&
582 (!$export_auth_hook || $export_auth_hook->($dir)));
585 # process alternate names for backward compatibility
586 # filter out unsupported (unknown) snapshot formats
587 sub filter_snapshot_fmts
{
591 exists $known_snapshot_format_aliases{$_} ?
592 $known_snapshot_format_aliases{$_} : $_} @fmts;
594 exists $known_snapshot_formats{$_} &&
595 !$known_snapshot_formats{$_}{'disabled'}} @fmts;
598 our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM);
599 sub evaluate_gitweb_config
{
600 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
601 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
602 # die if there are errors parsing config file
603 if (-e
$GITWEB_CONFIG) {
606 } elsif (-e
$GITWEB_CONFIG_SYSTEM) {
607 do $GITWEB_CONFIG_SYSTEM;
612 # Get loadavg of system, to compare against $maxload.
613 # Currently it requires '/proc/loadavg' present to get loadavg;
614 # if it is not present it returns 0, which means no load checking.
616 if( -e
'/proc/loadavg' ){
617 open my $fd, '<', '/proc/loadavg'
619 my @load = split(/\s+/, scalar <$fd>);
622 # The first three columns measure CPU and IO utilization of the last one,
623 # five, and 10 minute periods. The fourth column shows the number of
624 # currently running processes and the total number of processes in the m/n
625 # format. The last column displays the last process ID used.
626 return $load[0] || 0;
628 # additional checks for load average should go here for things that don't export
634 # version of the core git binary
636 sub evaluate_git_version
{
637 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
638 $number_of_git_cmds++;
642 if (defined $maxload && get_loadavg
() > $maxload) {
643 die_error
(503, "The load average on the server is too high");
647 # ======================================================================
648 # input validation and dispatch
650 # input parameters can be collected from a variety of sources (presently, CGI
651 # and PATH_INFO), so we define an %input_params hash that collects them all
652 # together during validation: this allows subsequent uses (e.g. href()) to be
653 # agnostic of the parameter origin
655 our %input_params = ();
657 # input parameters are stored with the long parameter name as key. This will
658 # also be used in the href subroutine to convert parameters to their CGI
659 # equivalent, and since the href() usage is the most frequent one, we store
660 # the name -> CGI key mapping here, instead of the reverse.
662 # XXX: Warning: If you touch this, check the search form for updating,
665 our @cgi_param_mapping = (
673 hash_parent_base
=> "hpb",
678 snapshot_format
=> "sf",
679 extra_options
=> "opt",
680 search_use_regexp
=> "sr",
681 # this must be last entry (for manipulation from JavaScript)
684 our %cgi_param_mapping = @cgi_param_mapping;
686 # we will also need to know the possible actions, for validation
688 "blame" => \
&git_blame
,
689 "blame_incremental" => \
&git_blame_incremental
,
690 "blame_data" => \
&git_blame_data
,
691 "blobdiff" => \
&git_blobdiff
,
692 "blobdiff_plain" => \
&git_blobdiff_plain
,
693 "blob" => \
&git_blob
,
694 "blob_plain" => \
&git_blob_plain
,
695 "commitdiff" => \
&git_commitdiff
,
696 "commitdiff_plain" => \
&git_commitdiff_plain
,
697 "commit" => \
&git_commit
,
698 "forks" => \
&git_forks
,
699 "heads" => \
&git_heads
,
700 "history" => \
&git_history
,
702 "patch" => \
&git_patch
,
703 "patches" => \
&git_patches
,
705 "atom" => \
&git_atom
,
706 "search" => \
&git_search
,
707 "search_help" => \
&git_search_help
,
708 "shortlog" => \
&git_shortlog
,
709 "summary" => \
&git_summary
,
711 "tags" => \
&git_tags
,
712 "tree" => \
&git_tree
,
713 "snapshot" => \
&git_snapshot
,
714 "object" => \
&git_object
,
715 # those below don't need $project
716 "opml" => \
&git_opml
,
717 "project_list" => \
&git_project_list
,
718 "project_index" => \
&git_project_index
,
721 # finally, we have the hash of allowed extra_options for the commands that
723 our %allowed_options = (
724 "--no-merges" => [ qw(rss atom log shortlog history) ],
727 # fill %input_params with the CGI parameters. All values except for 'opt'
728 # should be single values, but opt can be an array. We should probably
729 # build an array of parameters that can be multi-valued, but since for the time
730 # being it's only this one, we just single it out
731 sub evaluate_query_params
{
734 while (my ($name, $symbol) = each %cgi_param_mapping) {
735 if ($symbol eq 'opt') {
736 $input_params{$name} = [ $cgi->param($symbol) ];
738 $input_params{$name} = $cgi->param($symbol);
743 # now read PATH_INFO and update the parameter list for missing parameters
744 sub evaluate_path_info
{
745 return if defined $input_params{'project'};
746 return if !$path_info;
747 $path_info =~ s
,^/+,,;
748 return if !$path_info;
750 # find which part of PATH_INFO is project
751 my $project = $path_info;
753 while ($project && !check_head_link
("$projectroot/$project")) {
754 $project =~ s
,/*[^/]*$,,;
756 return unless $project;
757 $input_params{'project'} = $project;
759 # do not change any parameters if an action is given using the query string
760 return if $input_params{'action'};
761 $path_info =~ s
,^\Q
$project\E
/*,,;
763 # next, check if we have an action
764 my $action = $path_info;
766 if (exists $actions{$action}) {
767 $path_info =~ s
,^$action/*,,;
768 $input_params{'action'} = $action;
771 # list of actions that want hash_base instead of hash, but can have no
772 # pathname (f) parameter
779 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
780 my ($parentrefname, $parentpathname, $refname, $pathname) =
781 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?(.+?)(?::(.+))?$/);
783 # first, analyze the 'current' part
784 if (defined $pathname) {
785 # we got "branch:filename" or "branch:dir/"
786 # we could use git_get_type(branch:pathname), but:
787 # - it needs $git_dir
788 # - it does a git() call
789 # - the convention of terminating directories with a slash
790 # makes it superfluous
791 # - embedding the action in the PATH_INFO would make it even
793 $pathname =~ s
,^/+,,;
794 if (!$pathname || substr($pathname, -1) eq "/") {
795 $input_params{'action'} ||= "tree";
798 # the default action depends on whether we had parent info
800 if ($parentrefname) {
801 $input_params{'action'} ||= "blobdiff_plain";
803 $input_params{'action'} ||= "blob_plain";
806 $input_params{'hash_base'} ||= $refname;
807 $input_params{'file_name'} ||= $pathname;
808 } elsif (defined $refname) {
809 # we got "branch". In this case we have to choose if we have to
810 # set hash or hash_base.
812 # Most of the actions without a pathname only want hash to be
813 # set, except for the ones specified in @wants_base that want
814 # hash_base instead. It should also be noted that hand-crafted
815 # links having 'history' as an action and no pathname or hash
816 # set will fail, but that happens regardless of PATH_INFO.
817 $input_params{'action'} ||= "shortlog";
818 if (grep { $_ eq $input_params{'action'} } @wants_base) {
819 $input_params{'hash_base'} ||= $refname;
821 $input_params{'hash'} ||= $refname;
825 # next, handle the 'parent' part, if present
826 if (defined $parentrefname) {
827 # a missing pathspec defaults to the 'current' filename, allowing e.g.
828 # someproject/blobdiff/oldrev..newrev:/filename
829 if ($parentpathname) {
830 $parentpathname =~ s
,^/+,,;
831 $parentpathname =~ s
,/$,,;
832 $input_params{'file_parent'} ||= $parentpathname;
834 $input_params{'file_parent'} ||= $input_params{'file_name'};
836 # we assume that hash_parent_base is wanted if a path was specified,
837 # or if the action wants hash_base instead of hash
838 if (defined $input_params{'file_parent'} ||
839 grep { $_ eq $input_params{'action'} } @wants_base) {
840 $input_params{'hash_parent_base'} ||= $parentrefname;
842 $input_params{'hash_parent'} ||= $parentrefname;
846 # for the snapshot action, we allow URLs in the form
847 # $project/snapshot/$hash.ext
848 # where .ext determines the snapshot and gets removed from the
849 # passed $refname to provide the $hash.
851 # To be able to tell that $refname includes the format extension, we
852 # require the following two conditions to be satisfied:
853 # - the hash input parameter MUST have been set from the $refname part
854 # of the URL (i.e. they must be equal)
855 # - the snapshot format MUST NOT have been defined already (e.g. from
857 # It's also useless to try any matching unless $refname has a dot,
858 # so we check for that too
859 if (defined $input_params{'action'} &&
860 $input_params{'action'} eq 'snapshot' &&
861 defined $refname && index($refname, '.') != -1 &&
862 $refname eq $input_params{'hash'} &&
863 !defined $input_params{'snapshot_format'}) {
864 # We loop over the known snapshot formats, checking for
865 # extensions. Allowed extensions are both the defined suffix
866 # (which includes the initial dot already) and the snapshot
867 # format key itself, with a prepended dot
868 while (my ($fmt, $opt) = each %known_snapshot_formats) {
870 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
874 # a valid suffix was found, so set the snapshot format
875 # and reset the hash parameter
876 $input_params{'snapshot_format'} = $fmt;
877 $input_params{'hash'} = $hash;
878 # we also set the format suffix to the one requested
879 # in the URL: this way a request for e.g. .tgz returns
880 # a .tgz instead of a .tar.gz
881 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
887 our ($action, $project, $file_name, $file_parent, $hash, $hash_parent, $hash_base,
888 $hash_parent_base, @extra_options, $page, $searchtype, $search_use_regexp,
889 $searchtext, $search_regexp);
890 sub evaluate_and_validate_params
{
891 our $action = $input_params{'action'};
892 if (defined $action) {
893 if (!validate_action
($action)) {
894 die_error
(400, "Invalid action parameter");
898 # parameters which are pathnames
899 our $project = $input_params{'project'};
900 if (defined $project) {
901 if (!validate_project
($project)) {
903 die_error
(404, "No such project");
907 our $file_name = $input_params{'file_name'};
908 if (defined $file_name) {
909 if (!validate_pathname
($file_name)) {
910 die_error
(400, "Invalid file parameter");
914 our $file_parent = $input_params{'file_parent'};
915 if (defined $file_parent) {
916 if (!validate_pathname
($file_parent)) {
917 die_error
(400, "Invalid file parent parameter");
921 # parameters which are refnames
922 our $hash = $input_params{'hash'};
924 if (!validate_refname
($hash)) {
925 die_error
(400, "Invalid hash parameter");
929 our $hash_parent = $input_params{'hash_parent'};
930 if (defined $hash_parent) {
931 if (!validate_refname
($hash_parent)) {
932 die_error
(400, "Invalid hash parent parameter");
936 our $hash_base = $input_params{'hash_base'};
937 if (defined $hash_base) {
938 if (!validate_refname
($hash_base)) {
939 die_error
(400, "Invalid hash base parameter");
943 our @extra_options = @
{$input_params{'extra_options'}};
944 # @extra_options is always defined, since it can only be (currently) set from
945 # CGI, and $cgi->param() returns the empty array in array context if the param
947 foreach my $opt (@extra_options) {
948 if (not exists $allowed_options{$opt}) {
949 die_error
(400, "Invalid option parameter");
951 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
952 die_error
(400, "Invalid option parameter for this action");
956 our $hash_parent_base = $input_params{'hash_parent_base'};
957 if (defined $hash_parent_base) {
958 if (!validate_refname
($hash_parent_base)) {
959 die_error
(400, "Invalid hash parent base parameter");
964 our $page = $input_params{'page'};
966 if ($page =~ m/[^0-9]/) {
967 die_error
(400, "Invalid page parameter");
971 our $searchtype = $input_params{'searchtype'};
972 if (defined $searchtype) {
973 if ($searchtype =~ m/[^a-z]/) {
974 die_error
(400, "Invalid searchtype parameter");
978 our $search_use_regexp = $input_params{'search_use_regexp'};
980 our $searchtext = $input_params{'searchtext'};
982 if (defined $searchtext) {
983 if (length($searchtext) < 2) {
984 die_error
(403, "At least two characters are required for search parameter");
986 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
990 # path to the current git repository
992 sub evaluate_git_dir
{
993 our $git_dir = "$projectroot/$project" if $project;
996 our (@snapshot_fmts, $git_avatar);
997 sub configure_gitweb_features
{
998 # list of supported snapshot formats
999 our @snapshot_fmts = gitweb_get_feature
('snapshot');
1000 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1002 # check that the avatar feature is set to a known provider name,
1003 # and for each provider check if the dependencies are satisfied.
1004 # if the provider name is invalid or the dependencies are not met,
1005 # reset $git_avatar to the empty string.
1006 our ($git_avatar) = gitweb_get_feature
('avatar');
1007 if ($git_avatar eq 'gravatar') {
1008 $git_avatar = '' unless (eval { require Digest
::MD5
; 1; });
1009 } elsif ($git_avatar eq 'picon') {
1016 # custom error handler: 'die <message>' is Internal Server Error
1017 sub handle_errors_html
{
1018 my $msg = shift; # it is already HTML escaped
1020 # to avoid infinite loop where error occurs in die_error,
1021 # change handler to default handler, disabling handle_errors_html
1022 set_message
("Error occured when inside die_error:\n$msg");
1024 # you cannot jump out of die_error when called as error handler;
1025 # the subroutine set via CGI::Carp::set_message is called _after_
1026 # HTTP headers are already written, so it cannot write them itself
1027 die_error
(undef, undef, $msg, -error_handler
=> 1, -no_http_header
=> 1);
1029 set_message
(\
&handle_errors_html
);
1033 if (!defined $action) {
1034 if (defined $hash) {
1035 $action = git_get_type
($hash);
1036 } elsif (defined $hash_base && defined $file_name) {
1037 $action = git_get_type
("$hash_base:$file_name");
1038 } elsif (defined $project) {
1039 $action = 'summary';
1041 $action = 'project_list';
1044 if (!defined($actions{$action})) {
1045 die_error
(400, "Unknown action");
1047 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1049 die_error
(400, "Project needed");
1051 $actions{$action}->();
1055 our $t0 = [Time
::HiRes
::gettimeofday
()]
1057 our $number_of_git_cmds = 0;
1064 evaluate_gitweb_config
();
1067 # $projectroot and $projects_list might be set in gitweb config file
1068 $projects_list ||= $projectroot;
1070 evaluate_query_params
();
1071 evaluate_path_info
();
1072 evaluate_and_validate_params
();
1075 configure_gitweb_features
();
1080 our $is_last_request = sub { 1 };
1081 our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1084 sub configure_as_fcgi
{
1086 our $CGI = 'CGI::Fast';
1088 my $request_number = 0;
1089 # let each child service 100 requests
1090 our $is_last_request = sub { ++$request_number > 100 };
1093 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__
;
1095 if $script_name =~ /\.fcgi$/;
1097 return unless (@ARGV);
1099 require Getopt
::Long
;
1100 Getopt
::Long
::GetOptions
(
1101 'fastcgi|fcgi|f' => \
&configure_as_fcgi
,
1102 'nproc|n=i' => sub {
1103 my ($arg, $val) = @_;
1104 return unless eval { require FCGI
::ProcManager
; 1; };
1105 my $proc_manager = FCGI
::ProcManager
->new({
1106 n_processes
=> $val,
1108 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1109 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1110 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1117 evaluate_git_version
();
1119 $pre_listen_hook->()
1120 if $pre_listen_hook;
1123 while ($cgi = $CGI->new()) {
1124 $pre_dispatch_hook->()
1125 if $pre_dispatch_hook;
1129 $post_dispatch_hook->()
1130 if $post_dispatch_hook;
1132 last REQUEST
if ($is_last_request->());
1141 if (defined caller) {
1142 # wrapped in a subroutine processing requests,
1143 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1146 # pure CGI script, serving single request
1150 ## ======================================================================
1153 # possible values of extra options
1154 # -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1155 # -replay => 1 - start from a current view (replay with modifications)
1156 # -path_info => 0|1 - don't use/use path_info URL (if possible)
1159 # default is to use -absolute url() i.e. $my_uri
1160 my $href = $params{-full
} ?
$my_url : $my_uri;
1162 $params{'project'} = $project unless exists $params{'project'};
1164 if ($params{-replay
}) {
1165 while (my ($name, $symbol) = each %cgi_param_mapping) {
1166 if (!exists $params{$name}) {
1167 $params{$name} = $input_params{$name};
1172 my $use_pathinfo = gitweb_check_feature
('pathinfo');
1173 if (defined $params{'project'} &&
1174 (exists $params{-path_info
} ?
$params{-path_info
} : $use_pathinfo)) {
1175 # try to put as many parameters as possible in PATH_INFO:
1178 # - hash_parent or hash_parent_base:/file_parent
1179 # - hash or hash_base:/filename
1180 # - the snapshot_format as an appropriate suffix
1182 # When the script is the root DirectoryIndex for the domain,
1183 # $href here would be something like http://gitweb.example.com/
1184 # Thus, we strip any trailing / from $href, to spare us double
1185 # slashes in the final URL
1188 # Then add the project name, if present
1189 $href .= "/".esc_path_info
($params{'project'});
1190 delete $params{'project'};
1192 # since we destructively absorb parameters, we keep this
1193 # boolean that remembers if we're handling a snapshot
1194 my $is_snapshot = $params{'action'} eq 'snapshot';
1196 # Summary just uses the project path URL, any other action is
1198 if (defined $params{'action'}) {
1199 $href .= "/".esc_path_info
($params{'action'})
1200 unless $params{'action'} eq 'summary';
1201 delete $params{'action'};
1204 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1205 # stripping nonexistent or useless pieces
1206 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1207 || $params{'hash_parent'} || $params{'hash'});
1208 if (defined $params{'hash_base'}) {
1209 if (defined $params{'hash_parent_base'}) {
1210 $href .= esc_path_info
($params{'hash_parent_base'});
1211 # skip the file_parent if it's the same as the file_name
1212 if (defined $params{'file_parent'}) {
1213 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1214 delete $params{'file_parent'};
1215 } elsif ($params{'file_parent'} !~ /\.\./) {
1216 $href .= ":/".esc_path_info
($params{'file_parent'});
1217 delete $params{'file_parent'};
1221 delete $params{'hash_parent'};
1222 delete $params{'hash_parent_base'};
1223 } elsif (defined $params{'hash_parent'}) {
1224 $href .= esc_path_info
($params{'hash_parent'}). "..";
1225 delete $params{'hash_parent'};
1228 $href .= esc_path_info
($params{'hash_base'});
1229 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
1230 $href .= ":/".esc_path_info
($params{'file_name'});
1231 delete $params{'file_name'};
1233 delete $params{'hash'};
1234 delete $params{'hash_base'};
1235 } elsif (defined $params{'hash'}) {
1236 $href .= esc_path_info
($params{'hash'});
1237 delete $params{'hash'};
1240 # If the action was a snapshot, we can absorb the
1241 # snapshot_format parameter too
1243 my $fmt = $params{'snapshot_format'};
1244 # snapshot_format should always be defined when href()
1245 # is called, but just in case some code forgets, we
1246 # fall back to the default
1247 $fmt ||= $snapshot_fmts[0];
1248 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1249 delete $params{'snapshot_format'};
1253 # now encode the parameters explicitly
1255 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1256 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
1257 if (defined $params{$name}) {
1258 if (ref($params{$name}) eq "ARRAY") {
1259 foreach my $par (@
{$params{$name}}) {
1260 push @result, $symbol . "=" . esc_param
($par);
1263 push @result, $symbol . "=" . esc_param
($params{$name});
1267 $href .= "?" . join(';', @result) if scalar @result;
1269 # final transformation: trailing spaces must be escaped (URI-encoded)
1270 $href =~ s/(\s+)$/CGI::escape($1)/e;
1276 ## ======================================================================
1277 ## validation, quoting/unquoting and escaping
1279 sub validate_action
{
1280 my $input = shift || return undef;
1281 return undef unless exists $actions{$input};
1285 sub validate_project
{
1286 my $input = shift || return undef;
1287 if (!validate_pathname
($input) ||
1288 !(-d
"$projectroot/$input") ||
1289 !check_export_ok
("$projectroot/$input") ||
1290 ($strict_export && !project_in_list
($input))) {
1297 sub validate_pathname
{
1298 my $input = shift || return undef;
1300 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1301 # at the beginning, at the end, and between slashes.
1302 # also this catches doubled slashes
1303 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1306 # no null characters
1307 if ($input =~ m!\0!) {
1313 sub validate_refname
{
1314 my $input = shift || return undef;
1316 # textual hashes are O.K.
1317 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1320 # it must be correct pathname
1321 $input = validate_pathname
($input)
1323 # restrictions on ref name according to git-check-ref-format
1324 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1330 # decode sequences of octets in utf8 into Perl's internal form,
1331 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1332 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1335 return undef unless defined $str;
1336 if (utf8
::valid
($str)) {
1340 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
1344 # quote unsafe chars, but keep the slash, even when it's not
1345 # correct, but quoted slashes look too horrible in bookmarks
1348 return undef unless defined $str;
1349 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI
::escape
($1)/eg
;
1354 # the quoting rules for path_info fragment are slightly different
1357 return undef unless defined $str;
1359 # path_info doesn't treat '+' as space (specially), but '?' must be escaped
1360 $str =~ s/([^A-Za-z0-9\-_.~();\/;:@&= +]+)/CGI
::escape
($1)/eg
;
1365 # quote unsafe chars in whole URL, so some characters cannot be quoted
1368 return undef unless defined $str;
1369 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI
::escape
($1)/eg
;
1374 # replace invalid utf8 character with SUBSTITUTION sequence
1379 return undef unless defined $str;
1381 $str = to_utf8
($str);
1382 $str = $cgi->escapeHTML($str);
1383 if ($opts{'-nbsp'}) {
1384 $str =~ s/ / /g;
1386 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1390 # quote control characters and escape filename to HTML
1395 return undef unless defined $str;
1397 $str = to_utf8
($str);
1398 $str = $cgi->escapeHTML($str);
1399 if ($opts{'-nbsp'}) {
1400 $str =~ s/ / /g;
1402 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1406 # Make control characters "printable", using character escape codes (CEC)
1410 my %es = ( # character escape codes, aka escape sequences
1411 "\t" => '\t', # tab (HT)
1412 "\n" => '\n', # line feed (LF)
1413 "\r" => '\r', # carrige return (CR)
1414 "\f" => '\f', # form feed (FF)
1415 "\b" => '\b', # backspace (BS)
1416 "\a" => '\a', # alarm (bell) (BEL)
1417 "\e" => '\e', # escape (ESC)
1418 "\013" => '\v', # vertical tab (VT)
1419 "\000" => '\0', # nul character (NUL)
1421 my $chr = ( (exists $es{$cntrl})
1423 : sprintf('\%2x', ord($cntrl)) );
1424 if ($opts{-nohtml
}) {
1427 return "<span class=\"cntrl\">$chr</span>";
1431 # Alternatively use unicode control pictures codepoints,
1432 # Unicode "printable representation" (PR)
1437 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1438 if ($opts{-nohtml
}) {
1441 return "<span class=\"cntrl\">$chr</span>";
1445 # git may return quoted and escaped filenames
1451 my %es = ( # character escape codes, aka escape sequences
1452 't' => "\t", # tab (HT, TAB)
1453 'n' => "\n", # newline (NL)
1454 'r' => "\r", # return (CR)
1455 'f' => "\f", # form feed (FF)
1456 'b' => "\b", # backspace (BS)
1457 'a' => "\a", # alarm (bell) (BEL)
1458 'e' => "\e", # escape (ESC)
1459 'v' => "\013", # vertical tab (VT)
1462 if ($seq =~ m/^[0-7]{1,3}$/) {
1463 # octal char sequence
1464 return chr(oct($seq));
1465 } elsif (exists $es{$seq}) {
1466 # C escape sequence, aka character escape code
1469 # quoted ordinary character
1473 if ($str =~ m/^"(.*)"$/) {
1476 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1481 # escape tabs (convert tabs to spaces)
1485 while ((my $pos = index($line, "\t")) != -1) {
1486 if (my $count = (8 - ($pos % 8))) {
1487 my $spaces = ' ' x
$count;
1488 $line =~ s/\t/$spaces/;
1495 sub project_in_list
{
1496 my $project = shift;
1497 my @list = git_get_projects_list
();
1498 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1501 ## ----------------------------------------------------------------------
1502 ## HTML aware string manipulation
1504 # Try to chop given string on a word boundary between position
1505 # $len and $len+$add_len. If there is no word boundary there,
1506 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1507 # (marking chopped part) would be longer than given string.
1511 my $add_len = shift || 10;
1512 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1514 # Make sure perl knows it is utf8 encoded so we don't
1515 # cut in the middle of a utf8 multibyte char.
1516 $str = to_utf8
($str);
1518 # allow only $len chars, but don't cut a word if it would fit in $add_len
1519 # if it doesn't fit, cut it if it's still longer than the dots we would add
1520 # remove chopped character entities entirely
1522 # when chopping in the middle, distribute $len into left and right part
1523 # return early if chopping wouldn't make string shorter
1524 if ($where eq 'center') {
1525 return $str if ($len + 5 >= length($str)); # filler is length 5
1528 return $str if ($len + 4 >= length($str)); # filler is length 4
1531 # regexps: ending and beginning with word part up to $add_len
1532 my $endre = qr/.{$len}\w{0,$add_len}/;
1533 my $begre = qr/\w{0,$add_len}.{$len}/;
1535 if ($where eq 'left') {
1536 $str =~ m/^(.*?)($begre)$/;
1537 my ($lead, $body) = ($1, $2);
1538 if (length($lead) > 4) {
1541 return "$lead$body";
1543 } elsif ($where eq 'center') {
1544 $str =~ m/^($endre)(.*)$/;
1545 my ($left, $str) = ($1, $2);
1546 $str =~ m/^(.*?)($begre)$/;
1547 my ($mid, $right) = ($1, $2);
1548 if (length($mid) > 5) {
1551 return "$left$mid$right";
1554 $str =~ m/^($endre)(.*)$/;
1557 if (length($tail) > 4) {
1560 return "$body$tail";
1564 # takes the same arguments as chop_str, but also wraps a <span> around the
1565 # result with a title attribute if it does get chopped. Additionally, the
1566 # string is HTML-escaped.
1567 sub chop_and_escape_str
{
1570 my $chopped = chop_str
(@_);
1571 if ($chopped eq $str) {
1572 return esc_html
($chopped);
1574 $str =~ s/[[:cntrl:]]/?/g;
1575 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1579 ## ----------------------------------------------------------------------
1580 ## functions returning short strings
1582 # CSS class for given age value (in seconds)
1586 if (!defined $age) {
1588 } elsif ($age < 60*60*2) {
1590 } elsif ($age < 60*60*24*2) {
1597 # convert age in seconds to "nn units ago" string
1602 if ($age > 60*60*24*365*2) {
1603 $age_str = (int $age/60/60/24/365);
1604 $age_str .= " years ago";
1605 } elsif ($age > 60*60*24*(365/12)*2) {
1606 $age_str = int $age/60/60/24/(365/12);
1607 $age_str .= " months ago";
1608 } elsif ($age > 60*60*24*7*2) {
1609 $age_str = int $age/60/60/24/7;
1610 $age_str .= " weeks ago";
1611 } elsif ($age > 60*60*24*2) {
1612 $age_str = int $age/60/60/24;
1613 $age_str .= " days ago";
1614 } elsif ($age > 60*60*2) {
1615 $age_str = int $age/60/60;
1616 $age_str .= " hours ago";
1617 } elsif ($age > 60*2) {
1618 $age_str = int $age/60;
1619 $age_str .= " min ago";
1620 } elsif ($age > 2) {
1621 $age_str = int $age;
1622 $age_str .= " sec ago";
1624 $age_str .= " right now";
1630 S_IFINVALID
=> 0030000,
1631 S_IFGITLINK
=> 0160000,
1634 # submodule/subproject, a commit object reference
1638 return (($mode & S_IFMT
) == S_IFGITLINK
)
1641 # convert file mode in octal to symbolic file mode string
1643 my $mode = oct shift;
1645 if (S_ISGITLINK
($mode)) {
1646 return 'm---------';
1647 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1648 return 'drwxr-xr-x';
1649 } elsif (S_ISLNK
($mode)) {
1650 return 'lrwxrwxrwx';
1651 } elsif (S_ISREG
($mode)) {
1652 # git cares only about the executable bit
1653 if ($mode & S_IXUSR
) {
1654 return '-rwxr-xr-x';
1656 return '-rw-r--r--';
1659 return '----------';
1663 # convert file mode in octal to file type string
1667 if ($mode !~ m/^[0-7]+$/) {
1673 if (S_ISGITLINK
($mode)) {
1675 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1677 } elsif (S_ISLNK
($mode)) {
1679 } elsif (S_ISREG
($mode)) {
1686 # convert file mode in octal to file type description string
1687 sub file_type_long
{
1690 if ($mode !~ m/^[0-7]+$/) {
1696 if (S_ISGITLINK
($mode)) {
1698 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1700 } elsif (S_ISLNK
($mode)) {
1702 } elsif (S_ISREG
($mode)) {
1703 if ($mode & S_IXUSR
) {
1704 return "executable";
1714 ## ----------------------------------------------------------------------
1715 ## functions returning short HTML fragments, or transforming HTML fragments
1716 ## which don't belong to other sections
1718 # format line of commit message.
1719 sub format_log_line_html
{
1722 $line = esc_html
($line, -nbsp
=>1);
1723 $line =~ s
{\b([0-9a
-fA
-F
]{8,40})\b}{
1724 $cgi->a({-href
=> href
(action
=>"object", hash
=>$1),
1725 -class => "text"}, $1);
1731 # format marker of refs pointing to given object
1733 # the destination action is chosen based on object type and current context:
1734 # - for annotated tags, we choose the tag view unless it's the current view
1735 # already, in which case we go to shortlog view
1736 # - for other refs, we keep the current view if we're in history, shortlog or
1737 # log view, and select shortlog otherwise
1738 sub format_ref_marker
{
1739 my ($refs, $id) = @_;
1742 if (defined $refs->{$id}) {
1743 foreach my $ref (@
{$refs->{$id}}) {
1744 # this code exploits the fact that non-lightweight tags are the
1745 # only indirect objects, and that they are the only objects for which
1746 # we want to use tag instead of shortlog as action
1747 my ($type, $name) = qw();
1748 my $indirect = ($ref =~ s/\^\{\}$//);
1749 # e.g. tags/v2.6.11 or heads/next
1750 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1759 $class .= " indirect" if $indirect;
1761 my $dest_action = "shortlog";
1764 $dest_action = "tag" unless $action eq "tag";
1765 } elsif ($action =~ /^(history|(short)?log)$/) {
1766 $dest_action = $action;
1770 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1773 my $link = $cgi->a({
1775 action
=>$dest_action,
1779 $markers .= " <span class=\"$class\" title=\"$ref\">" .
1785 return ' <span class="refs">'. $markers . '</span>';
1791 # format, perhaps shortened and with markers, title line
1792 sub format_subject_html
{
1793 my ($long, $short, $href, $extra) = @_;
1794 $extra = '' unless defined($extra);
1796 if (length($short) < length($long)) {
1797 $long =~ s/[[:cntrl:]]/?/g;
1798 return $cgi->a({-href
=> $href, -class => "list subject",
1799 -title
=> to_utf8
($long)},
1800 esc_html
($short)) . $extra;
1802 return $cgi->a({-href
=> $href, -class => "list subject"},
1803 esc_html
($long)) . $extra;
1807 # Rather than recomputing the url for an email multiple times, we cache it
1808 # after the first hit. This gives a visible benefit in views where the avatar
1809 # for the same email is used repeatedly (e.g. shortlog).
1810 # The cache is shared by all avatar engines (currently gravatar only), which
1811 # are free to use it as preferred. Since only one avatar engine is used for any
1812 # given page, there's no risk for cache conflicts.
1813 our %avatar_cache = ();
1815 # Compute the picon url for a given email, by using the picon search service over at
1816 # http://www.cs.indiana.edu/picons/search.html
1818 my $email = lc shift;
1819 if (!$avatar_cache{$email}) {
1820 my ($user, $domain) = split('@', $email);
1821 $avatar_cache{$email} =
1822 "http://www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
1824 "users+domains+unknown/up/single";
1826 return $avatar_cache{$email};
1829 # Compute the gravatar url for a given email, if it's not in the cache already.
1830 # Gravatar stores only the part of the URL before the size, since that's the
1831 # one computationally more expensive. This also allows reuse of the cache for
1832 # different sizes (for this particular engine).
1834 my $email = lc shift;
1836 $avatar_cache{$email} ||=
1837 "http://www.gravatar.com/avatar/" .
1838 Digest
::MD5
::md5_hex
($email) . "?s=";
1839 return $avatar_cache{$email} . $size;
1842 # Insert an avatar for the given $email at the given $size if the feature
1844 sub git_get_avatar
{
1845 my ($email, %opts) = @_;
1846 my $pre_white = ($opts{-pad_before
} ?
" " : "");
1847 my $post_white = ($opts{-pad_after
} ?
" " : "");
1848 $opts{-size
} ||= 'default';
1849 my $size = $avatar_size{$opts{-size
}} || $avatar_size{'default'};
1851 if ($git_avatar eq 'gravatar') {
1852 $url = gravatar_url
($email, $size);
1853 } elsif ($git_avatar eq 'picon') {
1854 $url = picon_url
($email);
1856 # Other providers can be added by extending the if chain, defining $url
1857 # as needed. If no variant puts something in $url, we assume avatars
1858 # are completely disabled/unavailable.
1861 "<img width=\"$size\" " .
1862 "class=\"avatar\" " .
1871 sub format_search_author
{
1872 my ($author, $searchtype, $displaytext) = @_;
1873 my $have_search = gitweb_check_feature
('search');
1877 if ($searchtype eq 'author') {
1878 $performed = "authored";
1879 } elsif ($searchtype eq 'committer') {
1880 $performed = "committed";
1883 return $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
1884 searchtext
=>$author,
1885 searchtype
=>$searchtype), class=>"list",
1886 title
=>"Search for commits $performed by $author"},
1890 return $displaytext;
1894 # format the author name of the given commit with the given tag
1895 # the author name is chopped and escaped according to the other
1896 # optional parameters (see chop_str).
1897 sub format_author_html
{
1900 my $author = chop_and_escape_str
($co->{'author_name'}, @_);
1901 return "<$tag class=\"author\">" .
1902 format_search_author
($co->{'author_name'}, "author",
1903 git_get_avatar
($co->{'author_email'}, -pad_after
=> 1) .
1908 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1909 sub format_git_diff_header_line
{
1911 my $diffinfo = shift;
1912 my ($from, $to) = @_;
1914 if ($diffinfo->{'nparents'}) {
1916 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1917 if ($to->{'href'}) {
1918 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1919 esc_path
($to->{'file'}));
1920 } else { # file was deleted (no href)
1921 $line .= esc_path
($to->{'file'});
1925 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1926 if ($from->{'href'}) {
1927 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
1928 'a/' . esc_path
($from->{'file'}));
1929 } else { # file was added (no href)
1930 $line .= 'a/' . esc_path
($from->{'file'});
1933 if ($to->{'href'}) {
1934 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1935 'b/' . esc_path
($to->{'file'}));
1936 } else { # file was deleted
1937 $line .= 'b/' . esc_path
($to->{'file'});
1941 return "<div class=\"diff header\">$line</div>\n";
1944 # format extended diff header line, before patch itself
1945 sub format_extended_diff_header_line
{
1947 my $diffinfo = shift;
1948 my ($from, $to) = @_;
1951 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1952 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1953 esc_path
($from->{'file'}));
1955 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1956 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1957 esc_path
($to->{'file'}));
1959 # match single <mode>
1960 if ($line =~ m/\s(\d{6})$/) {
1961 $line .= '<span class="info"> (' .
1962 file_type_long
($1) .
1966 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1967 # can match only for combined diff
1969 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1970 if ($from->{'href'}[$i]) {
1971 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
1973 substr($diffinfo->{'from_id'}[$i],0,7));
1978 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1981 if ($to->{'href'}) {
1982 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1983 substr($diffinfo->{'to_id'},0,7));
1988 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
1989 # can match only for ordinary diff
1990 my ($from_link, $to_link);
1991 if ($from->{'href'}) {
1992 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
1993 substr($diffinfo->{'from_id'},0,7));
1995 $from_link = '0' x
7;
1997 if ($to->{'href'}) {
1998 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1999 substr($diffinfo->{'to_id'},0,7));
2003 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2004 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2007 return $line . "<br/>\n";
2010 # format from-file/to-file diff header
2011 sub format_diff_from_to_header
{
2012 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
2017 #assert($line =~ m/^---/) if DEBUG;
2018 # no extra formatting for "^--- /dev/null"
2019 if (! $diffinfo->{'nparents'}) {
2020 # ordinary (single parent) diff
2021 if ($line =~ m!^--- "?a/!) {
2022 if ($from->{'href'}) {
2024 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2025 esc_path
($from->{'file'}));
2028 esc_path
($from->{'file'});
2031 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2034 # combined diff (merge commit)
2035 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2036 if ($from->{'href'}[$i]) {
2038 $cgi->a({-href
=>href
(action
=>"blobdiff",
2039 hash_parent
=>$diffinfo->{'from_id'}[$i],
2040 hash_parent_base
=>$parents[$i],
2041 file_parent
=>$from->{'file'}[$i],
2042 hash
=>$diffinfo->{'to_id'},
2044 file_name
=>$to->{'file'}),
2046 -title
=>"diff" . ($i+1)},
2049 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
2050 esc_path
($from->{'file'}[$i]));
2052 $line = '--- /dev/null';
2054 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2059 #assert($line =~ m/^\+\+\+/) if DEBUG;
2060 # no extra formatting for "^+++ /dev/null"
2061 if ($line =~ m!^\+\+\+ "?b/!) {
2062 if ($to->{'href'}) {
2064 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2065 esc_path
($to->{'file'}));
2068 esc_path
($to->{'file'});
2071 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
2076 # create note for patch simplified by combined diff
2077 sub format_diff_cc_simplified
{
2078 my ($diffinfo, @parents) = @_;
2081 $result .= "<div class=\"diff header\">" .
2083 if (!is_deleted
($diffinfo)) {
2084 $result .= $cgi->a({-href
=> href
(action
=>"blob",
2086 hash
=>$diffinfo->{'to_id'},
2087 file_name
=>$diffinfo->{'to_file'}),
2089 esc_path
($diffinfo->{'to_file'}));
2091 $result .= esc_path
($diffinfo->{'to_file'});
2093 $result .= "</div>\n" . # class="diff header"
2094 "<div class=\"diff nodifferences\">" .
2096 "</div>\n"; # class="diff nodifferences"
2101 # format patch (diff) line (not to be used for diff headers)
2102 sub format_diff_line
{
2104 my ($from, $to) = @_;
2105 my $diff_class = "";
2109 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2111 my $prefix = substr($line, 0, scalar @
{$from->{'href'}});
2112 if ($line =~ m/^\@{3}/) {
2113 $diff_class = " chunk_header";
2114 } elsif ($line =~ m/^\\/) {
2115 $diff_class = " incomplete";
2116 } elsif ($prefix =~ tr/+/+/) {
2117 $diff_class = " add";
2118 } elsif ($prefix =~ tr/-/-/) {
2119 $diff_class = " rem";
2122 # assume ordinary diff
2123 my $char = substr($line, 0, 1);
2125 $diff_class = " add";
2126 } elsif ($char eq '-') {
2127 $diff_class = " rem";
2128 } elsif ($char eq '@') {
2129 $diff_class = " chunk_header";
2130 } elsif ($char eq "\\") {
2131 $diff_class = " incomplete";
2134 $line = untabify
($line);
2135 if ($from && $to && $line =~ m/^\@{2} /) {
2136 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2137 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2139 $from_lines = 0 unless defined $from_lines;
2140 $to_lines = 0 unless defined $to_lines;
2142 if ($from->{'href'}) {
2143 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
2144 -class=>"list"}, $from_text);
2146 if ($to->{'href'}) {
2147 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2148 -class=>"list"}, $to_text);
2150 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2151 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2152 return "<div class=\"diff$diff_class\">$line</div>\n";
2153 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2154 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2155 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2157 @from_text = split(' ', $ranges);
2158 for (my $i = 0; $i < @from_text; ++$i) {
2159 ($from_start[$i], $from_nlines[$i]) =
2160 (split(',', substr($from_text[$i], 1)), 0);
2163 $to_text = pop @from_text;
2164 $to_start = pop @from_start;
2165 $to_nlines = pop @from_nlines;
2167 $line = "<span class=\"chunk_info\">$prefix ";
2168 for (my $i = 0; $i < @from_text; ++$i) {
2169 if ($from->{'href'}[$i]) {
2170 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
2171 -class=>"list"}, $from_text[$i]);
2173 $line .= $from_text[$i];
2177 if ($to->{'href'}) {
2178 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2179 -class=>"list"}, $to_text);
2183 $line .= " $prefix</span>" .
2184 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2185 return "<div class=\"diff$diff_class\">$line</div>\n";
2187 return "<div class=\"diff$diff_class\">" . esc_html
($line, -nbsp
=>1) . "</div>\n";
2190 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2191 # linked. Pass the hash of the tree/commit to snapshot.
2192 sub format_snapshot_links
{
2194 my $num_fmts = @snapshot_fmts;
2195 if ($num_fmts > 1) {
2196 # A parenthesized list of links bearing format names.
2197 # e.g. "snapshot (_tar.gz_ _zip_)"
2198 return "snapshot (" . join(' ', map
2205 }, $known_snapshot_formats{$_}{'display'})
2206 , @snapshot_fmts) . ")";
2207 } elsif ($num_fmts == 1) {
2208 # A single "snapshot" link whose tooltip bears the format name.
2210 my ($fmt) = @snapshot_fmts;
2216 snapshot_format
=>$fmt
2218 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
2220 } else { # $num_fmts == 0
2225 ## ......................................................................
2226 ## functions returning values to be passed, perhaps after some
2227 ## transformation, to other functions; e.g. returning arguments to href()
2229 # returns hash to be passed to href to generate gitweb URL
2230 # in -title key it returns description of link
2232 my $format = shift || 'Atom';
2233 my %res = (action
=> lc($format));
2235 # feed links are possible only for project views
2236 return unless (defined $project);
2237 # some views should link to OPML, or to generic project feed,
2238 # or don't have specific feed yet (so they should use generic)
2239 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
2242 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
2243 # from tag links; this also makes possible to detect branch links
2244 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
2245 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
2248 # find log type for feed description (title)
2250 if (defined $file_name) {
2251 $type = "history of $file_name";
2252 $type .= "/" if ($action eq 'tree');
2253 $type .= " on '$branch'" if (defined $branch);
2255 $type = "log of $branch" if (defined $branch);
2258 $res{-title
} = $type;
2259 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
2260 $res{'file_name'} = $file_name;
2265 ## ----------------------------------------------------------------------
2266 ## git utility subroutines, invoking git commands
2268 # returns path to the core git executable and the --git-dir parameter as list
2270 $number_of_git_cmds++;
2271 return $GIT, '--git-dir='.$git_dir;
2274 # quote the given arguments for passing them to the shell
2275 # quote_command("command", "arg 1", "arg with ' and ! characters")
2276 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2277 # Try to avoid using this function wherever possible.
2280 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
2283 # get HEAD ref of given project as hash
2284 sub git_get_head_hash
{
2285 return git_get_full_hash
(shift, 'HEAD');
2288 sub git_get_full_hash
{
2289 return git_get_hash
(@_);
2292 sub git_get_short_hash
{
2293 return git_get_hash
(@_, '--short=7');
2297 my ($project, $hash, @options) = @_;
2298 my $o_git_dir = $git_dir;
2300 $git_dir = "$projectroot/$project";
2301 if (open my $fd, '-|', git_cmd
(), 'rev-parse',
2302 '--verify', '-q', @options, $hash) {
2304 chomp $retval if defined $retval;
2307 if (defined $o_git_dir) {
2308 $git_dir = $o_git_dir;
2313 # get type of given object
2317 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
2319 close $fd or return;
2324 # repository configuration
2325 our $config_file = '';
2328 # store multiple values for single key as anonymous array reference
2329 # single values stored directly in the hash, not as [ <value> ]
2330 sub hash_set_multi
{
2331 my ($hash, $key, $value) = @_;
2333 if (!exists $hash->{$key}) {
2334 $hash->{$key} = $value;
2335 } elsif (!ref $hash->{$key}) {
2336 $hash->{$key} = [ $hash->{$key}, $value ];
2338 push @
{$hash->{$key}}, $value;
2342 # return hash of git project configuration
2343 # optionally limited to some section, e.g. 'gitweb'
2344 sub git_parse_project_config
{
2345 my $section_regexp = shift;
2350 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
2353 while (my $keyval = <$fh>) {
2355 my ($key, $value) = split(/\n/, $keyval, 2);
2357 hash_set_multi
(\
%config, $key, $value)
2358 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2365 # convert config value to boolean: 'true' or 'false'
2366 # no value, number > 0, 'true' and 'yes' values are true
2367 # rest of values are treated as false (never as error)
2368 sub config_to_bool
{
2371 return 1 if !defined $val; # section.key
2373 # strip leading and trailing whitespace
2377 return (($val =~ /^\d+$/ && $val) || # section.key = 1
2378 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2381 # convert config value to simple decimal number
2382 # an optional value suffix of 'k', 'm', or 'g' will cause the value
2383 # to be multiplied by 1024, 1048576, or 1073741824
2387 # strip leading and trailing whitespace
2391 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2393 # unknown unit is treated as 1
2394 return $num * ($unit eq 'g' ?
1073741824 :
2395 $unit eq 'm' ?
1048576 :
2396 $unit eq 'k' ?
1024 : 1);
2401 # convert config value to array reference, if needed
2402 sub config_to_multi
{
2405 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
2408 sub git_get_project_config
{
2409 my ($key, $type) = @_;
2411 return unless defined $git_dir;
2414 return unless ($key);
2415 $key =~ s/^gitweb\.//;
2416 return if ($key =~ m/\W/);
2419 if (defined $type) {
2422 unless ($type eq 'bool' || $type eq 'int');
2426 if (!defined $config_file ||
2427 $config_file ne "$git_dir/config") {
2428 %config = git_parse_project_config
('gitweb');
2429 $config_file = "$git_dir/config";
2432 # check if config variable (key) exists
2433 return unless exists $config{"gitweb.$key"};
2436 if (!defined $type) {
2437 return $config{"gitweb.$key"};
2438 } elsif ($type eq 'bool') {
2439 # backward compatibility: 'git config --bool' returns true/false
2440 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
2441 } elsif ($type eq 'int') {
2442 return config_to_int
($config{"gitweb.$key"});
2444 return $config{"gitweb.$key"};
2447 # get hash of given path at given ref
2448 sub git_get_hash_by_path
{
2450 my $path = shift || return undef;
2455 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
2456 or die_error
(500, "Open git-ls-tree failed");
2458 close $fd or return undef;
2460 if (!defined $line) {
2461 # there is no tree or hash given by $path at $base
2465 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2466 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2467 if (defined $type && $type ne $2) {
2468 # type doesn't match
2474 # get path of entry with given hash at given tree-ish (ref)
2475 # used to get 'from' filename for combined diff (merge commit) for renames
2476 sub git_get_path_by_hash
{
2477 my $base = shift || return;
2478 my $hash = shift || return;
2482 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
2484 while (my $line = <$fd>) {
2487 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2488 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2489 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2498 ## ......................................................................
2499 ## git utility functions, directly accessing git repository
2501 sub git_get_project_description
{
2504 $git_dir = "$projectroot/$path";
2505 open my $fd, '<', "$git_dir/description"
2506 or return git_get_project_config
('description');
2509 if (defined $descr) {
2515 sub git_get_project_ctags
{
2519 $git_dir = "$projectroot/$path";
2520 opendir my $dh, "$git_dir/ctags"
2522 foreach (grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir($dh)) {
2523 open my $ct, '<', $_ or next;
2527 my $ctag = $_; $ctag =~ s
#.*/##;
2528 $ctags->{$ctag} = $val;
2534 sub git_populate_project_tagcloud
{
2537 # First, merge different-cased tags; tags vote on casing
2539 foreach (keys %$ctags) {
2540 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2541 if (not $ctags_lc{lc $_}->{topcount
}
2542 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2543 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2544 $ctags_lc{lc $_}->{topname
} = $_;
2549 if (eval { require HTML
::TagCloud
; 1; }) {
2550 $cloud = HTML
::TagCloud
->new;
2551 foreach (sort keys %ctags_lc) {
2552 # Pad the title with spaces so that the cloud looks
2554 my $title = $ctags_lc{$_}->{topname
};
2555 $title =~ s/ / /g;
2556 $title =~ s/^/ /g;
2557 $title =~ s/$/ /g;
2558 $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count
});
2561 $cloud = \
%ctags_lc;
2566 sub git_show_project_tagcloud
{
2567 my ($cloud, $count) = @_;
2568 print STDERR
ref($cloud)."..\n";
2569 if (ref $cloud eq 'HTML::TagCloud') {
2570 return $cloud->html_and_css($count);
2572 my @tags = sort { $cloud->{$a}->{count
} <=> $cloud->{$b}->{count
} } keys %$cloud;
2573 return '<p align="center">' . join (', ', map {
2574 "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
2575 } splice(@tags, 0, $count)) . '</p>';
2579 sub git_get_project_url_list
{
2582 $git_dir = "$projectroot/$path";
2583 open my $fd, '<', "$git_dir/cloneurl"
2584 or return wantarray ?
2585 @
{ config_to_multi
(git_get_project_config
('url')) } :
2586 config_to_multi
(git_get_project_config
('url'));
2587 my @git_project_url_list = map { chomp; $_ } <$fd>;
2590 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2593 sub git_get_projects_list
{
2598 $filter =~ s/\.git$//;
2600 my $check_forks = gitweb_check_feature
('forks');
2602 if (-d
$projects_list) {
2603 # search in directory
2604 my $dir = $projects_list . ($filter ?
"/$filter" : '');
2605 # remove the trailing "/"
2607 my $pfxlen = length("$dir");
2608 my $pfxdepth = ($dir =~ tr!/!!);
2611 follow_fast
=> 1, # follow symbolic links
2612 follow_skip
=> 2, # ignore duplicates
2613 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2616 our $project_maxdepth;
2618 # skip project-list toplevel, if we get it.
2619 return if (m!^[/.]$!);
2620 # only directories can be git repositories
2621 return unless (-d
$_);
2622 # don't traverse too deep (Find is super slow on os x)
2623 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2624 $File::Find
::prune
= 1;
2628 my $subdir = substr($File::Find
::name
, $pfxlen + 1);
2629 # we check related file in $projectroot
2630 my $path = ($filter ?
"$filter/" : '') . $subdir;
2631 if (check_export_ok
("$projectroot/$path")) {
2632 push @list, { path
=> $path };
2633 $File::Find
::prune
= 1;
2638 } elsif (-f
$projects_list) {
2639 # read from file(url-encoded):
2640 # 'git%2Fgit.git Linus+Torvalds'
2641 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2642 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2644 open my $fd, '<', $projects_list or return;
2646 while (my $line = <$fd>) {
2648 my ($path, $owner) = split ' ', $line;
2649 $path = unescape
($path);
2650 $owner = unescape
($owner);
2651 if (!defined $path) {
2654 if ($filter ne '') {
2655 # looking for forks;
2656 my $pfx = substr($path, 0, length($filter));
2657 if ($pfx ne $filter) {
2660 my $sfx = substr($path, length($filter));
2661 if ($sfx !~ /^\/.*\
.git
$/) {
2664 } elsif ($check_forks) {
2666 foreach my $filter (keys %paths) {
2667 # looking for forks;
2668 my $pfx = substr($path, 0, length($filter));
2669 if ($pfx ne $filter) {
2672 my $sfx = substr($path, length($filter));
2673 if ($sfx !~ /^\/.*\
.git
$/) {
2676 # is a fork, don't include it in
2681 if (check_export_ok
("$projectroot/$path")) {
2684 owner
=> to_utf8
($owner),
2687 (my $forks_path = $path) =~ s/\.git$//;
2688 $paths{$forks_path}++;
2696 our $gitweb_project_owner = undef;
2697 sub git_get_project_list_from_file
{
2699 return if (defined $gitweb_project_owner);
2701 $gitweb_project_owner = {};
2702 # read from file (url-encoded):
2703 # 'git%2Fgit.git Linus+Torvalds'
2704 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2705 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2706 if (-f
$projects_list) {
2707 open(my $fd, '<', $projects_list);
2708 while (my $line = <$fd>) {
2710 my ($pr, $ow) = split ' ', $line;
2711 $pr = unescape
($pr);
2712 $ow = unescape
($ow);
2713 $gitweb_project_owner->{$pr} = to_utf8
($ow);
2719 sub git_get_project_owner
{
2720 my $project = shift;
2723 return undef unless $project;
2724 $git_dir = "$projectroot/$project";
2726 if (!defined $gitweb_project_owner) {
2727 git_get_project_list_from_file
();
2730 if (exists $gitweb_project_owner->{$project}) {
2731 $owner = $gitweb_project_owner->{$project};
2733 if (!defined $owner){
2734 $owner = git_get_project_config
('owner');
2736 if (!defined $owner) {
2737 $owner = get_file_owner
("$git_dir");
2743 sub git_get_last_activity
{
2747 $git_dir = "$projectroot/$path";
2748 open($fd, "-|", git_cmd
(), 'for-each-ref',
2749 '--format=%(committer)',
2750 '--sort=-committerdate',
2752 'refs/heads') or return;
2753 my $most_recent = <$fd>;
2754 close $fd or return;
2755 if (defined $most_recent &&
2756 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2758 my $age = time - $timestamp;
2759 return ($age, age_string
($age));
2761 return (undef, undef);
2764 sub git_get_references
{
2765 my $type = shift || "";
2767 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2768 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2769 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
2770 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
2773 while (my $line = <$fd>) {
2775 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2776 if (defined $refs{$1}) {
2777 push @
{$refs{$1}}, $2;
2783 close $fd or return;
2787 sub git_get_rev_name_tags
{
2788 my $hash = shift || return undef;
2790 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
2792 my $name_rev = <$fd>;
2795 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
2798 # catches also '$hash undefined' output
2803 ## ----------------------------------------------------------------------
2804 ## parse to hash functions
2808 my $tz = shift || "-0000";
2811 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2812 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2813 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2814 $date{'hour'} = $hour;
2815 $date{'minute'} = $min;
2816 $date{'mday'} = $mday;
2817 $date{'day'} = $days[$wday];
2818 $date{'month'} = $months[$mon];
2819 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2820 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2821 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2822 $mday, $months[$mon], $hour ,$min;
2823 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2824 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2826 $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2827 my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2828 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2829 $date{'hour_local'} = $hour;
2830 $date{'minute_local'} = $min;
2831 $date{'tz_local'} = $tz;
2832 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2833 1900+$year, $mon+1, $mday,
2834 $hour, $min, $sec, $tz);
2843 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
2844 $tag{'id'} = $tag_id;
2845 while (my $line = <$fd>) {
2847 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2848 $tag{'object'} = $1;
2849 } elsif ($line =~ m/^type (.+)$/) {
2851 } elsif ($line =~ m/^tag (.+)$/) {
2853 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2854 $tag{'author'} = $1;
2855 $tag{'author_epoch'} = $2;
2856 $tag{'author_tz'} = $3;
2857 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2858 $tag{'author_name'} = $1;
2859 $tag{'author_email'} = $2;
2861 $tag{'author_name'} = $tag{'author'};
2863 } elsif ($line =~ m/--BEGIN/) {
2864 push @comment, $line;
2866 } elsif ($line eq "") {
2870 push @comment, <$fd>;
2871 $tag{'comment'} = \
@comment;
2872 close $fd or return;
2873 if (!defined $tag{'name'}) {
2879 sub parse_commit_text
{
2880 my ($commit_text, $withparents) = @_;
2881 my @commit_lines = split '\n', $commit_text;
2884 pop @commit_lines; # Remove '\0'
2886 if (! @commit_lines) {
2890 my $header = shift @commit_lines;
2891 if ($header !~ m/^[0-9a-fA-F]{40}/) {
2894 ($co{'id'}, my @parents) = split ' ', $header;
2895 while (my $line = shift @commit_lines) {
2896 last if $line eq "\n";
2897 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2899 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2901 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2902 $co{'author'} = to_utf8
($1);
2903 $co{'author_epoch'} = $2;
2904 $co{'author_tz'} = $3;
2905 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2906 $co{'author_name'} = $1;
2907 $co{'author_email'} = $2;
2909 $co{'author_name'} = $co{'author'};
2911 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2912 $co{'committer'} = to_utf8
($1);
2913 $co{'committer_epoch'} = $2;
2914 $co{'committer_tz'} = $3;
2915 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2916 $co{'committer_name'} = $1;
2917 $co{'committer_email'} = $2;
2919 $co{'committer_name'} = $co{'committer'};
2923 if (!defined $co{'tree'}) {
2926 $co{'parents'} = \
@parents;
2927 $co{'parent'} = $parents[0];
2929 foreach my $title (@commit_lines) {
2932 $co{'title'} = chop_str
($title, 80, 5);
2933 # remove leading stuff of merges to make the interesting part visible
2934 if (length($title) > 50) {
2935 $title =~ s/^Automatic //;
2936 $title =~ s/^merge (of|with) /Merge ... /i;
2937 if (length($title) > 50) {
2938 $title =~ s/(http|rsync):\/\///;
2940 if (length($title) > 50) {
2941 $title =~ s/(master|www|rsync)\.//;
2943 if (length($title) > 50) {
2944 $title =~ s/kernel.org:?//;
2946 if (length($title) > 50) {
2947 $title =~ s/\/pub\/scm//;
2950 $co{'title_short'} = chop_str
($title, 50, 5);
2954 if (! defined $co{'title'} || $co{'title'} eq "") {
2955 $co{'title'} = $co{'title_short'} = '(no commit message)';
2957 # remove added spaces
2958 foreach my $line (@commit_lines) {
2961 $co{'comment'} = \
@commit_lines;
2963 my $age = time - $co{'committer_epoch'};
2965 $co{'age_string'} = age_string
($age);
2966 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2967 if ($age > 60*60*24*7*2) {
2968 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2969 $co{'age_string_age'} = $co{'age_string'};
2971 $co{'age_string_date'} = $co{'age_string'};
2972 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2978 my ($commit_id) = @_;
2983 open my $fd, "-|", git_cmd
(), "rev-list",
2989 or die_error
(500, "Open git-rev-list failed");
2990 %co = parse_commit_text
(<$fd>, 1);
2997 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
3005 open my $fd, "-|", git_cmd
(), "rev-list",
3008 ("--max-count=" . $maxcount),
3009 ("--skip=" . $skip),
3013 ($filename ?
($filename) : ())
3014 or die_error
(500, "Open git-rev-list failed");
3015 while (my $line = <$fd>) {
3016 my %co = parse_commit_text
($line);
3021 return wantarray ?
@cos : \
@cos;
3024 # parse line of git-diff-tree "raw" output
3025 sub parse_difftree_raw_line
{
3029 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3030 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
3031 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
3032 $res{'from_mode'} = $1;
3033 $res{'to_mode'} = $2;
3034 $res{'from_id'} = $3;
3036 $res{'status'} = $5;
3037 $res{'similarity'} = $6;
3038 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
3039 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
3041 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
3044 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3045 # combined diff (for merge commit)
3046 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
3047 $res{'nparents'} = length($1);
3048 $res{'from_mode'} = [ split(' ', $2) ];
3049 $res{'to_mode'} = pop @
{$res{'from_mode'}};
3050 $res{'from_id'} = [ split(' ', $3) ];
3051 $res{'to_id'} = pop @
{$res{'from_id'}};
3052 $res{'status'} = [ split('', $4) ];
3053 $res{'to_file'} = unquote
($5);
3055 # 'c512b523472485aef4fff9e57b229d9d243c967f'
3056 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
3057 $res{'commit'} = $1;
3060 return wantarray ?
%res : \
%res;
3063 # wrapper: return parsed line of git-diff-tree "raw" output
3064 # (the argument might be raw line, or parsed info)
3065 sub parsed_difftree_line
{
3066 my $line_or_ref = shift;
3068 if (ref($line_or_ref) eq "HASH") {
3069 # pre-parsed (or generated by hand)
3070 return $line_or_ref;
3072 return parse_difftree_raw_line
($line_or_ref);
3076 # parse line of git-ls-tree output
3077 sub parse_ls_tree_line
{
3083 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
3084 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40}) +(-|[0-9]+)\t(.+)$/s;
3093 $res{'name'} = unquote
($5);
3096 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
3097 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
3105 $res{'name'} = unquote
($4);
3109 return wantarray ?
%res : \
%res;
3112 # generates _two_ hashes, references to which are passed as 2 and 3 argument
3113 sub parse_from_to_diffinfo
{
3114 my ($diffinfo, $from, $to, @parents) = @_;
3116 if ($diffinfo->{'nparents'}) {
3118 $from->{'file'} = [];
3119 $from->{'href'} = [];
3120 fill_from_file_info
($diffinfo, @parents)
3121 unless exists $diffinfo->{'from_file'};
3122 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
3123 $from->{'file'}[$i] =
3124 defined $diffinfo->{'from_file'}[$i] ?
3125 $diffinfo->{'from_file'}[$i] :
3126 $diffinfo->{'to_file'};
3127 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3128 $from->{'href'}[$i] = href
(action
=>"blob",
3129 hash_base
=>$parents[$i],
3130 hash
=>$diffinfo->{'from_id'}[$i],
3131 file_name
=>$from->{'file'}[$i]);
3133 $from->{'href'}[$i] = undef;
3137 # ordinary (not combined) diff
3138 $from->{'file'} = $diffinfo->{'from_file'};
3139 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3140 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
3141 hash
=>$diffinfo->{'from_id'},
3142 file_name
=>$from->{'file'});
3144 delete $from->{'href'};
3148 $to->{'file'} = $diffinfo->{'to_file'};
3149 if (!is_deleted
($diffinfo)) { # file exists in result
3150 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
3151 hash
=>$diffinfo->{'to_id'},
3152 file_name
=>$to->{'file'});
3154 delete $to->{'href'};
3158 ## ......................................................................
3159 ## parse to array of hashes functions
3161 sub git_get_heads_list
{
3165 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3166 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
3167 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
3170 while (my $line = <$fd>) {
3174 my ($refinfo, $committerinfo) = split(/\0/, $line);
3175 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3176 my ($committer, $epoch, $tz) =
3177 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
3178 $ref_item{'fullname'} = $name;
3179 $name =~ s!^refs/heads/!!;
3181 $ref_item{'name'} = $name;
3182 $ref_item{'id'} = $hash;
3183 $ref_item{'title'} = $title || '(no commit message)';
3184 $ref_item{'epoch'} = $epoch;
3186 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3188 $ref_item{'age'} = "unknown";
3191 push @headslist, \
%ref_item;
3195 return wantarray ?
@headslist : \
@headslist;
3198 sub git_get_tags_list
{
3202 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3203 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
3204 '--format=%(objectname) %(objecttype) %(refname) '.
3205 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3208 while (my $line = <$fd>) {
3212 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3213 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3214 my ($creator, $epoch, $tz) =
3215 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
3216 $ref_item{'fullname'} = $name;
3217 $name =~ s!^refs/tags/!!;
3219 $ref_item{'type'} = $type;
3220 $ref_item{'id'} = $id;
3221 $ref_item{'name'} = $name;
3222 if ($type eq "tag") {
3223 $ref_item{'subject'} = $title;
3224 $ref_item{'reftype'} = $reftype;
3225 $ref_item{'refid'} = $refid;
3227 $ref_item{'reftype'} = $type;
3228 $ref_item{'refid'} = $id;
3231 if ($type eq "tag" || $type eq "commit") {
3232 $ref_item{'epoch'} = $epoch;
3234 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3236 $ref_item{'age'} = "unknown";
3240 push @tagslist, \
%ref_item;
3244 return wantarray ?
@tagslist : \
@tagslist;
3247 ## ----------------------------------------------------------------------
3248 ## filesystem-related functions
3250 sub get_file_owner
{
3253 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3254 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3255 if (!defined $gcos) {
3259 $owner =~ s/[,;].*$//;
3260 return to_utf8
($owner);
3263 # assume that file exists
3265 my $filename = shift;
3267 open my $fd, '<', $filename;
3268 print map { to_utf8
($_) } <$fd>;
3272 ## ......................................................................
3273 ## mimetype related functions
3275 sub mimetype_guess_file
{
3276 my $filename = shift;
3277 my $mimemap = shift;
3278 -r
$mimemap or return undef;
3281 open(my $mh, '<', $mimemap) or return undef;
3283 next if m/^#/; # skip comments
3284 my ($mimetype, $exts) = split(/\t+/);
3285 if (defined $exts) {
3286 my @exts = split(/\s+/, $exts);
3287 foreach my $ext (@exts) {
3288 $mimemap{$ext} = $mimetype;
3294 $filename =~ /\.([^.]*)$/;
3295 return $mimemap{$1};
3298 sub mimetype_guess
{
3299 my $filename = shift;
3301 $filename =~ /\./ or return undef;
3303 if ($mimetypes_file) {
3304 my $file = $mimetypes_file;
3305 if ($file !~ m!^/!) { # if it is relative path
3306 # it is relative to project
3307 $file = "$projectroot/$project/$file";
3309 $mime = mimetype_guess_file
($filename, $file);
3311 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
3317 my $filename = shift;
3320 my $mime = mimetype_guess
($filename);
3321 $mime and return $mime;
3325 return $default_blob_plain_mimetype unless $fd;
3328 return 'text/plain';
3329 } elsif (! $filename) {
3330 return 'application/octet-stream';
3331 } elsif ($filename =~ m/\.png$/i) {
3333 } elsif ($filename =~ m/\.gif$/i) {
3335 } elsif ($filename =~ m/\.jpe?g$/i) {
3336 return 'image/jpeg';
3338 return 'application/octet-stream';
3342 sub blob_contenttype
{
3343 my ($fd, $file_name, $type) = @_;
3345 $type ||= blob_mimetype
($fd, $file_name);
3346 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3347 $type .= "; charset=$default_text_plain_charset";
3353 # guess file syntax for syntax highlighting; return undef if no highlighting
3354 # the name of syntax can (in the future) depend on syntax highlighter used
3355 sub guess_file_syntax
{
3356 my ($highlight, $mimetype, $file_name) = @_;
3357 return undef unless ($highlight && defined $file_name);
3358 my $basename = basename
($file_name, '.in');
3359 return $highlight_basename{$basename}
3360 if exists $highlight_basename{$basename};
3362 $basename =~ /\.([^.]*)$/;
3363 my $ext = $1 or return undef;
3364 return $highlight_ext{$ext}
3365 if exists $highlight_ext{$ext};
3370 # run highlighter and return FD of its output,
3371 # or return original FD if no highlighting
3372 sub run_highlighter
{
3373 my ($fd, $highlight, $syntax) = @_;
3374 return $fd unless ($highlight && defined $syntax);
3377 or die_error
(404, "Reading blob failed");
3378 open $fd, quote_command
(git_cmd
(), "cat-file", "blob", $hash)." | ".
3379 "highlight --xhtml --fragment --syntax $syntax |"
3380 or die_error
(500, "Couldn't open file or run syntax highlighter");
3384 ## ======================================================================
3385 ## functions printing HTML: header, footer, error page
3387 sub get_page_title
{
3388 my $title = to_utf8
($site_name);
3390 return $title unless (defined $project);
3391 $title .= " - " . to_utf8
($project);
3393 return $title unless (defined $action);
3394 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
3396 return $title unless (defined $file_name);
3397 $title .= " - " . esc_path
($file_name);
3398 if ($action eq "tree" && $file_name !~ m
|/$|) {
3405 sub git_header_html
{
3406 my $status = shift || "200 OK";
3407 my $expires = shift;
3410 my $title = get_page_title
();
3412 # require explicit support from the UA if we are to send the page as
3413 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
3414 # we have to do this because MSIE sometimes globs '*/*', pretending to
3415 # support xhtml+xml but choking when it gets what it asked for.
3416 if (defined $cgi->http('HTTP_ACCEPT') &&
3417 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
3418 $cgi->Accept('application/xhtml+xml') != 0) {
3419 $content_type = 'application/xhtml+xml';
3421 $content_type = 'text/html';
3423 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
3424 -status
=> $status, -expires
=> $expires)
3425 unless ($opts{'-no_http_header'});
3426 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
3428 <?xml version="1.0" encoding="utf-8"?>
3429 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3430 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
3431 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
3432 <!-- git core binaries version $git_version -->
3434 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
3435 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
3436 <meta name="robots" content="index, nofollow"/>
3437 <title>$title</title>
3439 # the stylesheet, favicon etc urls won't work correctly with path_info
3440 # unless we set the appropriate base URL
3441 if ($ENV{'PATH_INFO'}) {
3442 print "<base href=\"".esc_url
($base_url)."\" />\n";
3444 # print out each stylesheet that exist, providing backwards capability
3445 # for those people who defined $stylesheet in a config file
3446 if (defined $stylesheet) {
3447 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
3449 foreach my $stylesheet (@stylesheets) {
3450 next unless $stylesheet;
3451 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
3454 if (defined $project) {
3455 my %href_params = get_feed_info
();
3456 if (!exists $href_params{'-title'}) {
3457 $href_params{'-title'} = 'log';
3460 foreach my $format qw(RSS Atom) {
3461 my $type = lc($format);
3463 '-rel' => 'alternate',
3464 '-title' => "$project - $href_params{'-title'} - $format feed",
3465 '-type' => "application/$type+xml"
3468 $href_params{'action'} = $type;
3469 $link_attr{'-href'} = href
(%href_params);
3471 "rel=\"$link_attr{'-rel'}\" ".
3472 "title=\"$link_attr{'-title'}\" ".
3473 "href=\"$link_attr{'-href'}\" ".
3474 "type=\"$link_attr{'-type'}\" ".
3477 $href_params{'extra_options'} = '--no-merges';
3478 $link_attr{'-href'} = href
(%href_params);
3479 $link_attr{'-title'} .= ' (no merges)';
3481 "rel=\"$link_attr{'-rel'}\" ".
3482 "title=\"$link_attr{'-title'}\" ".
3483 "href=\"$link_attr{'-href'}\" ".
3484 "type=\"$link_attr{'-type'}\" ".
3489 printf('<link rel="alternate" title="%s projects list" '.
3490 'href="%s" type="text/plain; charset=utf-8" />'."\n",
3491 $site_name, href
(project
=>undef, action
=>"project_index"));
3492 printf('<link rel="alternate" title="%s projects feeds" '.
3493 'href="%s" type="text/x-opml" />'."\n",
3494 $site_name, href
(project
=>undef, action
=>"opml"));
3496 if (defined $favicon) {
3497 print qq(<link rel
="shortcut icon" href
="$favicon" type
="image/png" />\n);
3503 if (defined $site_header && -f
$site_header) {
3504 insert_file
($site_header);
3507 print "<div class=\"page_header\">\n" .
3508 $cgi->a({-href
=> esc_url
($logo_url),
3509 -title
=> $logo_label},
3510 qq(<img src
="$logo" width
="72" height
="27" alt
="git" class="logo"/>));
3511 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
3512 if (defined $project) {
3513 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
3514 if (defined $action) {
3521 my $have_search = gitweb_check_feature
('search');
3522 if (defined $project && $have_search) {
3523 if (!defined $searchtext) {
3527 if (defined $hash_base) {
3528 $search_hash = $hash_base;
3529 } elsif (defined $hash) {
3530 $search_hash = $hash;
3532 $search_hash = "HEAD";
3534 my $action = $my_uri;
3535 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3536 if ($use_pathinfo) {
3537 $action .= "/".esc_url
($project);
3539 print $cgi->startform(-method
=> "get", -action
=> $action) .
3540 "<div class=\"search\">\n" .
3542 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3543 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3544 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3545 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3546 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3547 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3549 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
3550 "<span title=\"Extended regular expression\">" .
3551 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3552 -checked
=> $search_use_regexp) .
3555 $cgi->end_form() . "\n";
3559 sub git_footer_html
{
3560 my $feed_class = 'rss_logo';
3562 print "<div class=\"page_footer\">\n";
3563 if (defined $project) {
3564 my $descr = git_get_project_description
($project);
3565 if (defined $descr) {
3566 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3569 my %href_params = get_feed_info
();
3570 if (!%href_params) {
3571 $feed_class .= ' generic';
3573 $href_params{'-title'} ||= 'log';
3575 foreach my $format qw(RSS Atom) {
3576 $href_params{'action'} = lc($format);
3577 print $cgi->a({-href
=> href
(%href_params),
3578 -title
=> "$href_params{'-title'} $format feed",
3579 -class => $feed_class}, $format)."\n";
3583 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3584 -class => $feed_class}, "OPML") . " ";
3585 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3586 -class => $feed_class}, "TXT") . "\n";
3588 print "</div>\n"; # class="page_footer"
3590 if (defined $t0 && gitweb_check_feature
('timed')) {
3591 print "<div id=\"generating_info\">\n";
3592 print 'This page took '.
3593 '<span id="generating_time" class="time_span">'.
3594 Time
::HiRes
::tv_interval
($t0, [Time
::HiRes
::gettimeofday
()]).
3597 '<span id="generating_cmd">'.
3598 $number_of_git_cmds.
3599 '</span> git commands '.
3601 print "</div>\n"; # class="page_footer"
3604 if (defined $site_footer && -f
$site_footer) {
3605 insert_file
($site_footer);
3608 print qq!<script type
="text/javascript" src
="$javascript"></script
>\n!;
3609 if (defined $action &&
3610 $action eq 'blame_incremental') {
3611 print qq!<script type
="text/javascript">\n!.
3612 qq!startBlame
("!. href(action=>"blame_data
", -replay=>1) .qq!",\n!.
3613 qq! "!. href() .qq!");\n!.
3615 } elsif (gitweb_check_feature
('javascript-actions')) {
3616 print qq!<script type
="text/javascript">\n!.
3617 qq!window
.onload
= fixLinks
;\n!.
3625 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
3626 # Example: die_error(404, 'Hash not found')
3627 # By convention, use the following status codes (as defined in RFC 2616):
3628 # 400: Invalid or missing CGI parameters, or
3629 # requested object exists but has wrong type.
3630 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
3631 # this server or project.
3632 # 404: Requested object/revision/project doesn't exist.
3633 # 500: The server isn't configured properly, or
3634 # an internal error occurred (e.g. failed assertions caused by bugs), or
3635 # an unknown error occurred (e.g. the git binary died unexpectedly).
3636 # 503: The server is currently unavailable (because it is overloaded,
3637 # or down for maintenance). Generally, this is a temporary state.
3639 my $status = shift || 500;
3640 my $error = esc_html
(shift) || "Internal Server Error";
3644 my %http_responses = (
3645 400 => '400 Bad Request',
3646 403 => '403 Forbidden',
3647 404 => '404 Not Found',
3648 500 => '500 Internal Server Error',
3649 503 => '503 Service Unavailable',
3651 git_header_html
($http_responses{$status}, undef, %opts);
3653 <div class="page_body">
3658 if (defined $extra) {
3666 unless ($opts{'-error_handler'});
3669 ## ----------------------------------------------------------------------
3670 ## functions printing or outputting HTML: navigation
3672 sub git_print_page_nav
{
3673 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3674 $extra = '' if !defined $extra; # pager or formats
3676 my @navs = qw(summary shortlog log commit commitdiff tree);
3678 @navs = grep { $_ ne $suppress } @navs;
3681 my %arg = map { $_ => {action
=>$_} } @navs;
3682 if (defined $head) {
3683 for (qw(commit commitdiff)) {
3684 $arg{$_}{'hash'} = $head;
3686 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3687 for (qw(shortlog log)) {
3688 $arg{$_}{'hash'} = $head;
3693 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3694 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3696 my @actions = gitweb_get_feature
('actions');
3699 'n' => $project, # project name
3700 'f' => $git_dir, # project path within filesystem
3701 'h' => $treehead || '', # current hash ('h' parameter)
3702 'b' => $treebase || '', # hash base ('hb' parameter)
3705 my ($label, $link, $pos) = splice(@actions,0,3);
3707 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
3709 $link =~ s/%([%nfhb])/$repl{$1}/g;
3710 $arg{$label}{'_href'} = $link;
3713 print "<div class=\"page_nav\">\n" .
3715 map { $_ eq $current ?
3716 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
3718 print "<br/>\n$extra<br/>\n" .
3722 sub format_paging_nav
{
3723 my ($action, $page, $has_next_link) = @_;
3729 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)}, "first") .
3731 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
3732 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
3734 $paging_nav .= "first ⋅ prev";
3737 if ($has_next_link) {
3738 $paging_nav .= " ⋅ " .
3739 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
3740 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
3742 $paging_nav .= " ⋅ next";
3748 ## ......................................................................
3749 ## functions printing or outputting HTML: div
3751 sub git_print_header_div
{
3752 my ($action, $title, $hash, $hash_base) = @_;
3755 $args{'action'} = $action;
3756 $args{'hash'} = $hash if $hash;
3757 $args{'hash_base'} = $hash_base if $hash_base;
3759 print "<div class=\"header\">\n" .
3760 $cgi->a({-href
=> href
(%args), -class => "title"},
3761 $title ?
$title : $action) .
3765 sub print_local_time
{
3766 print format_local_time
(@_);
3769 sub format_local_time
{
3772 if ($date{'hour_local'} < 6) {
3773 $localtime .= sprintf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3774 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3776 $localtime .= sprintf(" (%02d:%02d %s)",
3777 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3783 # Outputs the author name and date in long form
3784 sub git_print_authorship
{
3787 my $tag = $opts{-tag
} || 'div';
3788 my $author = $co->{'author_name'};
3790 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
3791 print "<$tag class=\"author_date\">" .
3792 format_search_author
($author, "author", esc_html
($author)) .
3794 print_local_time
(%ad) if ($opts{-localtime});
3795 print "]" . git_get_avatar
($co->{'author_email'}, -pad_before
=> 1)
3799 # Outputs table rows containing the full author or committer information,
3800 # in the format expected for 'commit' view (& similar).
3801 # Parameters are a commit hash reference, followed by the list of people
3802 # to output information for. If the list is empty it defaults to both
3803 # author and committer.
3804 sub git_print_authorship_rows
{
3806 # too bad we can't use @people = @_ || ('author', 'committer')
3808 @people = ('author', 'committer') unless @people;
3809 foreach my $who (@people) {
3810 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
3811 print "<tr><td>$who</td><td>" .
3812 format_search_author
($co->{"${who}_name"}, $who,
3813 esc_html
($co->{"${who}_name"})) . " " .
3814 format_search_author
($co->{"${who}_email"}, $who,
3815 esc_html
("<" . $co->{"${who}_email"} . ">")) .
3816 "</td><td rowspan=\"2\">" .
3817 git_get_avatar
($co->{"${who}_email"}, -size
=> 'double') .
3820 "<td></td><td> $wd{'rfc2822'}";
3821 print_local_time
(%wd);
3827 sub git_print_page_path
{
3833 print "<div class=\"page_path\">";
3834 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
3835 -title
=> 'tree root'}, to_utf8
("[$project]"));
3837 if (defined $name) {
3838 my @dirname = split '/', $name;
3839 my $basename = pop @dirname;
3842 foreach my $dir (@dirname) {
3843 $fullname .= ($fullname ?
'/' : '') . $dir;
3844 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
3846 -title
=> $fullname}, esc_path
($dir));
3849 if (defined $type && $type eq 'blob') {
3850 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
3852 -title
=> $name}, esc_path
($basename));
3853 } elsif (defined $type && $type eq 'tree') {
3854 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
3856 -title
=> $name}, esc_path
($basename));
3859 print esc_path
($basename);
3862 print "<br/></div>\n";
3869 if ($opts{'-remove_title'}) {
3870 # remove title, i.e. first line of log
3873 # remove leading empty lines
3874 while (defined $log->[0] && $log->[0] eq "") {
3881 foreach my $line (@
$log) {
3882 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3885 if (! $opts{'-remove_signoff'}) {
3886 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
3889 # remove signoff lines
3896 # print only one empty line
3897 # do not print empty line after signoff
3899 next if ($empty || $signoff);
3905 print format_log_line_html
($line) . "<br/>\n";
3908 if ($opts{'-final_empty_line'}) {
3909 # end with single empty line
3910 print "<br/>\n" unless $empty;
3914 # return link target (what link points to)
3915 sub git_get_link_target
{
3920 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
3924 $link_target = <$fd>;
3929 return $link_target;
3932 # given link target, and the directory (basedir) the link is in,
3933 # return target of link relative to top directory (top tree);
3934 # return undef if it is not possible (including absolute links).
3935 sub normalize_link_target
{
3936 my ($link_target, $basedir) = @_;
3938 # absolute symlinks (beginning with '/') cannot be normalized
3939 return if (substr($link_target, 0, 1) eq '/');
3941 # normalize link target to path from top (root) tree (dir)
3944 $path = $basedir . '/' . $link_target;
3946 # we are in top (root) tree (dir)
3947 $path = $link_target;
3950 # remove //, /./, and /../
3952 foreach my $part (split('/', $path)) {
3953 # discard '.' and ''
3954 next if (!$part || $part eq '.');
3956 if ($part eq '..') {
3960 # link leads outside repository (outside top dir)
3964 push @path_parts, $part;
3967 $path = join('/', @path_parts);
3972 # print tree entry (row of git_tree), but without encompassing <tr> element
3973 sub git_print_tree_entry
{
3974 my ($t, $basedir, $hash_base, $have_blame) = @_;
3977 $base_key{'hash_base'} = $hash_base if defined $hash_base;
3979 # The format of a table row is: mode list link. Where mode is
3980 # the mode of the entry, list is the name of the entry, an href,
3981 # and link is the action links of the entry.
3983 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
3984 if (exists $t->{'size'}) {
3985 print "<td class=\"size\">$t->{'size'}</td>\n";
3987 if ($t->{'type'} eq "blob") {
3988 print "<td class=\"list\">" .
3989 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3990 file_name
=>"$basedir$t->{'name'}", %base_key),
3991 -class => "list"}, esc_path
($t->{'name'}));
3992 if (S_ISLNK
(oct $t->{'mode'})) {
3993 my $link_target = git_get_link_target
($t->{'hash'});
3995 my $norm_target = normalize_link_target
($link_target, $basedir);
3996 if (defined $norm_target) {
3998 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
3999 file_name
=>$norm_target),
4000 -title
=> $norm_target}, esc_path
($link_target));
4002 print " -> " . esc_path
($link_target);
4007 print "<td class=\"link\">";
4008 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4009 file_name
=>"$basedir$t->{'name'}", %base_key)},
4013 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
4014 file_name
=>"$basedir$t->{'name'}", %base_key)},
4017 if (defined $hash_base) {
4019 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4020 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
4024 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
4025 file_name
=>"$basedir$t->{'name'}")},
4029 } elsif ($t->{'type'} eq "tree") {
4030 print "<td class=\"list\">";
4031 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4032 file_name
=>"$basedir$t->{'name'}",
4034 esc_path
($t->{'name'}));
4036 print "<td class=\"link\">";
4037 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4038 file_name
=>"$basedir$t->{'name'}",
4041 if (defined $hash_base) {
4043 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4044 file_name
=>"$basedir$t->{'name'}")},
4049 # unknown object: we can only present history for it
4050 # (this includes 'commit' object, i.e. submodule support)
4051 print "<td class=\"list\">" .
4052 esc_path
($t->{'name'}) .
4054 print "<td class=\"link\">";
4055 if (defined $hash_base) {
4056 print $cgi->a({-href
=> href
(action
=>"history",
4057 hash_base
=>$hash_base,
4058 file_name
=>"$basedir$t->{'name'}")},
4065 ## ......................................................................
4066 ## functions printing large fragments of HTML
4068 # get pre-image filenames for merge (combined) diff
4069 sub fill_from_file_info
{
4070 my ($diff, @parents) = @_;
4072 $diff->{'from_file'} = [ ];
4073 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4074 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4075 if ($diff->{'status'}[$i] eq 'R' ||
4076 $diff->{'status'}[$i] eq 'C') {
4077 $diff->{'from_file'}[$i] =
4078 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
4085 # is current raw difftree line of file deletion
4087 my $diffinfo = shift;
4089 return $diffinfo->{'to_id'} eq ('0' x
40);
4092 # does patch correspond to [previous] difftree raw line
4093 # $diffinfo - hashref of parsed raw diff format
4094 # $patchinfo - hashref of parsed patch diff format
4095 # (the same keys as in $diffinfo)
4096 sub is_patch_split
{
4097 my ($diffinfo, $patchinfo) = @_;
4099 return defined $diffinfo && defined $patchinfo
4100 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4104 sub git_difftree_body
{
4105 my ($difftree, $hash, @parents) = @_;
4106 my ($parent) = $parents[0];
4107 my $have_blame = gitweb_check_feature
('blame');
4108 print "<div class=\"list_head\">\n";
4109 if ($#{$difftree} > 10) {
4110 print(($#{$difftree} + 1) . " files changed:\n");
4114 print "<table class=\"" .
4115 (@parents > 1 ?
"combined " : "") .
4118 # header only for combined diff in 'commitdiff' view
4119 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
4122 print "<thead><tr>\n" .
4123 "<th></th><th></th>\n"; # filename, patchN link
4124 for (my $i = 0; $i < @parents; $i++) {
4125 my $par = $parents[$i];
4127 $cgi->a({-href
=> href
(action
=>"commitdiff",
4128 hash
=>$hash, hash_parent
=>$par),
4129 -title
=> 'commitdiff to parent number ' .
4130 ($i+1) . ': ' . substr($par,0,7)},
4134 print "</tr></thead>\n<tbody>\n";
4139 foreach my $line (@
{$difftree}) {
4140 my $diff = parsed_difftree_line
($line);
4143 print "<tr class=\"dark\">\n";
4145 print "<tr class=\"light\">\n";
4149 if (exists $diff->{'nparents'}) { # combined diff
4151 fill_from_file_info
($diff, @parents)
4152 unless exists $diff->{'from_file'};
4154 if (!is_deleted
($diff)) {
4155 # file exists in the result (child) commit
4157 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4158 file_name
=>$diff->{'to_file'},
4160 -class => "list"}, esc_path
($diff->{'to_file'})) .
4164 esc_path
($diff->{'to_file'}) .
4168 if ($action eq 'commitdiff') {
4171 print "<td class=\"link\">" .
4172 $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4177 my $has_history = 0;
4178 my $not_deleted = 0;
4179 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4180 my $hash_parent = $parents[$i];
4181 my $from_hash = $diff->{'from_id'}[$i];
4182 my $from_path = $diff->{'from_file'}[$i];
4183 my $status = $diff->{'status'}[$i];
4185 $has_history ||= ($status ne 'A');
4186 $not_deleted ||= ($status ne 'D');
4188 if ($status eq 'A') {
4189 print "<td class=\"link\" align=\"right\"> | </td>\n";
4190 } elsif ($status eq 'D') {
4191 print "<td class=\"link\">" .
4192 $cgi->a({-href
=> href
(action
=>"blob",
4195 file_name
=>$from_path)},
4199 if ($diff->{'to_id'} eq $from_hash) {
4200 print "<td class=\"link nochange\">";
4202 print "<td class=\"link\">";
4204 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4205 hash
=>$diff->{'to_id'},
4206 hash_parent
=>$from_hash,
4208 hash_parent_base
=>$hash_parent,
4209 file_name
=>$diff->{'to_file'},
4210 file_parent
=>$from_path)},
4216 print "<td class=\"link\">";
4218 print $cgi->a({-href
=> href
(action
=>"blob",
4219 hash
=>$diff->{'to_id'},
4220 file_name
=>$diff->{'to_file'},
4223 print " | " if ($has_history);
4226 print $cgi->a({-href
=> href
(action
=>"history",
4227 file_name
=>$diff->{'to_file'},
4234 next; # instead of 'else' clause, to avoid extra indent
4236 # else ordinary diff
4238 my ($to_mode_oct, $to_mode_str, $to_file_type);
4239 my ($from_mode_oct, $from_mode_str, $from_file_type);
4240 if ($diff->{'to_mode'} ne ('0' x
6)) {
4241 $to_mode_oct = oct $diff->{'to_mode'};
4242 if (S_ISREG
($to_mode_oct)) { # only for regular file
4243 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4245 $to_file_type = file_type
($diff->{'to_mode'});
4247 if ($diff->{'from_mode'} ne ('0' x
6)) {
4248 $from_mode_oct = oct $diff->{'from_mode'};
4249 if (S_ISREG
($to_mode_oct)) { # only for regular file
4250 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4252 $from_file_type = file_type
($diff->{'from_mode'});
4255 if ($diff->{'status'} eq "A") { # created
4256 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4257 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4258 $mode_chng .= "]</span>";
4260 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4261 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4262 -class => "list"}, esc_path
($diff->{'file'}));
4264 print "<td>$mode_chng</td>\n";
4265 print "<td class=\"link\">";
4266 if ($action eq 'commitdiff') {
4269 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
4272 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4273 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4277 } elsif ($diff->{'status'} eq "D") { # deleted
4278 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4280 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4281 hash_base
=>$parent, file_name
=>$diff->{'file'}),
4282 -class => "list"}, esc_path
($diff->{'file'}));
4284 print "<td>$mode_chng</td>\n";
4285 print "<td class=\"link\">";
4286 if ($action eq 'commitdiff') {
4289 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
4292 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4293 hash_base
=>$parent, file_name
=>$diff->{'file'})},
4296 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
4297 file_name
=>$diff->{'file'})},
4300 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
4301 file_name
=>$diff->{'file'})},
4305 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4306 my $mode_chnge = "";
4307 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4308 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4309 if ($from_file_type ne $to_file_type) {
4310 $mode_chnge .= " from $from_file_type to $to_file_type";
4312 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4313 if ($from_mode_str && $to_mode_str) {
4314 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4315 } elsif ($to_mode_str) {
4316 $mode_chnge .= " mode: $to_mode_str";
4319 $mode_chnge .= "]</span>\n";
4322 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4323 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4324 -class => "list"}, esc_path
($diff->{'file'}));
4326 print "<td>$mode_chnge</td>\n";
4327 print "<td class=\"link\">";
4328 if ($action eq 'commitdiff') {
4331 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4333 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4334 # "commit" view and modified file (not onlu mode changed)
4335 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4336 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4337 hash_base
=>$hash, hash_parent_base
=>$parent,
4338 file_name
=>$diff->{'file'})},
4342 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4343 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4346 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4347 file_name
=>$diff->{'file'})},
4350 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4351 file_name
=>$diff->{'file'})},
4355 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4356 my %status_name = ('R' => 'moved', 'C' => 'copied');
4357 my $nstatus = $status_name{$diff->{'status'}};
4359 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4360 # mode also for directories, so we cannot use $to_mode_str
4361 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4364 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
4365 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
4366 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
4367 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4368 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
4369 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
4370 -class => "list"}, esc_path
($diff->{'from_file'})) .
4371 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4372 "<td class=\"link\">";
4373 if ($action eq 'commitdiff') {
4376 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
4378 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4379 # "commit" view and modified file (not only pure rename or copy)
4380 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4381 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4382 hash_base
=>$hash, hash_parent_base
=>$parent,
4383 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
4387 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4388 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
4391 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4392 file_name
=>$diff->{'to_file'})},
4395 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4396 file_name
=>$diff->{'to_file'})},
4400 } # we should not encounter Unmerged (U) or Unknown (X) status
4403 print "</tbody>" if $has_header;
4407 sub git_patchset_body
{
4408 my ($fd, $difftree, $hash, @hash_parents) = @_;
4409 my ($hash_parent) = $hash_parents[0];
4411 my $is_combined = (@hash_parents > 1);
4413 my $patch_number = 0;
4419 print "<div class=\"patchset\">\n";
4421 # skip to first patch
4422 while ($patch_line = <$fd>) {
4425 last if ($patch_line =~ m/^diff /);
4429 while ($patch_line) {
4431 # parse "git diff" header line
4432 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
4433 # $1 is from_name, which we do not use
4434 $to_name = unquote
($2);
4435 $to_name =~ s!^b/!!;
4436 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
4437 # $1 is 'cc' or 'combined', which we do not use
4438 $to_name = unquote
($2);
4443 # check if current patch belong to current raw line
4444 # and parse raw git-diff line if needed
4445 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
4446 # this is continuation of a split patch
4447 print "<div class=\"patch cont\">\n";
4449 # advance raw git-diff output if needed
4450 $patch_idx++ if defined $diffinfo;
4452 # read and prepare patch information
4453 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4455 # compact combined diff output can have some patches skipped
4456 # find which patch (using pathname of result) we are at now;
4458 while ($to_name ne $diffinfo->{'to_file'}) {
4459 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4460 format_diff_cc_simplified
($diffinfo, @hash_parents) .
4461 "</div>\n"; # class="patch"
4466 last if $patch_idx > $#$difftree;
4467 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4471 # modifies %from, %to hashes
4472 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
4474 # this is first patch for raw difftree line with $patch_idx index
4475 # we index @$difftree array from 0, but number patches from 1
4476 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
4480 #assert($patch_line =~ m/^diff /) if DEBUG;
4481 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
4483 # print "git diff" header
4484 print format_git_diff_header_line
($patch_line, $diffinfo,
4487 # print extended diff header
4488 print "<div class=\"diff extended_header\">\n";
4490 while ($patch_line = <$fd>) {
4493 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
4495 print format_extended_diff_header_line
($patch_line, $diffinfo,
4498 print "</div>\n"; # class="diff extended_header"
4500 # from-file/to-file diff header
4501 if (! $patch_line) {
4502 print "</div>\n"; # class="patch"
4505 next PATCH
if ($patch_line =~ m/^diff /);
4506 #assert($patch_line =~ m/^---/) if DEBUG;
4508 my $last_patch_line = $patch_line;
4509 $patch_line = <$fd>;
4511 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
4513 print format_diff_from_to_header
($last_patch_line, $patch_line,
4514 $diffinfo, \
%from, \
%to,
4519 while ($patch_line = <$fd>) {
4522 next PATCH
if ($patch_line =~ m/^diff /);
4524 print format_diff_line
($patch_line, \
%from, \
%to);
4528 print "</div>\n"; # class="patch"
4531 # for compact combined (--cc) format, with chunk and patch simplification
4532 # the patchset might be empty, but there might be unprocessed raw lines
4533 for (++$patch_idx if $patch_number > 0;
4534 $patch_idx < @
$difftree;
4536 # read and prepare patch information
4537 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4539 # generate anchor for "patch" links in difftree / whatchanged part
4540 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4541 format_diff_cc_simplified
($diffinfo, @hash_parents) .
4542 "</div>\n"; # class="patch"
4547 if ($patch_number == 0) {
4548 if (@hash_parents > 1) {
4549 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
4551 print "<div class=\"diff nodifferences\">No differences found</div>\n";
4555 print "</div>\n"; # class="patchset"
4558 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4560 # fills project list info (age, description, owner, forks) for each
4561 # project in the list, removing invalid projects from returned list
4562 # NOTE: modifies $projlist, but does not remove entries from it
4563 sub fill_project_list_info
{
4564 my ($projlist, $check_forks) = @_;
4567 my $show_ctags = gitweb_check_feature
('ctags');
4569 foreach my $pr (@
$projlist) {
4570 my (@activity) = git_get_last_activity
($pr->{'path'});
4571 unless (@activity) {
4574 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
4575 if (!defined $pr->{'descr'}) {
4576 my $descr = git_get_project_description
($pr->{'path'}) || "";
4577 $descr = to_utf8
($descr);
4578 $pr->{'descr_long'} = $descr;
4579 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
4581 if (!defined $pr->{'owner'}) {
4582 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
4585 my $pname = $pr->{'path'};
4586 if (($pname =~ s/\.git$//) &&
4587 ($pname !~ /\/$/) &&
4588 (-d
"$projectroot/$pname")) {
4589 $pr->{'forks'} = "-d $projectroot/$pname";
4594 $show_ctags and $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
4595 push @projects, $pr;
4601 # print 'sort by' <th> element, generating 'sort by $name' replay link
4602 # if that order is not selected
4604 print format_sort_th
(@_);
4607 sub format_sort_th
{
4608 my ($name, $order, $header) = @_;
4610 $header ||= ucfirst($name);
4612 if ($order eq $name) {
4613 $sort_th .= "<th>$header</th>\n";
4615 $sort_th .= "<th>" .
4616 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
4617 -class => "header"}, $header) .
4624 sub git_project_list_body
{
4625 # actually uses global variable $project
4626 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
4628 my $check_forks = gitweb_check_feature
('forks');
4629 my @projects = fill_project_list_info
($projlist, $check_forks);
4631 $order ||= $default_projects_order;
4632 $from = 0 unless defined $from;
4633 $to = $#projects if (!defined $to || $#projects < $to);
4636 project
=> { key
=> 'path', type
=> 'str' },
4637 descr
=> { key
=> 'descr_long', type
=> 'str' },
4638 owner
=> { key
=> 'owner', type
=> 'str' },
4639 age
=> { key
=> 'age', type
=> 'num' }
4641 my $oi = $order_info{$order};
4642 if ($oi->{'type'} eq 'str') {
4643 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
4645 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
4648 my $show_ctags = gitweb_check_feature
('ctags');
4651 foreach my $p (@projects) {
4652 foreach my $ct (keys %{$p->{'ctags'}}) {
4653 $ctags{$ct} += $p->{'ctags'}->{$ct};
4656 my $cloud = git_populate_project_tagcloud
(\
%ctags);
4657 print git_show_project_tagcloud
($cloud, 64);
4660 print "<table class=\"project_list\">\n";
4661 unless ($no_header) {
4664 print "<th></th>\n";
4666 print_sort_th
('project', $order, 'Project');
4667 print_sort_th
('descr', $order, 'Description');
4668 print_sort_th
('owner', $order, 'Owner');
4669 print_sort_th
('age', $order, 'Last Change');
4670 print "<th></th>\n" . # for links
4674 my $tagfilter = $cgi->param('by_tag');
4675 for (my $i = $from; $i <= $to; $i++) {
4676 my $pr = $projects[$i];
4678 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
4679 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
4680 and not $pr->{'descr_long'} =~ /$searchtext/;
4681 # Weed out forks or non-matching entries of search
4683 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s
#\.git$#/#;
4684 $forkbase="^$forkbase" if $forkbase;
4685 next if not $searchtext and not $tagfilter and $show_ctags
4686 and $pr->{'path'} =~ m
#$forkbase.*/.*#; # regexp-safe
4690 print "<tr class=\"dark\">\n";
4692 print "<tr class=\"light\">\n";
4697 if ($pr->{'forks'}) {
4698 print "<!-- $pr->{'forks'} -->\n";
4699 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "+");
4703 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4704 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
4705 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4706 -class => "list", -title
=> $pr->{'descr_long'}},
4707 esc_html
($pr->{'descr'})) . "</td>\n" .
4708 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
4709 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
4710 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
4711 "<td class=\"link\">" .
4712 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
4713 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
4714 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
4715 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
4716 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
4720 if (defined $extra) {
4723 print "<td></td>\n";
4725 print "<td colspan=\"5\">$extra</td>\n" .
4732 # uses global variable $project
4733 my ($commitlist, $from, $to, $refs, $extra) = @_;
4735 $from = 0 unless defined $from;
4736 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4738 for (my $i = 0; $i <= $to; $i++) {
4739 my %co = %{$commitlist->[$i]};
4741 my $commit = $co{'id'};
4742 my $ref = format_ref_marker
($refs, $commit);
4743 my %ad = parse_date
($co{'author_epoch'});
4744 git_print_header_div
('commit',
4745 "<span class=\"age\">$co{'age_string'}</span>" .
4746 esc_html
($co{'title'}) . $ref,
4748 print "<div class=\"title_text\">\n" .
4749 "<div class=\"log_link\">\n" .
4750 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
4752 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
4754 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
4757 git_print_authorship
(\
%co, -tag
=> 'span');
4758 print "<br/>\n</div>\n";
4760 print "<div class=\"log_body\">\n";
4761 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
4765 print "<div class=\"page_nav\">\n";
4771 sub git_shortlog_body
{
4772 # uses global variable $project
4773 my ($commitlist, $from, $to, $refs, $extra) = @_;
4775 $from = 0 unless defined $from;
4776 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4778 print "<table class=\"shortlog\">\n";
4780 for (my $i = $from; $i <= $to; $i++) {
4781 my %co = %{$commitlist->[$i]};
4782 my $commit = $co{'id'};
4783 my $ref = format_ref_marker
($refs, $commit);
4785 print "<tr class=\"dark\">\n";
4787 print "<tr class=\"light\">\n";
4790 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4791 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4792 format_author_html
('td', \
%co, 10) . "<td>";
4793 print format_subject_html
($co{'title'}, $co{'title_short'},
4794 href
(action
=>"commit", hash
=>$commit), $ref);
4796 "<td class=\"link\">" .
4797 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
4798 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
4799 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
4800 my $snapshot_links = format_snapshot_links
($commit);
4801 if (defined $snapshot_links) {
4802 print " | " . $snapshot_links;
4807 if (defined $extra) {
4809 "<td colspan=\"4\">$extra</td>\n" .
4815 sub git_history_body
{
4816 # Warning: assumes constant type (blob or tree) during history
4817 my ($commitlist, $from, $to, $refs, $extra,
4818 $file_name, $file_hash, $ftype) = @_;
4820 $from = 0 unless defined $from;
4821 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
4823 print "<table class=\"history\">\n";
4825 for (my $i = $from; $i <= $to; $i++) {
4826 my %co = %{$commitlist->[$i]};
4830 my $commit = $co{'id'};
4832 my $ref = format_ref_marker
($refs, $commit);
4835 print "<tr class=\"dark\">\n";
4837 print "<tr class=\"light\">\n";
4840 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4841 # shortlog: format_author_html('td', \%co, 10)
4842 format_author_html
('td', \
%co, 15, 3) . "<td>";
4843 # originally git_history used chop_str($co{'title'}, 50)
4844 print format_subject_html
($co{'title'}, $co{'title_short'},
4845 href
(action
=>"commit", hash
=>$commit), $ref);
4847 "<td class=\"link\">" .
4848 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
4849 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
4851 if ($ftype eq 'blob') {
4852 my $blob_current = $file_hash;
4853 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
4854 if (defined $blob_current && defined $blob_parent &&
4855 $blob_current ne $blob_parent) {
4857 $cgi->a({-href
=> href
(action
=>"blobdiff",
4858 hash
=>$blob_current, hash_parent
=>$blob_parent,
4859 hash_base
=>$hash_base, hash_parent_base
=>$commit,
4860 file_name
=>$file_name)},
4867 if (defined $extra) {
4869 "<td colspan=\"4\">$extra</td>\n" .
4876 # uses global variable $project
4877 my ($taglist, $from, $to, $extra) = @_;
4878 $from = 0 unless defined $from;
4879 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
4881 print "<table class=\"tags\">\n";
4883 for (my $i = $from; $i <= $to; $i++) {
4884 my $entry = $taglist->[$i];
4886 my $comment = $tag{'subject'};
4888 if (defined $comment) {
4889 $comment_short = chop_str
($comment, 30, 5);
4892 print "<tr class=\"dark\">\n";
4894 print "<tr class=\"light\">\n";
4897 if (defined $tag{'age'}) {
4898 print "<td><i>$tag{'age'}</i></td>\n";
4900 print "<td></td>\n";
4903 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
4904 -class => "list name"}, esc_html
($tag{'name'})) .
4907 if (defined $comment) {
4908 print format_subject_html
($comment, $comment_short,
4909 href
(action
=>"tag", hash
=>$tag{'id'}));
4912 "<td class=\"selflink\">";
4913 if ($tag{'type'} eq "tag") {
4914 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
4919 "<td class=\"link\">" . " | " .
4920 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
4921 if ($tag{'reftype'} eq "commit") {
4922 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
4923 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
4924 } elsif ($tag{'reftype'} eq "blob") {
4925 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
4930 if (defined $extra) {
4932 "<td colspan=\"5\">$extra</td>\n" .
4938 sub git_heads_body
{
4939 # uses global variable $project
4940 my ($headlist, $head, $from, $to, $extra) = @_;
4941 $from = 0 unless defined $from;
4942 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4944 print "<table class=\"heads\">\n";
4946 for (my $i = $from; $i <= $to; $i++) {
4947 my $entry = $headlist->[$i];
4949 my $curr = $ref{'id'} eq $head;
4951 print "<tr class=\"dark\">\n";
4953 print "<tr class=\"light\">\n";
4956 print "<td><i>$ref{'age'}</i></td>\n" .
4957 ($curr ?
"<td class=\"current_head\">" : "<td>") .
4958 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
4959 -class => "list name"},esc_html
($ref{'name'})) .
4961 "<td class=\"link\">" .
4962 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
4963 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
4964 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'name'})}, "tree") .
4968 if (defined $extra) {
4970 "<td colspan=\"3\">$extra</td>\n" .
4976 sub git_search_grep_body
{
4977 my ($commitlist, $from, $to, $extra) = @_;
4978 $from = 0 unless defined $from;
4979 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4981 print "<table class=\"commit_search\">\n";
4983 for (my $i = $from; $i <= $to; $i++) {
4984 my %co = %{$commitlist->[$i]};
4988 my $commit = $co{'id'};
4990 print "<tr class=\"dark\">\n";
4992 print "<tr class=\"light\">\n";
4995 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4996 format_author_html
('td', \
%co, 15, 5) .
4998 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
4999 -class => "list subject"},
5000 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5001 my $comment = $co{'comment'};
5002 foreach my $line (@
$comment) {
5003 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5004 my ($lead, $match, $trail) = ($1, $2, $3);
5005 $match = chop_str
($match, 70, 5, 'center');
5006 my $contextlen = int((80 - length($match))/2);
5007 $contextlen = 30 if ($contextlen > 30);
5008 $lead = chop_str
($lead, $contextlen, 10, 'left');
5009 $trail = chop_str
($trail, $contextlen, 10, 'right');
5011 $lead = esc_html
($lead);
5012 $match = esc_html
($match);
5013 $trail = esc_html
($trail);
5015 print "$lead<span class=\"match\">$match</span>$trail<br />";
5019 "<td class=\"link\">" .
5020 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5022 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
5024 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5028 if (defined $extra) {
5030 "<td colspan=\"3\">$extra</td>\n" .
5036 ## ======================================================================
5037 ## ======================================================================
5040 sub git_project_list
{
5041 my $order = $input_params{'order'};
5042 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5043 die_error
(400, "Unknown order parameter");
5046 my @list = git_get_projects_list
();
5048 die_error
(404, "No projects found");
5052 if (defined $home_text && -f
$home_text) {
5053 print "<div class=\"index_include\">\n";
5054 insert_file
($home_text);
5057 print $cgi->startform(-method
=> "get") .
5058 "<p class=\"projsearch\">Search:\n" .
5059 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
5061 $cgi->end_form() . "\n";
5062 git_project_list_body
(\
@list, $order);
5067 my $order = $input_params{'order'};
5068 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5069 die_error
(400, "Unknown order parameter");
5072 my @list = git_get_projects_list
($project);
5074 die_error
(404, "No forks found");
5078 git_print_page_nav
('','');
5079 git_print_header_div
('summary', "$project forks");
5080 git_project_list_body
(\
@list, $order);
5084 sub git_project_index
{
5085 my @projects = git_get_projects_list
($project);
5088 -type
=> 'text/plain',
5089 -charset
=> 'utf-8',
5090 -content_disposition
=> 'inline; filename="index.aux"');
5092 foreach my $pr (@projects) {
5093 if (!exists $pr->{'owner'}) {
5094 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
5097 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
5098 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
5099 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5100 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5104 print "$path $owner\n";
5109 my $descr = git_get_project_description
($project) || "none";
5110 my %co = parse_commit
("HEAD");
5111 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
5112 my $head = $co{'id'};
5114 my $owner = git_get_project_owner
($project);
5116 my $refs = git_get_references
();
5117 # These get_*_list functions return one more to allow us to see if
5118 # there are more ...
5119 my @taglist = git_get_tags_list
(16);
5120 my @headlist = git_get_heads_list
(16);
5122 my $check_forks = gitweb_check_feature
('forks');
5125 @forklist = git_get_projects_list
($project);
5129 git_print_page_nav
('summary','', $head);
5131 print "<div class=\"title\"> </div>\n";
5132 print "<table class=\"projects_list\">\n" .
5133 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
5134 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
5135 if (defined $cd{'rfc2822'}) {
5136 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
5139 # use per project git URL list in $projectroot/$project/cloneurl
5140 # or make project git URL from git base URL and project name
5141 my $url_tag = "URL";
5142 my @url_list = git_get_project_url_list
($project);
5143 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
5144 foreach my $git_url (@url_list) {
5145 next unless $git_url;
5146 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
5151 my $show_ctags = gitweb_check_feature
('ctags');
5153 my $ctags = git_get_project_ctags
($project);
5154 my $cloud = git_populate_project_tagcloud
($ctags);
5155 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
5156 print "</td>\n<td>" unless %$ctags;
5157 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
5158 print "</td>\n<td>" if %$ctags;
5159 print git_show_project_tagcloud
($cloud, 48);
5165 # If XSS prevention is on, we don't include README.html.
5166 # TODO: Allow a readme in some safe format.
5167 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
5168 print "<div class=\"title\">readme</div>\n" .
5169 "<div class=\"readme\">\n";
5170 insert_file
("$projectroot/$project/README.html");
5171 print "\n</div>\n"; # class="readme"
5174 # we need to request one more than 16 (0..15) to check if
5176 my @commitlist = $head ? parse_commits
($head, 17) : ();
5178 git_print_header_div
('shortlog');
5179 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
5180 $#commitlist <= 15 ?
undef :
5181 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
5185 git_print_header_div
('tags');
5186 git_tags_body
(\
@taglist, 0, 15,
5187 $#taglist <= 15 ?
undef :
5188 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
5192 git_print_header_div
('heads');
5193 git_heads_body
(\
@headlist, $head, 0, 15,
5194 $#headlist <= 15 ?
undef :
5195 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
5199 git_print_header_div
('forks');
5200 git_project_list_body
(\
@forklist, 'age', 0, 15,
5201 $#forklist <= 15 ?
undef :
5202 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
5210 my %tag = parse_tag
($hash);
5213 die_error
(404, "Unknown tag object");
5216 my $head = git_get_head_hash
($project);
5218 git_print_page_nav
('','', $head,undef,$head);
5219 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
5220 print "<div class=\"title_text\">\n" .
5221 "<table class=\"object_header\">\n" .
5223 "<td>object</td>\n" .
5224 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
5225 $tag{'object'}) . "</td>\n" .
5226 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
5227 $tag{'type'}) . "</td>\n" .
5229 if (defined($tag{'author'})) {
5230 git_print_authorship_rows
(\
%tag, 'author');
5232 print "</table>\n\n" .
5234 print "<div class=\"page_body\">";
5235 my $comment = $tag{'comment'};
5236 foreach my $line (@
$comment) {
5238 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
5244 sub git_blame_common
{
5245 my $format = shift || 'porcelain';
5246 if ($format eq 'porcelain' && $cgi->param('js')) {
5247 $format = 'incremental';
5248 $action = 'blame_incremental'; # for page title etc
5252 gitweb_check_feature
('blame')
5253 or die_error
(403, "Blame view not allowed");
5256 die_error
(400, "No file name given") unless $file_name;
5257 $hash_base ||= git_get_head_hash
($project);
5258 die_error
(404, "Couldn't find base commit") unless $hash_base;
5259 my %co = parse_commit
($hash_base)
5260 or die_error
(404, "Commit not found");
5262 if (!defined $hash) {
5263 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
5264 or die_error
(404, "Error looking up file");
5266 $ftype = git_get_type
($hash);
5267 if ($ftype !~ "blob") {
5268 die_error
(400, "Object is not a blob");
5273 if ($format eq 'incremental') {
5274 # get file contents (as base)
5275 open $fd, "-|", git_cmd
(), 'cat-file', 'blob', $hash
5276 or die_error
(500, "Open git-cat-file failed");
5277 } elsif ($format eq 'data') {
5278 # run git-blame --incremental
5279 open $fd, "-|", git_cmd
(), "blame", "--incremental",
5280 $hash_base, "--", $file_name
5281 or die_error
(500, "Open git-blame --incremental failed");
5283 # run git-blame --porcelain
5284 open $fd, "-|", git_cmd
(), "blame", '-p',
5285 $hash_base, '--', $file_name
5286 or die_error
(500, "Open git-blame --porcelain failed");
5289 # incremental blame data returns early
5290 if ($format eq 'data') {
5292 -type
=>"text/plain", -charset
=> "utf-8",
5293 -status
=> "200 OK");
5294 local $| = 1; # output autoflush
5297 or print "ERROR $!\n";
5300 if (defined $t0 && gitweb_check_feature
('timed')) {
5302 Time
::HiRes
::tv_interval
($t0, [Time
::HiRes
::gettimeofday
()]).
5303 ' '.$number_of_git_cmds;
5313 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
5316 if ($format eq 'incremental') {
5318 $cgi->a({-href
=> href
(action
=>"blame", javascript
=>0, -replay
=>1)},
5319 "blame") . " (non-incremental)";
5322 $cgi->a({-href
=> href
(action
=>"blame_incremental", -replay
=>1)},
5323 "blame") . " (incremental)";
5327 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5330 $cgi->a({-href
=> href
(action
=>$action, file_name
=>$file_name)},
5332 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5333 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5334 git_print_page_path
($file_name, $ftype, $hash_base);
5337 if ($format eq 'incremental') {
5338 print "<noscript>\n<div class=\"error\"><center><b>\n".
5339 "This page requires JavaScript to run.\n Use ".
5340 $cgi->a({-href
=> href
(action
=>'blame',javascript
=>0,-replay
=>1)},
5343 "</b></center></div>\n</noscript>\n";
5345 print qq!<div id
="progress_bar" style
="width: 100%; background-color: yellow"></div
>\n!;
5348 print qq!<div
class="page_body">\n!;
5349 print qq!<div id
="progress_info">... / ...</div
>\n!
5350 if ($format eq 'incremental');
5351 print qq!<table id
="blame_table" class="blame" width
="100%">\n!.
5352 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
5354 qq!<tr
><th
>Commit
</th><th>Line</th
><th
>Data
</th></tr
>\n!.
5358 my @rev_color = qw(light dark);
5359 my $num_colors = scalar(@rev_color);
5360 my $current_color = 0;
5362 if ($format eq 'incremental') {
5363 my $color_class = $rev_color[$current_color];
5368 while (my $line = <$fd>) {
5372 print qq!<tr id
="l$linenr" class="$color_class">!.
5373 qq!<td
class="sha1"><a href
=""> </a></td
>!.
5374 qq!<td
class="linenr">!.
5375 qq!<a
class="linenr" href
="">$linenr</a></td
>!;
5376 print qq!<td
class="pre">! . esc_html
($line) . "</td>\n";
5380 } else { # porcelain, i.e. ordinary blame
5381 my %metainfo = (); # saves information about commits
5385 while (my $line = <$fd>) {
5387 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
5388 # no <lines in group> for subsequent lines in group of lines
5389 my ($full_rev, $orig_lineno, $lineno, $group_size) =
5390 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
5391 if (!exists $metainfo{$full_rev}) {
5392 $metainfo{$full_rev} = { 'nprevious' => 0 };
5394 my $meta = $metainfo{$full_rev};
5396 while ($data = <$fd>) {
5398 last if ($data =~ s/^\t//); # contents of line
5399 if ($data =~ /^(\S+)(?: (.*))?$/) {
5400 $meta->{$1} = $2 unless exists $meta->{$1};
5402 if ($data =~ /^previous /) {
5403 $meta->{'nprevious'}++;
5406 my $short_rev = substr($full_rev, 0, 8);
5407 my $author = $meta->{'author'};
5409 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
5410 my $date = $date{'iso-tz'};
5412 $current_color = ($current_color + 1) % $num_colors;
5414 my $tr_class = $rev_color[$current_color];
5415 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
5416 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
5417 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
5418 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
5420 print "<td class=\"sha1\"";
5421 print " title=\"". esc_html
($author) . ", $date\"";
5422 print " rowspan=\"$group_size\"" if ($group_size > 1);
5424 print $cgi->a({-href
=> href
(action
=>"commit",
5426 file_name
=>$file_name)},
5427 esc_html
($short_rev));
5428 if ($group_size >= 2) {
5429 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
5430 if (@author_initials) {
5432 esc_html
(join('', @author_initials));
5438 # 'previous' <sha1 of parent commit> <filename at commit>
5439 if (exists $meta->{'previous'} &&
5440 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
5441 $meta->{'parent'} = $1;
5442 $meta->{'file_parent'} = unquote
($2);
5445 exists($meta->{'parent'}) ?
5446 $meta->{'parent'} : $full_rev;
5447 my $linenr_filename =
5448 exists($meta->{'file_parent'}) ?
5449 $meta->{'file_parent'} : unquote
($meta->{'filename'});
5450 my $blamed = href
(action
=> 'blame',
5451 file_name
=> $linenr_filename,
5452 hash_base
=> $linenr_commit);
5453 print "<td class=\"linenr\">";
5454 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
5455 -class => "linenr" },
5458 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
5466 "</table>\n"; # class="blame"
5467 print "</div>\n"; # class="blame_body"
5469 or print "Reading blob failed\n";
5478 sub git_blame_incremental
{
5479 git_blame_common
('incremental');
5482 sub git_blame_data
{
5483 git_blame_common
('data');
5487 my $head = git_get_head_hash
($project);
5489 git_print_page_nav
('','', $head,undef,$head);
5490 git_print_header_div
('summary', $project);
5492 my @tagslist = git_get_tags_list
();
5494 git_tags_body
(\
@tagslist);
5500 my $head = git_get_head_hash
($project);
5502 git_print_page_nav
('','', $head,undef,$head);
5503 git_print_header_div
('summary', $project);
5505 my @headslist = git_get_heads_list
();
5507 git_heads_body
(\
@headslist, $head);
5512 sub git_blob_plain
{
5516 if (!defined $hash) {
5517 if (defined $file_name) {
5518 my $base = $hash_base || git_get_head_hash
($project);
5519 $hash = git_get_hash_by_path
($base, $file_name, "blob")
5520 or die_error
(404, "Cannot find file");
5522 die_error
(400, "No file name defined");
5524 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5525 # blobs defined by non-textual hash id's can be cached
5529 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
5530 or die_error
(500, "Open git-cat-file blob '$hash' failed");
5532 # content-type (can include charset)
5533 $type = blob_contenttype
($fd, $file_name, $type);
5535 # "save as" filename, even when no $file_name is given
5536 my $save_as = "$hash";
5537 if (defined $file_name) {
5538 $save_as = $file_name;
5539 } elsif ($type =~ m/^text\//) {
5543 # With XSS prevention on, blobs of all types except a few known safe
5544 # ones are served with "Content-Disposition: attachment" to make sure
5545 # they don't run in our security domain. For certain image types,
5546 # blob view writes an <img> tag referring to blob_plain view, and we
5547 # want to be sure not to break that by serving the image as an
5548 # attachment (though Firefox 3 doesn't seem to care).
5549 my $sandbox = $prevent_xss &&
5550 $type !~ m!^(?:text/plain|image/(?:gif|png|jpeg))$!;
5554 -expires
=> $expires,
5555 -content_disposition
=>
5556 ($sandbox ?
'attachment' : 'inline')
5557 . '; filename="' . $save_as . '"');
5559 binmode STDOUT
, ':raw';
5561 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
5568 if (!defined $hash) {
5569 if (defined $file_name) {
5570 my $base = $hash_base || git_get_head_hash
($project);
5571 $hash = git_get_hash_by_path
($base, $file_name, "blob")
5572 or die_error
(404, "Cannot find file");
5574 die_error
(400, "No file name defined");
5576 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5577 # blobs defined by non-textual hash id's can be cached
5581 my $have_blame = gitweb_check_feature
('blame');
5582 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
5583 or die_error
(500, "Couldn't cat $file_name, $hash");
5584 my $mimetype = blob_mimetype
($fd, $file_name);
5585 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
5586 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
5588 return git_blob_plain
($mimetype);
5590 # we can have blame only for text/* mimetype
5591 $have_blame &&= ($mimetype =~ m!^text/!);
5593 my $highlight = gitweb_check_feature
('highlight');
5594 my $syntax = guess_file_syntax
($highlight, $mimetype, $file_name);
5595 $fd = run_highlighter
($fd, $highlight, $syntax)
5598 git_header_html
(undef, $expires);
5599 my $formats_nav = '';
5600 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5601 if (defined $file_name) {
5604 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
5609 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5612 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
5615 $cgi->a({-href
=> href
(action
=>"blob",
5616 hash_base
=>"HEAD", file_name
=>$file_name)},
5620 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
5623 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5624 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5626 print "<div class=\"page_nav\">\n" .
5627 "<br/><br/></div>\n" .
5628 "<div class=\"title\">$hash</div>\n";
5630 git_print_page_path
($file_name, "blob", $hash_base);
5631 print "<div class=\"page_body\">\n";
5632 if ($mimetype =~ m!^image/!) {
5633 print qq!<img type
="$mimetype"!;
5635 print qq! alt
="$file_name" title
="$file_name"!;
5638 href(action=>"blob_plain
", hash=>$hash,
5639 hash_base=>$hash_base, file_name=>$file_name) .
5643 while (my $line = <$fd>) {
5646 $line = untabify
($line);
5647 printf qq!<div
class="pre"><a id
="l%i" href
="%s#l%i" class="linenr">%4i</a> %s</div
>\n!,
5648 $nr, href
(-replay
=> 1), $nr, $nr, $syntax ?
$line : esc_html
($line, -nbsp
=>1);
5652 or print "Reading blob failed.\n";
5658 if (!defined $hash_base) {
5659 $hash_base = "HEAD";
5661 if (!defined $hash) {
5662 if (defined $file_name) {
5663 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
5668 die_error
(404, "No such tree") unless defined($hash);
5670 my $show_sizes = gitweb_check_feature
('show-sizes');
5671 my $have_blame = gitweb_check_feature
('blame');
5676 open my $fd, "-|", git_cmd
(), "ls-tree", '-z',
5677 ($show_sizes ?
'-l' : ()), @extra_options, $hash
5678 or die_error
(500, "Open git-ls-tree failed");
5679 @entries = map { chomp; $_ } <$fd>;
5681 or die_error
(404, "Reading tree failed");
5684 my $refs = git_get_references
();
5685 my $ref = format_ref_marker
($refs, $hash_base);
5688 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5690 if (defined $file_name) {
5692 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
5694 $cgi->a({-href
=> href
(action
=>"tree",
5695 hash_base
=>"HEAD", file_name
=>$file_name)},
5698 my $snapshot_links = format_snapshot_links
($hash);
5699 if (defined $snapshot_links) {
5700 # FIXME: Should be available when we have no hash base as well.
5701 push @views_nav, $snapshot_links;
5703 git_print_page_nav
('tree','', $hash_base, undef, undef,
5704 join(' | ', @views_nav));
5705 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
5708 print "<div class=\"page_nav\">\n";
5709 print "<br/><br/></div>\n";
5710 print "<div class=\"title\">$hash</div>\n";
5712 if (defined $file_name) {
5713 $basedir = $file_name;
5714 if ($basedir ne '' && substr($basedir, -1) ne '/') {
5717 git_print_page_path
($file_name, 'tree', $hash_base);
5719 print "<div class=\"page_body\">\n";
5720 print "<table class=\"tree\">\n";
5722 # '..' (top directory) link if possible
5723 if (defined $hash_base &&
5724 defined $file_name && $file_name =~ m![^/]+$!) {
5726 print "<tr class=\"dark\">\n";
5728 print "<tr class=\"light\">\n";
5732 my $up = $file_name;
5733 $up =~ s!/?[^/]+$!!;
5734 undef $up unless $up;
5735 # based on git_print_tree_entry
5736 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
5737 print '<td class="size"> </td>'."\n" if $show_sizes;
5738 print '<td class="list">';
5739 print $cgi->a({-href
=> href
(action
=>"tree",
5740 hash_base
=>$hash_base,
5744 print "<td class=\"link\"></td>\n";
5748 foreach my $line (@entries) {
5749 my %t = parse_ls_tree_line
($line, -z
=> 1, -l
=> $show_sizes);
5752 print "<tr class=\"dark\">\n";
5754 print "<tr class=\"light\">\n";
5758 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
5762 print "</table>\n" .
5768 my ($project, $hash) = @_;
5770 # path/to/project.git -> project
5771 # path/to/project/.git -> project
5772 my $name = to_utf8
($project);
5773 $name =~ s
,([^/])/*\
.git
$,$1,;
5774 $name = basename
($name);
5776 $name =~ s/[[:cntrl:]]/?/g;
5779 if ($hash =~ /^[0-9a-fA-F]+$/) {
5780 # shorten SHA-1 hash
5781 my $full_hash = git_get_full_hash
($project, $hash);
5782 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
5783 $ver = git_get_short_hash
($project, $hash);
5785 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
5786 # tags don't need shortened SHA-1 hash
5789 # branches and other need shortened SHA-1 hash
5790 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
5793 $ver .= '-' . git_get_short_hash
($project, $hash);
5795 # in case of hierarchical branch names
5798 # name = project-version_string
5799 $name = "$name-$ver";
5801 return wantarray ?
($name, $name) : $name;
5805 my $format = $input_params{'snapshot_format'};
5806 if (!@snapshot_fmts) {
5807 die_error
(403, "Snapshots not allowed");
5809 # default to first supported snapshot format
5810 $format ||= $snapshot_fmts[0];
5811 if ($format !~ m/^[a-z0-9]+$/) {
5812 die_error
(400, "Invalid snapshot format parameter");
5813 } elsif (!exists($known_snapshot_formats{$format})) {
5814 die_error
(400, "Unknown snapshot format");
5815 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
5816 die_error
(403, "Snapshot format not allowed");
5817 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
5818 die_error
(403, "Unsupported snapshot format");
5821 my $type = git_get_type
("$hash^{}");
5823 die_error
(404, 'Object does not exist');
5824 } elsif ($type eq 'blob') {
5825 die_error
(400, 'Object is not a tree-ish');
5828 my ($name, $prefix) = snapshot_name
($project, $hash);
5829 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
5830 my $cmd = quote_command
(
5831 git_cmd
(), 'archive',
5832 "--format=$known_snapshot_formats{$format}{'format'}",
5833 "--prefix=$prefix/", $hash);
5834 if (exists $known_snapshot_formats{$format}{'compressor'}) {
5835 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
5838 $filename =~ s/(["\\])/\\$1/g;
5840 -type
=> $known_snapshot_formats{$format}{'type'},
5841 -content_disposition
=> 'inline; filename="' . $filename . '"',
5842 -status
=> '200 OK');
5844 open my $fd, "-|", $cmd
5845 or die_error
(500, "Execute git-archive failed");
5846 binmode STDOUT
, ':raw';
5848 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
5852 sub git_log_generic
{
5853 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
5855 my $head = git_get_head_hash
($project);
5856 if (!defined $base) {
5859 if (!defined $page) {
5862 my $refs = git_get_references
();
5864 my $commit_hash = $base;
5865 if (defined $parent) {
5866 $commit_hash = "$parent..$base";
5869 parse_commits
($commit_hash, 101, (100 * $page),
5870 defined $file_name ?
($file_name, "--full-history") : ());
5873 if (!defined $file_hash && defined $file_name) {
5874 # some commits could have deleted file in question,
5875 # and not have it in tree, but one of them has to have it
5876 for (my $i = 0; $i < @commitlist; $i++) {
5877 $file_hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
5878 last if defined $file_hash;
5881 if (defined $file_hash) {
5882 $ftype = git_get_type
($file_hash);
5884 if (defined $file_name && !defined $ftype) {
5885 die_error
(500, "Unknown type of object");
5888 if (defined $file_name) {
5889 %co = parse_commit
($base)
5890 or die_error
(404, "Unknown commit object");
5894 my $paging_nav = format_paging_nav
($fmt_name, $page, $#commitlist >= 100);
5896 if ($#commitlist >= 100) {
5898 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5899 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5901 my $patch_max = gitweb_get_feature
('patches');
5902 if ($patch_max && !defined $file_name) {
5903 if ($patch_max < 0 || @commitlist <= $patch_max) {
5904 $paging_nav .= " ⋅ " .
5905 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
5911 git_print_page_nav
($fmt_name,'', $hash,$hash,$hash, $paging_nav);
5912 if (defined $file_name) {
5913 git_print_header_div
('commit', esc_html
($co{'title'}), $base);
5915 git_print_header_div
('summary', $project)
5917 git_print_page_path
($file_name, $ftype, $hash_base)
5918 if (defined $file_name);
5920 $body_subr->(\
@commitlist, 0, 99, $refs, $next_link,
5921 $file_name, $file_hash, $ftype);
5927 git_log_generic
('log', \
&git_log_body
,
5928 $hash, $hash_parent);
5932 $hash ||= $hash_base || "HEAD";
5933 my %co = parse_commit
($hash)
5934 or die_error
(404, "Unknown commit object");
5936 my $parent = $co{'parent'};
5937 my $parents = $co{'parents'}; # listref
5939 # we need to prepare $formats_nav before any parameter munging
5941 if (!defined $parent) {
5943 $formats_nav .= '(initial)';
5944 } elsif (@
$parents == 1) {
5945 # single parent commit
5948 $cgi->a({-href
=> href
(action
=>"commit",
5950 esc_html
(substr($parent, 0, 7))) .
5957 $cgi->a({-href
=> href
(action
=>"commit",
5959 esc_html
(substr($_, 0, 7)));
5963 if (gitweb_check_feature
('patches') && @
$parents <= 1) {
5964 $formats_nav .= " | " .
5965 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
5969 if (!defined $parent) {
5973 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
5975 (@
$parents <= 1 ?
$parent : '-c'),
5977 or die_error
(500, "Open git-diff-tree failed");
5978 @difftree = map { chomp; $_ } <$fd>;
5979 close $fd or die_error
(404, "Reading git-diff-tree failed");
5981 # non-textual hash id's can be cached
5983 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5986 my $refs = git_get_references
();
5987 my $ref = format_ref_marker
($refs, $co{'id'});
5989 git_header_html
(undef, $expires);
5990 git_print_page_nav
('commit', '',
5991 $hash, $co{'tree'}, $hash,
5994 if (defined $co{'parent'}) {
5995 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
5997 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
5999 print "<div class=\"title_text\">\n" .
6000 "<table class=\"object_header\">\n";
6001 git_print_authorship_rows
(\
%co);
6002 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
6005 "<td class=\"sha1\">" .
6006 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
6007 class => "list"}, $co{'tree'}) .
6009 "<td class=\"link\">" .
6010 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
6012 my $snapshot_links = format_snapshot_links
($hash);
6013 if (defined $snapshot_links) {
6014 print " | " . $snapshot_links;
6019 foreach my $par (@
$parents) {
6022 "<td class=\"sha1\">" .
6023 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
6024 class => "list"}, $par) .
6026 "<td class=\"link\">" .
6027 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
6029 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
6036 print "<div class=\"page_body\">\n";
6037 git_print_log
($co{'comment'});
6040 git_difftree_body
(\
@difftree, $hash, @
$parents);
6046 # object is defined by:
6047 # - hash or hash_base alone
6048 # - hash_base and file_name
6051 # - hash or hash_base alone
6052 if ($hash || ($hash_base && !defined $file_name)) {
6053 my $object_id = $hash || $hash_base;
6055 open my $fd, "-|", quote_command
(
6056 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
6057 or die_error
(404, "Object does not exist");
6061 or die_error
(404, "Object does not exist");
6063 # - hash_base and file_name
6064 } elsif ($hash_base && defined $file_name) {
6065 $file_name =~ s
,/+$,,;
6067 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
6068 or die_error
(404, "Base object does not exist");
6070 # here errors should not hapen
6071 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
6072 or die_error
(500, "Open git-ls-tree failed");
6076 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
6077 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
6078 die_error
(404, "File or directory for given base does not exist");
6083 die_error
(400, "Not enough information to find object");
6086 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
6087 hash
=>$hash, hash_base
=>$hash_base,
6088 file_name
=>$file_name),
6089 -status
=> '302 Found');
6093 my $format = shift || 'html';
6100 # preparing $fd and %diffinfo for git_patchset_body
6102 if (defined $hash_base && defined $hash_parent_base) {
6103 if (defined $file_name) {
6105 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6106 $hash_parent_base, $hash_base,
6107 "--", (defined $file_parent ?
$file_parent : ()), $file_name
6108 or die_error
(500, "Open git-diff-tree failed");
6109 @difftree = map { chomp; $_ } <$fd>;
6111 or die_error
(404, "Reading git-diff-tree failed");
6113 or die_error
(404, "Blob diff not found");
6115 } elsif (defined $hash &&
6116 $hash =~ /[0-9a-fA-F]{40}/) {
6117 # try to find filename from $hash
6119 # read filtered raw output
6120 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6121 $hash_parent_base, $hash_base, "--"
6122 or die_error
(500, "Open git-diff-tree failed");
6124 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
6126 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
6127 map { chomp; $_ } <$fd>;
6129 or die_error
(404, "Reading git-diff-tree failed");
6131 or die_error
(404, "Blob diff not found");
6134 die_error
(400, "Missing one of the blob diff parameters");
6137 if (@difftree > 1) {
6138 die_error
(400, "Ambiguous blob diff specification");
6141 %diffinfo = parse_difftree_raw_line
($difftree[0]);
6142 $file_parent ||= $diffinfo{'from_file'} || $file_name;
6143 $file_name ||= $diffinfo{'to_file'};
6145 $hash_parent ||= $diffinfo{'from_id'};
6146 $hash ||= $diffinfo{'to_id'};
6148 # non-textual hash id's can be cached
6149 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
6150 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
6155 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6156 '-p', ($format eq 'html' ?
"--full-index" : ()),
6157 $hash_parent_base, $hash_base,
6158 "--", (defined $file_parent ?
$file_parent : ()), $file_name
6159 or die_error
(500, "Open git-diff-tree failed");
6162 # old/legacy style URI -- not generated anymore since 1.4.3.
6164 die_error
('404 Not Found', "Missing one of the blob diff parameters")
6168 if ($format eq 'html') {
6170 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
6172 git_header_html
(undef, $expires);
6173 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6174 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6175 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6177 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
6178 print "<div class=\"title\">$hash vs $hash_parent</div>\n";
6180 if (defined $file_name) {
6181 git_print_page_path
($file_name, "blob", $hash_base);
6183 print "<div class=\"page_path\"></div>\n";
6186 } elsif ($format eq 'plain') {
6188 -type
=> 'text/plain',
6189 -charset
=> 'utf-8',
6190 -expires
=> $expires,
6191 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
6193 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6196 die_error
(400, "Unknown blobdiff format");
6200 if ($format eq 'html') {
6201 print "<div class=\"page_body\">\n";
6203 git_patchset_body
($fd, [ \
%diffinfo ], $hash_base, $hash_parent_base);
6206 print "</div>\n"; # class="page_body"
6210 while (my $line = <$fd>) {
6211 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
6212 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
6216 last if $line =~ m!^\+\+\+!;
6224 sub git_blobdiff_plain
{
6225 git_blobdiff
('plain');
6228 sub git_commitdiff
{
6230 my $format = $params{-format
} || 'html';
6232 my ($patch_max) = gitweb_get_feature
('patches');
6233 if ($format eq 'patch') {
6234 die_error
(403, "Patch view not allowed") unless $patch_max;
6237 $hash ||= $hash_base || "HEAD";
6238 my %co = parse_commit
($hash)
6239 or die_error
(404, "Unknown commit object");
6241 # choose format for commitdiff for merge
6242 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
6243 $hash_parent = '--cc';
6245 # we need to prepare $formats_nav before almost any parameter munging
6247 if ($format eq 'html') {
6249 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
6251 if ($patch_max && @
{$co{'parents'}} <= 1) {
6252 $formats_nav .= " | " .
6253 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6257 if (defined $hash_parent &&
6258 $hash_parent ne '-c' && $hash_parent ne '--cc') {
6259 # commitdiff with two commits given
6260 my $hash_parent_short = $hash_parent;
6261 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
6262 $hash_parent_short = substr($hash_parent, 0, 7);
6266 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
6267 if ($co{'parents'}[$i] eq $hash_parent) {
6268 $formats_nav .= ' parent ' . ($i+1);
6272 $formats_nav .= ': ' .
6273 $cgi->a({-href
=> href
(action
=>"commitdiff",
6274 hash
=>$hash_parent)},
6275 esc_html
($hash_parent_short)) .
6277 } elsif (!$co{'parent'}) {
6279 $formats_nav .= ' (initial)';
6280 } elsif (scalar @
{$co{'parents'}} == 1) {
6281 # single parent commit
6284 $cgi->a({-href
=> href
(action
=>"commitdiff",
6285 hash
=>$co{'parent'})},
6286 esc_html
(substr($co{'parent'}, 0, 7))) .
6290 if ($hash_parent eq '--cc') {
6291 $formats_nav .= ' | ' .
6292 $cgi->a({-href
=> href
(action
=>"commitdiff",
6293 hash
=>$hash, hash_parent
=>'-c')},
6295 } else { # $hash_parent eq '-c'
6296 $formats_nav .= ' | ' .
6297 $cgi->a({-href
=> href
(action
=>"commitdiff",
6298 hash
=>$hash, hash_parent
=>'--cc')},
6304 $cgi->a({-href
=> href
(action
=>"commitdiff",
6306 esc_html
(substr($_, 0, 7)));
6307 } @
{$co{'parents'}} ) .
6312 my $hash_parent_param = $hash_parent;
6313 if (!defined $hash_parent_param) {
6314 # --cc for multiple parents, --root for parentless
6315 $hash_parent_param =
6316 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
6322 if ($format eq 'html') {
6323 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6324 "--no-commit-id", "--patch-with-raw", "--full-index",
6325 $hash_parent_param, $hash, "--"
6326 or die_error
(500, "Open git-diff-tree failed");
6328 while (my $line = <$fd>) {
6330 # empty line ends raw part of diff-tree output
6332 push @difftree, scalar parse_difftree_raw_line
($line);
6335 } elsif ($format eq 'plain') {
6336 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6337 '-p', $hash_parent_param, $hash, "--"
6338 or die_error
(500, "Open git-diff-tree failed");
6339 } elsif ($format eq 'patch') {
6340 # For commit ranges, we limit the output to the number of
6341 # patches specified in the 'patches' feature.
6342 # For single commits, we limit the output to a single patch,
6343 # diverging from the git-format-patch default.
6344 my @commit_spec = ();
6346 if ($patch_max > 0) {
6347 push @commit_spec, "-$patch_max";
6349 push @commit_spec, '-n', "$hash_parent..$hash";
6351 if ($params{-single
}) {
6352 push @commit_spec, '-1';
6354 if ($patch_max > 0) {
6355 push @commit_spec, "-$patch_max";
6357 push @commit_spec, "-n";
6359 push @commit_spec, '--root', $hash;
6361 open $fd, "-|", git_cmd
(), "format-patch", @diff_opts,
6362 '--encoding=utf8', '--stdout', @commit_spec
6363 or die_error
(500, "Open git-format-patch failed");
6365 die_error
(400, "Unknown commitdiff format");
6368 # non-textual hash id's can be cached
6370 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6374 # write commit message
6375 if ($format eq 'html') {
6376 my $refs = git_get_references
();
6377 my $ref = format_ref_marker
($refs, $co{'id'});
6379 git_header_html
(undef, $expires);
6380 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
6381 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
6382 print "<div class=\"title_text\">\n" .
6383 "<table class=\"object_header\">\n";
6384 git_print_authorship_rows
(\
%co);
6387 print "<div class=\"page_body\">\n";
6388 if (@
{$co{'comment'}} > 1) {
6389 print "<div class=\"log\">\n";
6390 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
6391 print "</div>\n"; # class="log"
6394 } elsif ($format eq 'plain') {
6395 my $refs = git_get_references
("tags");
6396 my $tagname = git_get_rev_name_tags
($hash);
6397 my $filename = basename
($project) . "-$hash.patch";
6400 -type
=> 'text/plain',
6401 -charset
=> 'utf-8',
6402 -expires
=> $expires,
6403 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
6404 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
6405 print "From: " . to_utf8
($co{'author'}) . "\n";
6406 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
6407 print "Subject: " . to_utf8
($co{'title'}) . "\n";
6409 print "X-Git-Tag: $tagname\n" if $tagname;
6410 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6412 foreach my $line (@
{$co{'comment'}}) {
6413 print to_utf8
($line) . "\n";
6416 } elsif ($format eq 'patch') {
6417 my $filename = basename
($project) . "-$hash.patch";
6420 -type
=> 'text/plain',
6421 -charset
=> 'utf-8',
6422 -expires
=> $expires,
6423 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
6427 if ($format eq 'html') {
6428 my $use_parents = !defined $hash_parent ||
6429 $hash_parent eq '-c' || $hash_parent eq '--cc';
6430 git_difftree_body
(\
@difftree, $hash,
6431 $use_parents ? @
{$co{'parents'}} : $hash_parent);
6434 git_patchset_body
($fd, \
@difftree, $hash,
6435 $use_parents ? @
{$co{'parents'}} : $hash_parent);
6437 print "</div>\n"; # class="page_body"
6440 } elsif ($format eq 'plain') {
6444 or print "Reading git-diff-tree failed\n";
6445 } elsif ($format eq 'patch') {
6449 or print "Reading git-format-patch failed\n";
6453 sub git_commitdiff_plain
{
6454 git_commitdiff
(-format
=> 'plain');
6457 # format-patch-style patches
6459 git_commitdiff
(-format
=> 'patch', -single
=> 1);
6463 git_commitdiff
(-format
=> 'patch');
6467 git_log_generic
('history', \
&git_history_body
,
6468 $hash_base, $hash_parent_base,
6473 gitweb_check_feature
('search') or die_error
(403, "Search is disabled");
6474 if (!defined $searchtext) {
6475 die_error
(400, "Text field is empty");
6477 if (!defined $hash) {
6478 $hash = git_get_head_hash
($project);
6480 my %co = parse_commit
($hash);
6482 die_error
(404, "Unknown commit object");
6484 if (!defined $page) {
6488 $searchtype ||= 'commit';
6489 if ($searchtype eq 'pickaxe') {
6490 # pickaxe may take all resources of your box and run for several minutes
6491 # with every query - so decide by yourself how public you make this feature
6492 gitweb_check_feature
('pickaxe')
6493 or die_error
(403, "Pickaxe is disabled");
6495 if ($searchtype eq 'grep') {
6496 gitweb_check_feature
('grep')
6497 or die_error
(403, "Grep is disabled");
6502 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
6504 if ($searchtype eq 'commit') {
6505 $greptype = "--grep=";
6506 } elsif ($searchtype eq 'author') {
6507 $greptype = "--author=";
6508 } elsif ($searchtype eq 'committer') {
6509 $greptype = "--committer=";
6511 $greptype .= $searchtext;
6512 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
6513 $greptype, '--regexp-ignore-case',
6514 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
6516 my $paging_nav = '';
6519 $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
6520 searchtext
=>$searchtext,
6521 searchtype
=>$searchtype)},
6523 $paging_nav .= " ⋅ " .
6524 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
6525 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
6527 $paging_nav .= "first";
6528 $paging_nav .= " ⋅ prev";
6531 if ($#commitlist >= 100) {
6533 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6534 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
6535 $paging_nav .= " ⋅ $next_link";
6537 $paging_nav .= " ⋅ next";
6540 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
6541 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6542 if ($page == 0 && !@commitlist) {
6543 print "<p>No match.</p>\n";
6545 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
6549 if ($searchtype eq 'pickaxe') {
6550 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
6551 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6553 print "<table class=\"pickaxe search\">\n";
6556 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
6557 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
6558 ($search_use_regexp ?
'--pickaxe-regex' : ());
6561 while (my $line = <$fd>) {
6565 my %set = parse_difftree_raw_line
($line);
6566 if (defined $set{'commit'}) {
6567 # finish previous commit
6570 "<td class=\"link\">" .
6571 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
6573 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
6579 print "<tr class=\"dark\">\n";
6581 print "<tr class=\"light\">\n";
6584 %co = parse_commit
($set{'commit'});
6585 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
6586 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
6587 "<td><i>$author</i></td>\n" .
6589 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
6590 -class => "list subject"},
6591 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
6592 } elsif (defined $set{'to_id'}) {
6593 next if ($set{'to_id'} =~ m/^0{40}$/);
6595 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
6596 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
6598 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
6604 # finish last commit (warning: repetition!)
6607 "<td class=\"link\">" .
6608 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
6610 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
6618 if ($searchtype eq 'grep') {
6619 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
6620 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
6622 print "<table class=\"grep_search\">\n";
6626 open my $fd, "-|", git_cmd
(), 'grep', '-n',
6627 $search_use_regexp ?
('-E', '-i') : '-F',
6628 $searchtext, $co{'tree'};
6630 while (my $line = <$fd>) {
6632 my ($file, $lno, $ltext, $binary);
6633 last if ($matches++ > 1000);
6634 if ($line =~ /^Binary file (.+) matches$/) {
6638 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
6640 if ($file ne $lastfile) {
6641 $lastfile and print "</td></tr>\n";
6643 print "<tr class=\"dark\">\n";
6645 print "<tr class=\"light\">\n";
6647 print "<td class=\"list\">".
6648 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
6649 file_name
=>"$file"),
6650 -class => "list"}, esc_path
($file));
6651 print "</td><td>\n";
6655 print "<div class=\"binary\">Binary file</div>\n";
6657 $ltext = untabify
($ltext);
6658 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
6659 $ltext = esc_html
($1, -nbsp
=>1);
6660 $ltext .= '<span class="match">';
6661 $ltext .= esc_html
($2, -nbsp
=>1);
6662 $ltext .= '</span>';
6663 $ltext .= esc_html
($3, -nbsp
=>1);
6665 $ltext = esc_html
($ltext, -nbsp
=>1);
6667 print "<div class=\"pre\">" .
6668 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
6669 file_name
=>"$file").'#l'.$lno,
6670 -class => "linenr"}, sprintf('%4i', $lno))
6671 . ' ' . $ltext . "</div>\n";
6675 print "</td></tr>\n";
6676 if ($matches > 1000) {
6677 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
6680 print "<div class=\"diff nodifferences\">No matches found</div>\n";
6689 sub git_search_help
{
6691 git_print_page_nav
('','', $hash,$hash,$hash);
6693 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
6694 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
6695 the pattern entered is recognized as the POSIX extended
6696 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
6699 <dt><b>commit</b></dt>
6700 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
6702 my $have_grep = gitweb_check_feature
('grep');
6705 <dt><b>grep</b></dt>
6706 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
6707 a different one) are searched for the given pattern. On large trees, this search can take
6708 a while and put some strain on the server, so please use it with some consideration. Note that
6709 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
6710 case-sensitive.</dd>
6714 <dt><b>author</b></dt>
6715 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
6716 <dt><b>committer</b></dt>
6717 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
6719 my $have_pickaxe = gitweb_check_feature
('pickaxe');
6720 if ($have_pickaxe) {
6722 <dt><b>pickaxe</b></dt>
6723 <dd>All commits that caused the string to appear or disappear from any file (changes that
6724 added, removed or "modified" the string) will be listed. This search can take a while and
6725 takes a lot of strain on the server, so please use it wisely. Note that since you may be
6726 interested even in changes just changing the case as well, this search is case sensitive.</dd>
6734 git_log_generic
('shortlog', \
&git_shortlog_body
,
6735 $hash, $hash_parent);
6738 ## ......................................................................
6739 ## feeds (RSS, Atom; OPML)
6742 my $format = shift || 'atom';
6743 my $have_blame = gitweb_check_feature
('blame');
6745 # Atom: http://www.atomenabled.org/developers/syndication/
6746 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
6747 if ($format ne 'rss' && $format ne 'atom') {
6748 die_error
(400, "Unknown web feed format");
6751 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
6752 my $head = $hash || 'HEAD';
6753 my @commitlist = parse_commits
($head, 150, 0, $file_name);
6757 my $content_type = "application/$format+xml";
6758 if (defined $cgi->http('HTTP_ACCEPT') &&
6759 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
6760 # browser (feed reader) prefers text/xml
6761 $content_type = 'text/xml';
6763 if (defined($commitlist[0])) {
6764 %latest_commit = %{$commitlist[0]};
6765 my $latest_epoch = $latest_commit{'committer_epoch'};
6766 %latest_date = parse_date
($latest_epoch);
6767 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
6768 if (defined $if_modified) {
6770 if (eval { require HTTP
::Date
; 1; }) {
6771 $since = HTTP
::Date
::str2time
($if_modified);
6772 } elsif (eval { require Time
::ParseDate
; 1; }) {
6773 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
6775 if (defined $since && $latest_epoch <= $since) {
6777 -type
=> $content_type,
6778 -charset
=> 'utf-8',
6779 -last_modified
=> $latest_date{'rfc2822'},
6780 -status
=> '304 Not Modified');
6785 -type
=> $content_type,
6786 -charset
=> 'utf-8',
6787 -last_modified
=> $latest_date{'rfc2822'});
6790 -type
=> $content_type,
6791 -charset
=> 'utf-8');
6794 # Optimization: skip generating the body if client asks only
6795 # for Last-Modified date.
6796 return if ($cgi->request_method() eq 'HEAD');
6799 my $title = "$site_name - $project/$action";
6800 my $feed_type = 'log';
6801 if (defined $hash) {
6802 $title .= " - '$hash'";
6803 $feed_type = 'branch log';
6804 if (defined $file_name) {
6805 $title .= " :: $file_name";
6806 $feed_type = 'history';
6808 } elsif (defined $file_name) {
6809 $title .= " - $file_name";
6810 $feed_type = 'history';
6812 $title .= " $feed_type";
6813 my $descr = git_get_project_description
($project);
6814 if (defined $descr) {
6815 $descr = esc_html
($descr);
6817 $descr = "$project " .
6818 ($format eq 'rss' ?
'RSS' : 'Atom') .
6821 my $owner = git_get_project_owner
($project);
6822 $owner = esc_html
($owner);
6826 if (defined $file_name) {
6827 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
6828 } elsif (defined $hash) {
6829 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
6831 $alt_url = href
(-full
=>1, action
=>"summary");
6833 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
6834 if ($format eq 'rss') {
6836 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
6839 print "<title>$title</title>\n" .
6840 "<link>$alt_url</link>\n" .
6841 "<description>$descr</description>\n" .
6842 "<language>en</language>\n" .
6843 # project owner is responsible for 'editorial' content
6844 "<managingEditor>$owner</managingEditor>\n";
6845 if (defined $logo || defined $favicon) {
6846 # prefer the logo to the favicon, since RSS
6847 # doesn't allow both
6848 my $img = esc_url
($logo || $favicon);
6850 "<url>$img</url>\n" .
6851 "<title>$title</title>\n" .
6852 "<link>$alt_url</link>\n" .
6856 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
6857 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
6859 print "<generator>gitweb v.$version/$git_version</generator>\n";
6860 } elsif ($format eq 'atom') {
6862 <feed xmlns="http://www.w3.org/2005/Atom">
6864 print "<title>$title</title>\n" .
6865 "<subtitle>$descr</subtitle>\n" .
6866 '<link rel="alternate" type="text/html" href="' .
6867 $alt_url . '" />' . "\n" .
6868 '<link rel="self" type="' . $content_type . '" href="' .
6869 $cgi->self_url() . '" />' . "\n" .
6870 "<id>" . href
(-full
=>1) . "</id>\n" .
6871 # use project owner for feed author
6872 "<author><name>$owner</name></author>\n";
6873 if (defined $favicon) {
6874 print "<icon>" . esc_url
($favicon) . "</icon>\n";
6876 if (defined $logo_url) {
6877 # not twice as wide as tall: 72 x 27 pixels
6878 print "<logo>" . esc_url
($logo) . "</logo>\n";
6880 if (! %latest_date) {
6881 # dummy date to keep the feed valid until commits trickle in:
6882 print "<updated>1970-01-01T00:00:00Z</updated>\n";
6884 print "<updated>$latest_date{'iso-8601'}</updated>\n";
6886 print "<generator version='$version/$git_version'>gitweb</generator>\n";
6890 for (my $i = 0; $i <= $#commitlist; $i++) {
6891 my %co = %{$commitlist[$i]};
6892 my $commit = $co{'id'};
6893 # we read 150, we always show 30 and the ones more recent than 48 hours
6894 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
6897 my %cd = parse_date
($co{'author_epoch'});
6899 # get list of changed files
6900 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6901 $co{'parent'} || "--root",
6902 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
6904 my @difftree = map { chomp; $_ } <$fd>;
6908 # print element (entry, item)
6909 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
6910 if ($format eq 'rss') {
6912 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
6913 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
6914 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
6915 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
6916 "<link>$co_url</link>\n" .
6917 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
6918 "<content:encoded>" .
6920 } elsif ($format eq 'atom') {
6922 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
6923 "<updated>$cd{'iso-8601'}</updated>\n" .
6925 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
6926 if ($co{'author_email'}) {
6927 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
6929 print "</author>\n" .
6930 # use committer for contributor
6932 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
6933 if ($co{'committer_email'}) {
6934 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
6936 print "</contributor>\n" .
6937 "<published>$cd{'iso-8601'}</published>\n" .
6938 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
6939 "<id>$co_url</id>\n" .
6940 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
6941 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
6943 my $comment = $co{'comment'};
6945 foreach my $line (@
$comment) {
6946 $line = esc_html
($line);
6949 print "</pre><ul>\n";
6950 foreach my $difftree_line (@difftree) {
6951 my %difftree = parse_difftree_raw_line
($difftree_line);
6952 next if !$difftree{'from_id'};
6954 my $file = $difftree{'file'} || $difftree{'to_file'};
6958 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
6959 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
6960 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
6961 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
6962 -title
=> "diff"}, 'D');
6964 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
6965 file_name
=>$file, hash_base
=>$commit),
6966 -title
=> "blame"}, 'B');
6968 # if this is not a feed of a file history
6969 if (!defined $file_name || $file_name ne $file) {
6970 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
6971 file_name
=>$file, hash
=>$commit),
6972 -title
=> "history"}, 'H');
6974 $file = esc_path
($file);
6978 if ($format eq 'rss') {
6979 print "</ul>]]>\n" .
6980 "</content:encoded>\n" .
6982 } elsif ($format eq 'atom') {
6983 print "</ul>\n</div>\n" .
6990 if ($format eq 'rss') {
6991 print "</channel>\n</rss>\n";
6992 } elsif ($format eq 'atom') {
7006 my @list = git_get_projects_list
();
7009 -type
=> 'text/xml',
7010 -charset
=> 'utf-8',
7011 -content_disposition
=> 'inline; filename="opml.xml"');
7014 <?xml version="1.0" encoding="utf-8"?>
7015 <opml version="1.0">
7017 <title>$site_name OPML Export</title>
7020 <outline text="git RSS feeds">
7023 foreach my $pr (@list) {
7025 my $head = git_get_head_hash
($proj{'path'});
7026 if (!defined $head) {
7029 $git_dir = "$projectroot/$proj{'path'}";
7030 my %co = parse_commit
($head);
7035 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
7036 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
7037 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
7038 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";