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 use Time
::HiRes
qw(gettimeofday tv_interval);
21 binmode STDOUT
, ':utf8';
23 our $t0 = [ gettimeofday
() ];
24 our $number_of_git_cmds = 0;
27 CGI
->compile() if $ENV{'MOD_PERL'};
30 our $version = "++GIT_VERSION++";
32 our ($my_url, $my_uri, $base_url, $path_info, $home_link);
36 our $my_url = $cgi->url();
37 our $my_uri = $cgi->url(-absolute
=> 1);
39 # Base URL for relative URLs in gitweb ($logo, $favicon, ...),
40 # needed and used only for URLs with nonempty PATH_INFO
41 our $base_url = $my_url;
43 # When the script is used as DirectoryIndex, the URL does not contain the name
44 # of the script file itself, and $cgi->url() fails to strip PATH_INFO, so we
45 # have to do it ourselves. We make $path_info global because it's also used
48 # Another issue with the script being the DirectoryIndex is that the resulting
49 # $my_url data is not the full script URL: this is good, because we want
50 # generated links to keep implying the script name if it wasn't explicitly
51 # indicated in the URL we're handling, but it means that $my_url cannot be used
53 # Therefore, if we needed to strip PATH_INFO, then we know that we have
54 # to build the base URL ourselves:
55 our $path_info = $ENV{"PATH_INFO"};
57 if ($my_url =~ s
,\Q
$path_info\E
$,, &&
58 $my_uri =~ s
,\Q
$path_info\E
$,, &&
59 defined $ENV{'SCRIPT_NAME'}) {
60 $base_url = $cgi->url(-base
=> 1) . $ENV{'SCRIPT_NAME'};
64 # target of the home link on top of all pages
65 our $home_link = $my_uri || "/";
68 # core git executable to use
69 # this can just be "git" if your webserver has a sensible PATH
70 our $GIT = "++GIT_BINDIR++/git";
72 # absolute fs-path which will be prepended to the project path
73 #our $projectroot = "/pub/scm";
74 our $projectroot = "++GITWEB_PROJECTROOT++";
76 # fs traversing limit for getting project list
77 # the number is relative to the projectroot
78 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
80 # string of the home link on top of all pages
81 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
83 # name of your site or organization to appear in page titles
84 # replace this with something more descriptive for clearer bookmarks
85 our $site_name = "++GITWEB_SITENAME++"
86 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
88 # html snippet to include in the <head> section of each page
89 our $site_html_head_string = "++GITWEB_SITE_HTML_HEAD_STRING++";
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 # group projects by category on the projects list
121 # (enabled if this variable evaluates to true)
122 our $projects_list_group_categories = 0;
124 # default category if none specified
125 # (leave the empty string for no category)
126 our $project_list_default_category = "";
128 # default order of projects list
129 # valid values are none, project, descr, owner, and age
130 our $default_projects_order = "project";
132 # show repository only if this file exists
133 # (only effective if this variable evaluates to true)
134 our $export_ok = "++GITWEB_EXPORT_OK++";
136 # show repository only if this subroutine returns true
137 # when given the path to the project, for example:
138 # sub { return -e "$_[0]/git-daemon-export-ok"; }
139 our $export_auth_hook = undef;
141 # only allow viewing of repositories also shown on the overview page
142 our $strict_export = "++GITWEB_STRICT_EXPORT++";
144 # list of git base URLs used for URL to where fetch project from,
145 # i.e. full URL is "$git_base_url/$project"
146 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
148 # default blob_plain mimetype and default charset for text/plain blob
149 our $default_blob_plain_mimetype = 'text/plain';
150 our $default_text_plain_charset = undef;
152 # file to use for guessing MIME types before trying /etc/mime.types
153 # (relative to the current git repository)
154 our $mimetypes_file = undef;
156 # assume this charset if line contains non-UTF-8 characters;
157 # it should be valid encoding (see Encoding::Supported(3pm) for list),
158 # for which encoding all byte sequences are valid, for example
159 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
160 # could be even 'utf-8' for the old behavior)
161 our $fallback_encoding = 'latin1';
163 # rename detection options for git-diff and git-diff-tree
164 # - default is '-M', with the cost proportional to
165 # (number of removed files) * (number of new files).
166 # - more costly is '-C' (which implies '-M'), with the cost proportional to
167 # (number of changed files + number of removed files) * (number of new files)
168 # - even more costly is '-C', '--find-copies-harder' with cost
169 # (number of files in the original tree) * (number of new files)
170 # - one might want to include '-B' option, e.g. '-B', '-M'
171 our @diff_opts = ('-M'); # taken from git_commit
173 # Disables features that would allow repository owners to inject script into
175 our $prevent_xss = 0;
177 # Path to the highlight executable to use (must be the one from
178 # http://www.andre-simon.de due to assumptions about parameters and output).
179 # Useful if highlight is not installed on your webserver's PATH.
180 # [Default: highlight]
181 our $highlight_bin = "++HIGHLIGHT_BIN++";
183 # information about snapshot formats that gitweb is capable of serving
184 our %known_snapshot_formats = (
186 # 'display' => display name,
187 # 'type' => mime type,
188 # 'suffix' => filename suffix,
189 # 'format' => --format for git-archive,
190 # 'compressor' => [compressor command and arguments]
191 # (array reference, optional)
192 # 'disabled' => boolean (optional)}
195 'display' => 'tar.gz',
196 'type' => 'application/x-gzip',
197 'suffix' => '.tar.gz',
199 'compressor' => ['gzip', '-n']},
202 'display' => 'tar.bz2',
203 'type' => 'application/x-bzip2',
204 'suffix' => '.tar.bz2',
206 'compressor' => ['bzip2']},
209 'display' => 'tar.xz',
210 'type' => 'application/x-xz',
211 'suffix' => '.tar.xz',
213 'compressor' => ['xz'],
218 'type' => 'application/x-zip',
223 # Aliases so we understand old gitweb.snapshot values in repository
225 our %known_snapshot_format_aliases = (
230 # backward compatibility: legacy gitweb config support
231 'x-gzip' => undef, 'gz' => undef,
232 'x-bzip2' => undef, 'bz2' => undef,
233 'x-zip' => undef, '' => undef,
236 # Pixel sizes for icons and avatars. If the default font sizes or lineheights
237 # are changed, it may be appropriate to change these values too via
244 # Used to set the maximum load that we will still respond to gitweb queries.
245 # If server load exceed this value then return "503 server busy" error.
246 # If gitweb cannot determined server load, it is taken to be 0.
247 # Leave it undefined (or set to 'undef') to turn off load checking.
250 # configuration for 'highlight' (http://www.andre-simon.de/)
252 our %highlight_basename = (
255 'SConstruct' => 'py', # SCons equivalent of Makefile
256 'Makefile' => 'make',
259 our %highlight_ext = (
260 # main extensions, defining name of syntax;
261 # see files in /usr/share/highlight/langDefs/ directory
263 qw(py c cpp rb java css php sh pl js tex bib xml awk bat ini spec tcl sql make),
264 # alternate extensions, see /etc/highlight/filetypes.conf
266 map { $_ => 'sh' } qw(bash zsh ksh),
267 map { $_ => 'cpp' } qw(cxx c++ cc),
268 map { $_ => 'php' } qw(php3 php4 php5 phps),
269 map { $_ => 'pl' } qw(perl pm), # perhaps also 'cgi'
270 map { $_ => 'make'} qw(mak mk),
271 map { $_ => 'xml' } qw(xhtml html htm),
274 # You define site-wide feature defaults here; override them with
275 # $GITWEB_CONFIG as necessary.
278 # 'sub' => feature-sub (subroutine),
279 # 'override' => allow-override (boolean),
280 # 'default' => [ default options...] (array reference)}
282 # if feature is overridable (it means that allow-override has true value),
283 # then feature-sub will be called with default options as parameters;
284 # return value of feature-sub indicates if to enable specified feature
286 # if there is no 'sub' key (no feature-sub), then feature cannot be
289 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
290 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
293 # Enable the 'blame' blob view, showing the last commit that modified
294 # each line in the file. This can be very CPU-intensive.
296 # To enable system wide have in $GITWEB_CONFIG
297 # $feature{'blame'}{'default'} = [1];
298 # To have project specific config enable override in $GITWEB_CONFIG
299 # $feature{'blame'}{'override'} = 1;
300 # and in project config gitweb.blame = 0|1;
302 'sub' => sub { feature_bool
('blame', @_) },
306 # Enable the 'snapshot' link, providing a compressed archive of any
307 # tree. This can potentially generate high traffic if you have large
310 # Value is a list of formats defined in %known_snapshot_formats that
312 # To disable system wide have in $GITWEB_CONFIG
313 # $feature{'snapshot'}{'default'} = [];
314 # To have project specific config enable override in $GITWEB_CONFIG
315 # $feature{'snapshot'}{'override'} = 1;
316 # and in project config, a comma-separated list of formats or "none"
317 # to disable. Example: gitweb.snapshot = tbz2,zip;
319 'sub' => \
&feature_snapshot
,
321 'default' => ['tgz']},
323 # Enable text search, which will list the commits which match author,
324 # committer or commit text to a given string. Enabled by default.
325 # Project specific override is not supported.
327 # Note that this controls all search features, which means that if
328 # it is disabled, then 'grep' and 'pickaxe' search would also be
334 # Enable grep search, which will list the files in currently selected
335 # tree containing the given string. Enabled by default. This can be
336 # potentially CPU-intensive, of course.
337 # Note that you need to have 'search' feature enabled too.
339 # To enable system wide have in $GITWEB_CONFIG
340 # $feature{'grep'}{'default'} = [1];
341 # To have project specific config enable override in $GITWEB_CONFIG
342 # $feature{'grep'}{'override'} = 1;
343 # and in project config gitweb.grep = 0|1;
345 'sub' => sub { feature_bool
('grep', @_) },
349 # Enable the pickaxe search, which will list the commits that modified
350 # a given string in a file. This can be practical and quite faster
351 # alternative to 'blame', but still potentially CPU-intensive.
352 # Note that you need to have 'search' feature enabled too.
354 # To enable system wide have in $GITWEB_CONFIG
355 # $feature{'pickaxe'}{'default'} = [1];
356 # To have project specific config enable override in $GITWEB_CONFIG
357 # $feature{'pickaxe'}{'override'} = 1;
358 # and in project config gitweb.pickaxe = 0|1;
360 'sub' => sub { feature_bool
('pickaxe', @_) },
364 # Enable showing size of blobs in a 'tree' view, in a separate
365 # column, similar to what 'ls -l' does. This cost a bit of IO.
367 # To disable system wide have in $GITWEB_CONFIG
368 # $feature{'show-sizes'}{'default'} = [0];
369 # To have project specific config enable override in $GITWEB_CONFIG
370 # $feature{'show-sizes'}{'override'} = 1;
371 # and in project config gitweb.showsizes = 0|1;
373 'sub' => sub { feature_bool
('showsizes', @_) },
377 # Make gitweb use an alternative format of the URLs which can be
378 # more readable and natural-looking: project name is embedded
379 # directly in the path and the query string contains other
380 # auxiliary information. All gitweb installations recognize
381 # URL in either format; this configures in which formats gitweb
384 # To enable system wide have in $GITWEB_CONFIG
385 # $feature{'pathinfo'}{'default'} = [1];
386 # Project specific override is not supported.
388 # Note that you will need to change the default location of CSS,
389 # favicon, logo and possibly other files to an absolute URL. Also,
390 # if gitweb.cgi serves as your indexfile, you will need to force
391 # $my_uri to contain the script name in your $GITWEB_CONFIG.
396 # Make gitweb consider projects in project root subdirectories
397 # to be forks of existing projects. Given project $projname.git,
398 # projects matching $projname/*.git will not be shown in the main
399 # projects list, instead a '+' mark will be added to $projname
400 # there and a 'forks' view will be enabled for the project, listing
401 # all the forks. If project list is taken from a file, forks have
402 # to be listed after the main project.
404 # To enable system wide have in $GITWEB_CONFIG
405 # $feature{'forks'}{'default'} = [1];
406 # Project specific override is not supported.
411 # Insert custom links to the action bar of all project pages.
412 # This enables you mainly to link to third-party scripts integrating
413 # into gitweb; e.g. git-browser for graphical history representation
414 # or custom web-based repository administration interface.
416 # The 'default' value consists of a list of triplets in the form
417 # (label, link, position) where position is the label after which
418 # to insert the link and link is a format string where %n expands
419 # to the project name, %f to the project path within the filesystem,
420 # %h to the current hash (h gitweb parameter) and %b to the current
421 # hash base (hb gitweb parameter); %% expands to %.
423 # To enable system wide have in $GITWEB_CONFIG e.g.
424 # $feature{'actions'}{'default'} = [('graphiclog',
425 # '/git-browser/by-commit.html?r=%n', 'summary')];
426 # Project specific override is not supported.
431 # Allow gitweb scan project content tags of project repository,
432 # and display the popular Web 2.0-ish "tag cloud" near the projects
433 # list. Note that this is something COMPLETELY different from the
436 # gitweb by itself can show existing tags, but it does not handle
437 # tagging itself; you need to do it externally, outside gitweb.
438 # The format is described in git_get_project_ctags() subroutine.
439 # You may want to install the HTML::TagCloud Perl module to get
440 # a pretty tag cloud instead of just a list of tags.
442 # To enable system wide have in $GITWEB_CONFIG
443 # $feature{'ctags'}{'default'} = [1];
444 # Project specific override is not supported.
446 # In the future whether ctags editing is enabled might depend
447 # on the value, but using 1 should always mean no editing of ctags.
452 # The maximum number of patches in a patchset generated in patch
453 # view. Set this to 0 or undef to disable patch view, or to a
454 # negative number to remove any limit.
456 # To disable system wide have in $GITWEB_CONFIG
457 # $feature{'patches'}{'default'} = [0];
458 # To have project specific config enable override in $GITWEB_CONFIG
459 # $feature{'patches'}{'override'} = 1;
460 # and in project config gitweb.patches = 0|n;
461 # where n is the maximum number of patches allowed in a patchset.
463 'sub' => \
&feature_patches
,
467 # Avatar support. When this feature is enabled, views such as
468 # shortlog or commit will display an avatar associated with
469 # the email of the committer(s) and/or author(s).
471 # Currently available providers are gravatar and picon.
472 # If an unknown provider is specified, the feature is disabled.
474 # Gravatar depends on Digest::MD5.
475 # Picon currently relies on the indiana.edu database.
477 # To enable system wide have in $GITWEB_CONFIG
478 # $feature{'avatar'}{'default'} = ['<provider>'];
479 # where <provider> is either gravatar or picon.
480 # To have project specific config enable override in $GITWEB_CONFIG
481 # $feature{'avatar'}{'override'} = 1;
482 # and in project config gitweb.avatar = <provider>;
484 'sub' => \
&feature_avatar
,
488 # Enable displaying how much time and how many git commands
489 # it took to generate and display page. Disabled by default.
490 # Project specific override is not supported.
495 # Enable turning some links into links to actions which require
496 # JavaScript to run (like 'blame_incremental'). Not enabled by
497 # default. Project specific override is currently not supported.
498 'javascript-actions' => {
502 # Enable and configure ability to change common timezone for dates
503 # in gitweb output via JavaScript. Enabled by default.
504 # Project specific override is not supported.
505 'javascript-timezone' => {
508 'local', # default timezone: 'utc', 'local', or '(-|+)HHMM' format,
509 # or undef to turn off this feature
510 'gitweb_tz', # name of cookie where to store selected timezone
511 'datetime', # CSS class used to mark up dates for manipulation
514 # Syntax highlighting support. This is based on Daniel Svensson's
515 # and Sham Chukoury's work in gitweb-xmms2.git.
516 # It requires the 'highlight' program present in $PATH,
517 # and therefore is disabled by default.
519 # To enable system wide have in $GITWEB_CONFIG
520 # $feature{'highlight'}{'default'} = [1];
523 'sub' => sub { feature_bool
('highlight', @_) },
527 # Enable displaying of remote heads in the heads list
529 # To enable system wide have in $GITWEB_CONFIG
530 # $feature{'remote_heads'}{'default'} = [1];
531 # To have project specific config enable override in $GITWEB_CONFIG
532 # $feature{'remote_heads'}{'override'} = 1;
533 # and in project config gitweb.remote_heads = 0|1;
535 'sub' => sub { feature_bool
('remote_heads', @_) },
540 sub gitweb_get_feature
{
542 return unless exists $feature{$name};
543 my ($sub, $override, @defaults) = (
544 $feature{$name}{'sub'},
545 $feature{$name}{'override'},
546 @
{$feature{$name}{'default'}});
547 # project specific override is possible only if we have project
548 our $git_dir; # global variable, declared later
549 if (!$override || !defined $git_dir) {
553 warn "feature $name is not overridable";
556 return $sub->(@defaults);
559 # A wrapper to check if a given feature is enabled.
560 # With this, you can say
562 # my $bool_feat = gitweb_check_feature('bool_feat');
563 # gitweb_check_feature('bool_feat') or somecode;
567 # my ($bool_feat) = gitweb_get_feature('bool_feat');
568 # (gitweb_get_feature('bool_feat'))[0] or somecode;
570 sub gitweb_check_feature
{
571 return (gitweb_get_feature
(@_))[0];
577 my ($val) = git_get_project_config
($key, '--bool');
581 } elsif ($val eq 'true') {
583 } elsif ($val eq 'false') {
588 sub feature_snapshot
{
591 my ($val) = git_get_project_config
('snapshot');
594 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
600 sub feature_patches
{
601 my @val = (git_get_project_config
('patches', '--int'));
611 my @val = (git_get_project_config
('avatar'));
613 return @val ?
@val : @_;
616 # checking HEAD file with -e is fragile if the repository was
617 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
619 sub check_head_link
{
621 my $headfile = "$dir/HEAD";
622 return ((-e
$headfile) ||
623 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
626 sub check_export_ok
{
628 return (check_head_link
($dir) &&
629 (!$export_ok || -e
"$dir/$export_ok") &&
630 (!$export_auth_hook || $export_auth_hook->($dir)));
633 # process alternate names for backward compatibility
634 # filter out unsupported (unknown) snapshot formats
635 sub filter_snapshot_fmts
{
639 exists $known_snapshot_format_aliases{$_} ?
640 $known_snapshot_format_aliases{$_} : $_} @fmts;
642 exists $known_snapshot_formats{$_} &&
643 !$known_snapshot_formats{$_}{'disabled'}} @fmts;
646 # If it is set to code reference, it is code that it is to be run once per
647 # request, allowing updating configurations that change with each request,
648 # while running other code in config file only once.
650 # Otherwise, if it is false then gitweb would process config file only once;
651 # if it is true then gitweb config would be run for each request.
652 our $per_request_config = 1;
654 # read and parse gitweb config file given by its parameter.
655 # returns true on success, false on recoverable error, allowing
656 # to chain this subroutine, using first file that exists.
657 # dies on errors during parsing config file, as it is unrecoverable.
658 sub read_config_file
{
659 my $filename = shift;
660 return unless defined $filename;
661 # die if there are errors parsing config file
670 our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM, $GITWEB_CONFIG_COMMON);
671 sub evaluate_gitweb_config
{
672 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
673 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
674 our $GITWEB_CONFIG_COMMON = $ENV{'GITWEB_CONFIG_COMMON'} || "++GITWEB_CONFIG_COMMON++";
676 # Protect agains duplications of file names, to not read config twice.
677 # Only one of $GITWEB_CONFIG and $GITWEB_CONFIG_SYSTEM is used, so
678 # there possibility of duplication of filename there doesn't matter.
679 $GITWEB_CONFIG = "" if ($GITWEB_CONFIG eq $GITWEB_CONFIG_COMMON);
680 $GITWEB_CONFIG_SYSTEM = "" if ($GITWEB_CONFIG_SYSTEM eq $GITWEB_CONFIG_COMMON);
682 # Common system-wide settings for convenience.
683 # Those settings can be ovverriden by GITWEB_CONFIG or GITWEB_CONFIG_SYSTEM.
684 read_config_file
($GITWEB_CONFIG_COMMON);
686 # Use first config file that exists. This means use the per-instance
687 # GITWEB_CONFIG if exists, otherwise use GITWEB_SYSTEM_CONFIG.
688 read_config_file
($GITWEB_CONFIG) and return;
689 read_config_file
($GITWEB_CONFIG_SYSTEM);
692 # Get loadavg of system, to compare against $maxload.
693 # Currently it requires '/proc/loadavg' present to get loadavg;
694 # if it is not present it returns 0, which means no load checking.
696 if( -e
'/proc/loadavg' ){
697 open my $fd, '<', '/proc/loadavg'
699 my @load = split(/\s+/, scalar <$fd>);
702 # The first three columns measure CPU and IO utilization of the last one,
703 # five, and 10 minute periods. The fourth column shows the number of
704 # currently running processes and the total number of processes in the m/n
705 # format. The last column displays the last process ID used.
706 return $load[0] || 0;
708 # additional checks for load average should go here for things that don't export
714 # version of the core git binary
716 sub evaluate_git_version
{
717 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
718 $number_of_git_cmds++;
722 if (defined $maxload && get_loadavg
() > $maxload) {
723 die_error
(503, "The load average on the server is too high");
727 # ======================================================================
728 # input validation and dispatch
730 # input parameters can be collected from a variety of sources (presently, CGI
731 # and PATH_INFO), so we define an %input_params hash that collects them all
732 # together during validation: this allows subsequent uses (e.g. href()) to be
733 # agnostic of the parameter origin
735 our %input_params = ();
737 # input parameters are stored with the long parameter name as key. This will
738 # also be used in the href subroutine to convert parameters to their CGI
739 # equivalent, and since the href() usage is the most frequent one, we store
740 # the name -> CGI key mapping here, instead of the reverse.
742 # XXX: Warning: If you touch this, check the search form for updating,
745 our @cgi_param_mapping = (
753 hash_parent_base
=> "hpb",
758 snapshot_format
=> "sf",
759 extra_options
=> "opt",
760 search_use_regexp
=> "sr",
763 # this must be last entry (for manipulation from JavaScript)
766 our %cgi_param_mapping = @cgi_param_mapping;
768 # we will also need to know the possible actions, for validation
770 "blame" => \
&git_blame
,
771 "blame_incremental" => \
&git_blame_incremental
,
772 "blame_data" => \
&git_blame_data
,
773 "blobdiff" => \
&git_blobdiff
,
774 "blobdiff_plain" => \
&git_blobdiff_plain
,
775 "blob" => \
&git_blob
,
776 "blob_plain" => \
&git_blob_plain
,
777 "commitdiff" => \
&git_commitdiff
,
778 "commitdiff_plain" => \
&git_commitdiff_plain
,
779 "commit" => \
&git_commit
,
780 "forks" => \
&git_forks
,
781 "heads" => \
&git_heads
,
782 "history" => \
&git_history
,
784 "patch" => \
&git_patch
,
785 "patches" => \
&git_patches
,
786 "remotes" => \
&git_remotes
,
788 "atom" => \
&git_atom
,
789 "search" => \
&git_search
,
790 "search_help" => \
&git_search_help
,
791 "shortlog" => \
&git_shortlog
,
792 "summary" => \
&git_summary
,
794 "tags" => \
&git_tags
,
795 "tree" => \
&git_tree
,
796 "snapshot" => \
&git_snapshot
,
797 "object" => \
&git_object
,
798 # those below don't need $project
799 "opml" => \
&git_opml
,
800 "project_list" => \
&git_project_list
,
801 "project_index" => \
&git_project_index
,
804 # finally, we have the hash of allowed extra_options for the commands that
806 our %allowed_options = (
807 "--no-merges" => [ qw(rss atom log shortlog history) ],
810 # fill %input_params with the CGI parameters. All values except for 'opt'
811 # should be single values, but opt can be an array. We should probably
812 # build an array of parameters that can be multi-valued, but since for the time
813 # being it's only this one, we just single it out
814 sub evaluate_query_params
{
817 while (my ($name, $symbol) = each %cgi_param_mapping) {
818 if ($symbol eq 'opt') {
819 $input_params{$name} = [ $cgi->param($symbol) ];
821 $input_params{$name} = $cgi->param($symbol);
826 # now read PATH_INFO and update the parameter list for missing parameters
827 sub evaluate_path_info
{
828 return if defined $input_params{'project'};
829 return if !$path_info;
830 $path_info =~ s
,^/+,,;
831 return if !$path_info;
833 # find which part of PATH_INFO is project
834 my $project = $path_info;
836 while ($project && !check_head_link
("$projectroot/$project")) {
837 $project =~ s
,/*[^/]*$,,;
839 return unless $project;
840 $input_params{'project'} = $project;
842 # do not change any parameters if an action is given using the query string
843 return if $input_params{'action'};
844 $path_info =~ s
,^\Q
$project\E
/*,,;
846 # next, check if we have an action
847 my $action = $path_info;
849 if (exists $actions{$action}) {
850 $path_info =~ s
,^$action/*,,;
851 $input_params{'action'} = $action;
854 # list of actions that want hash_base instead of hash, but can have no
855 # pathname (f) parameter
861 # we want to catch, among others
862 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
863 my ($parentrefname, $parentpathname, $refname, $pathname) =
864 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?([^:]+?)?(?::(.+))?$/);
866 # first, analyze the 'current' part
867 if (defined $pathname) {
868 # we got "branch:filename" or "branch:dir/"
869 # we could use git_get_type(branch:pathname), but:
870 # - it needs $git_dir
871 # - it does a git() call
872 # - the convention of terminating directories with a slash
873 # makes it superfluous
874 # - embedding the action in the PATH_INFO would make it even
876 $pathname =~ s
,^/+,,;
877 if (!$pathname || substr($pathname, -1) eq "/") {
878 $input_params{'action'} ||= "tree";
881 # the default action depends on whether we had parent info
883 if ($parentrefname) {
884 $input_params{'action'} ||= "blobdiff_plain";
886 $input_params{'action'} ||= "blob_plain";
889 $input_params{'hash_base'} ||= $refname;
890 $input_params{'file_name'} ||= $pathname;
891 } elsif (defined $refname) {
892 # we got "branch". In this case we have to choose if we have to
893 # set hash or hash_base.
895 # Most of the actions without a pathname only want hash to be
896 # set, except for the ones specified in @wants_base that want
897 # hash_base instead. It should also be noted that hand-crafted
898 # links having 'history' as an action and no pathname or hash
899 # set will fail, but that happens regardless of PATH_INFO.
900 if (defined $parentrefname) {
901 # if there is parent let the default be 'shortlog' action
902 # (for http://git.example.com/repo.git/A..B links); if there
903 # is no parent, dispatch will detect type of object and set
904 # action appropriately if required (if action is not set)
905 $input_params{'action'} ||= "shortlog";
907 if ($input_params{'action'} &&
908 grep { $_ eq $input_params{'action'} } @wants_base) {
909 $input_params{'hash_base'} ||= $refname;
911 $input_params{'hash'} ||= $refname;
915 # next, handle the 'parent' part, if present
916 if (defined $parentrefname) {
917 # a missing pathspec defaults to the 'current' filename, allowing e.g.
918 # someproject/blobdiff/oldrev..newrev:/filename
919 if ($parentpathname) {
920 $parentpathname =~ s
,^/+,,;
921 $parentpathname =~ s
,/$,,;
922 $input_params{'file_parent'} ||= $parentpathname;
924 $input_params{'file_parent'} ||= $input_params{'file_name'};
926 # we assume that hash_parent_base is wanted if a path was specified,
927 # or if the action wants hash_base instead of hash
928 if (defined $input_params{'file_parent'} ||
929 grep { $_ eq $input_params{'action'} } @wants_base) {
930 $input_params{'hash_parent_base'} ||= $parentrefname;
932 $input_params{'hash_parent'} ||= $parentrefname;
936 # for the snapshot action, we allow URLs in the form
937 # $project/snapshot/$hash.ext
938 # where .ext determines the snapshot and gets removed from the
939 # passed $refname to provide the $hash.
941 # To be able to tell that $refname includes the format extension, we
942 # require the following two conditions to be satisfied:
943 # - the hash input parameter MUST have been set from the $refname part
944 # of the URL (i.e. they must be equal)
945 # - the snapshot format MUST NOT have been defined already (e.g. from
947 # It's also useless to try any matching unless $refname has a dot,
948 # so we check for that too
949 if (defined $input_params{'action'} &&
950 $input_params{'action'} eq 'snapshot' &&
951 defined $refname && index($refname, '.') != -1 &&
952 $refname eq $input_params{'hash'} &&
953 !defined $input_params{'snapshot_format'}) {
954 # We loop over the known snapshot formats, checking for
955 # extensions. Allowed extensions are both the defined suffix
956 # (which includes the initial dot already) and the snapshot
957 # format key itself, with a prepended dot
958 while (my ($fmt, $opt) = each %known_snapshot_formats) {
960 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
964 # a valid suffix was found, so set the snapshot format
965 # and reset the hash parameter
966 $input_params{'snapshot_format'} = $fmt;
967 $input_params{'hash'} = $hash;
968 # we also set the format suffix to the one requested
969 # in the URL: this way a request for e.g. .tgz returns
970 # a .tgz instead of a .tar.gz
971 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
977 our ($action, $project, $file_name, $file_parent, $hash, $hash_parent, $hash_base,
978 $hash_parent_base, @extra_options, $page, $searchtype, $search_use_regexp,
979 $searchtext, $search_regexp);
980 sub evaluate_and_validate_params
{
981 our $action = $input_params{'action'};
982 if (defined $action) {
983 if (!validate_action
($action)) {
984 die_error
(400, "Invalid action parameter");
988 # parameters which are pathnames
989 our $project = $input_params{'project'};
990 if (defined $project) {
991 if (!validate_project
($project)) {
993 die_error
(404, "No such project");
997 our $file_name = $input_params{'file_name'};
998 if (defined $file_name) {
999 if (!validate_pathname
($file_name)) {
1000 die_error
(400, "Invalid file parameter");
1004 our $file_parent = $input_params{'file_parent'};
1005 if (defined $file_parent) {
1006 if (!validate_pathname
($file_parent)) {
1007 die_error
(400, "Invalid file parent parameter");
1011 # parameters which are refnames
1012 our $hash = $input_params{'hash'};
1013 if (defined $hash) {
1014 if (!validate_refname
($hash)) {
1015 die_error
(400, "Invalid hash parameter");
1019 our $hash_parent = $input_params{'hash_parent'};
1020 if (defined $hash_parent) {
1021 if (!validate_refname
($hash_parent)) {
1022 die_error
(400, "Invalid hash parent parameter");
1026 our $hash_base = $input_params{'hash_base'};
1027 if (defined $hash_base) {
1028 if (!validate_refname
($hash_base)) {
1029 die_error
(400, "Invalid hash base parameter");
1033 our @extra_options = @
{$input_params{'extra_options'}};
1034 # @extra_options is always defined, since it can only be (currently) set from
1035 # CGI, and $cgi->param() returns the empty array in array context if the param
1037 foreach my $opt (@extra_options) {
1038 if (not exists $allowed_options{$opt}) {
1039 die_error
(400, "Invalid option parameter");
1041 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
1042 die_error
(400, "Invalid option parameter for this action");
1046 our $hash_parent_base = $input_params{'hash_parent_base'};
1047 if (defined $hash_parent_base) {
1048 if (!validate_refname
($hash_parent_base)) {
1049 die_error
(400, "Invalid hash parent base parameter");
1054 our $page = $input_params{'page'};
1055 if (defined $page) {
1056 if ($page =~ m/[^0-9]/) {
1057 die_error
(400, "Invalid page parameter");
1061 our $searchtype = $input_params{'searchtype'};
1062 if (defined $searchtype) {
1063 if ($searchtype =~ m/[^a-z]/) {
1064 die_error
(400, "Invalid searchtype parameter");
1068 our $search_use_regexp = $input_params{'search_use_regexp'};
1070 our $searchtext = $input_params{'searchtext'};
1072 if (defined $searchtext) {
1073 if (length($searchtext) < 2) {
1074 die_error
(403, "At least two characters are required for search parameter");
1076 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
1080 # path to the current git repository
1082 sub evaluate_git_dir
{
1083 our $git_dir = "$projectroot/$project" if $project;
1086 our (@snapshot_fmts, $git_avatar);
1087 sub configure_gitweb_features
{
1088 # list of supported snapshot formats
1089 our @snapshot_fmts = gitweb_get_feature
('snapshot');
1090 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1092 # check that the avatar feature is set to a known provider name,
1093 # and for each provider check if the dependencies are satisfied.
1094 # if the provider name is invalid or the dependencies are not met,
1095 # reset $git_avatar to the empty string.
1096 our ($git_avatar) = gitweb_get_feature
('avatar');
1097 if ($git_avatar eq 'gravatar') {
1098 $git_avatar = '' unless (eval { require Digest
::MD5
; 1; });
1099 } elsif ($git_avatar eq 'picon') {
1106 # custom error handler: 'die <message>' is Internal Server Error
1107 sub handle_errors_html
{
1108 my $msg = shift; # it is already HTML escaped
1110 # to avoid infinite loop where error occurs in die_error,
1111 # change handler to default handler, disabling handle_errors_html
1112 set_message
("Error occured when inside die_error:\n$msg");
1114 # you cannot jump out of die_error when called as error handler;
1115 # the subroutine set via CGI::Carp::set_message is called _after_
1116 # HTTP headers are already written, so it cannot write them itself
1117 die_error
(undef, undef, $msg, -error_handler
=> 1, -no_http_header
=> 1);
1119 set_message
(\
&handle_errors_html
);
1123 if (!defined $action) {
1124 if (defined $hash) {
1125 $action = git_get_type
($hash);
1126 } elsif (defined $hash_base && defined $file_name) {
1127 $action = git_get_type
("$hash_base:$file_name");
1128 } elsif (defined $project) {
1129 $action = 'summary';
1131 $action = 'project_list';
1134 if (!defined($actions{$action})) {
1135 die_error
(400, "Unknown action");
1137 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1139 die_error
(400, "Project needed");
1141 $actions{$action}->();
1145 our $t0 = [ gettimeofday
() ]
1147 our $number_of_git_cmds = 0;
1150 our $first_request = 1;
1155 if ($first_request) {
1156 evaluate_gitweb_config
();
1157 evaluate_git_version
();
1159 if ($per_request_config) {
1160 if (ref($per_request_config) eq 'CODE') {
1161 $per_request_config->();
1162 } elsif (!$first_request) {
1163 evaluate_gitweb_config
();
1168 # $projectroot and $projects_list might be set in gitweb config file
1169 $projects_list ||= $projectroot;
1171 evaluate_query_params
();
1172 evaluate_path_info
();
1173 evaluate_and_validate_params
();
1176 configure_gitweb_features
();
1181 our $is_last_request = sub { 1 };
1182 our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1185 sub configure_as_fcgi
{
1187 our $CGI = 'CGI::Fast';
1189 my $request_number = 0;
1190 # let each child service 100 requests
1191 our $is_last_request = sub { ++$request_number > 100 };
1194 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__
;
1196 if $script_name =~ /\.fcgi$/;
1198 return unless (@ARGV);
1200 require Getopt
::Long
;
1201 Getopt
::Long
::GetOptions
(
1202 'fastcgi|fcgi|f' => \
&configure_as_fcgi
,
1203 'nproc|n=i' => sub {
1204 my ($arg, $val) = @_;
1205 return unless eval { require FCGI
::ProcManager
; 1; };
1206 my $proc_manager = FCGI
::ProcManager
->new({
1207 n_processes
=> $val,
1209 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1210 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1211 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1220 $pre_listen_hook->()
1221 if $pre_listen_hook;
1224 while ($cgi = $CGI->new()) {
1225 $pre_dispatch_hook->()
1226 if $pre_dispatch_hook;
1230 $post_dispatch_hook->()
1231 if $post_dispatch_hook;
1234 last REQUEST
if ($is_last_request->());
1243 if (defined caller) {
1244 # wrapped in a subroutine processing requests,
1245 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1248 # pure CGI script, serving single request
1252 ## ======================================================================
1255 # possible values of extra options
1256 # -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1257 # -replay => 1 - start from a current view (replay with modifications)
1258 # -path_info => 0|1 - don't use/use path_info URL (if possible)
1259 # -anchor => ANCHOR - add #ANCHOR to end of URL, implies -replay if used alone
1262 # default is to use -absolute url() i.e. $my_uri
1263 my $href = $params{-full
} ?
$my_url : $my_uri;
1265 # implicit -replay, must be first of implicit params
1266 $params{-replay
} = 1 if (keys %params == 1 && $params{-anchor
});
1268 $params{'project'} = $project unless exists $params{'project'};
1270 if ($params{-replay
}) {
1271 while (my ($name, $symbol) = each %cgi_param_mapping) {
1272 if (!exists $params{$name}) {
1273 $params{$name} = $input_params{$name};
1278 my $use_pathinfo = gitweb_check_feature
('pathinfo');
1279 if (defined $params{'project'} &&
1280 (exists $params{-path_info
} ?
$params{-path_info
} : $use_pathinfo)) {
1281 # try to put as many parameters as possible in PATH_INFO:
1284 # - hash_parent or hash_parent_base:/file_parent
1285 # - hash or hash_base:/filename
1286 # - the snapshot_format as an appropriate suffix
1288 # When the script is the root DirectoryIndex for the domain,
1289 # $href here would be something like http://gitweb.example.com/
1290 # Thus, we strip any trailing / from $href, to spare us double
1291 # slashes in the final URL
1294 # Then add the project name, if present
1295 $href .= "/".esc_path_info
($params{'project'});
1296 delete $params{'project'};
1298 # since we destructively absorb parameters, we keep this
1299 # boolean that remembers if we're handling a snapshot
1300 my $is_snapshot = $params{'action'} eq 'snapshot';
1302 # Summary just uses the project path URL, any other action is
1304 if (defined $params{'action'}) {
1305 $href .= "/".esc_path_info
($params{'action'})
1306 unless $params{'action'} eq 'summary';
1307 delete $params{'action'};
1310 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1311 # stripping nonexistent or useless pieces
1312 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1313 || $params{'hash_parent'} || $params{'hash'});
1314 if (defined $params{'hash_base'}) {
1315 if (defined $params{'hash_parent_base'}) {
1316 $href .= esc_path_info
($params{'hash_parent_base'});
1317 # skip the file_parent if it's the same as the file_name
1318 if (defined $params{'file_parent'}) {
1319 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1320 delete $params{'file_parent'};
1321 } elsif ($params{'file_parent'} !~ /\.\./) {
1322 $href .= ":/".esc_path_info
($params{'file_parent'});
1323 delete $params{'file_parent'};
1327 delete $params{'hash_parent'};
1328 delete $params{'hash_parent_base'};
1329 } elsif (defined $params{'hash_parent'}) {
1330 $href .= esc_path_info
($params{'hash_parent'}). "..";
1331 delete $params{'hash_parent'};
1334 $href .= esc_path_info
($params{'hash_base'});
1335 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
1336 $href .= ":/".esc_path_info
($params{'file_name'});
1337 delete $params{'file_name'};
1339 delete $params{'hash'};
1340 delete $params{'hash_base'};
1341 } elsif (defined $params{'hash'}) {
1342 $href .= esc_path_info
($params{'hash'});
1343 delete $params{'hash'};
1346 # If the action was a snapshot, we can absorb the
1347 # snapshot_format parameter too
1349 my $fmt = $params{'snapshot_format'};
1350 # snapshot_format should always be defined when href()
1351 # is called, but just in case some code forgets, we
1352 # fall back to the default
1353 $fmt ||= $snapshot_fmts[0];
1354 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1355 delete $params{'snapshot_format'};
1359 # now encode the parameters explicitly
1361 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1362 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
1363 if (defined $params{$name}) {
1364 if (ref($params{$name}) eq "ARRAY") {
1365 foreach my $par (@
{$params{$name}}) {
1366 push @result, $symbol . "=" . esc_param
($par);
1369 push @result, $symbol . "=" . esc_param
($params{$name});
1373 $href .= "?" . join(';', @result) if scalar @result;
1375 # final transformation: trailing spaces must be escaped (URI-encoded)
1376 $href =~ s/(\s+)$/CGI::escape($1)/e;
1378 if ($params{-anchor
}) {
1379 $href .= "#".esc_param
($params{-anchor
});
1386 ## ======================================================================
1387 ## validation, quoting/unquoting and escaping
1389 sub validate_action
{
1390 my $input = shift || return undef;
1391 return undef unless exists $actions{$input};
1395 sub validate_project
{
1396 my $input = shift || return undef;
1397 if (!validate_pathname
($input) ||
1398 !(-d
"$projectroot/$input") ||
1399 !check_export_ok
("$projectroot/$input") ||
1400 ($strict_export && !project_in_list
($input))) {
1407 sub validate_pathname
{
1408 my $input = shift || return undef;
1410 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1411 # at the beginning, at the end, and between slashes.
1412 # also this catches doubled slashes
1413 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1416 # no null characters
1417 if ($input =~ m!\0!) {
1423 sub validate_refname
{
1424 my $input = shift || return undef;
1426 # textual hashes are O.K.
1427 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1430 # it must be correct pathname
1431 $input = validate_pathname
($input)
1433 # restrictions on ref name according to git-check-ref-format
1434 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1440 # decode sequences of octets in utf8 into Perl's internal form,
1441 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1442 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1445 return undef unless defined $str;
1447 if (utf8
::is_utf8
($str) || utf8
::decode
($str)) {
1450 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
1454 # quote unsafe chars, but keep the slash, even when it's not
1455 # correct, but quoted slashes look too horrible in bookmarks
1458 return undef unless defined $str;
1459 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI
::escape
($1)/eg
;
1464 # the quoting rules for path_info fragment are slightly different
1467 return undef unless defined $str;
1469 # path_info doesn't treat '+' as space (specially), but '?' must be escaped
1470 $str =~ s/([^A-Za-z0-9\-_.~();\/;:@&= +]+)/CGI
::escape
($1)/eg
;
1475 # quote unsafe chars in whole URL, so some characters cannot be quoted
1478 return undef unless defined $str;
1479 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI
::escape
($1)/eg
;
1484 # quote unsafe characters in HTML attributes
1487 # for XHTML conformance escaping '"' to '"' is not enough
1488 return esc_html
(@_);
1491 # replace invalid utf8 character with SUBSTITUTION sequence
1496 return undef unless defined $str;
1498 $str = to_utf8
($str);
1499 $str = $cgi->escapeHTML($str);
1500 if ($opts{'-nbsp'}) {
1501 $str =~ s/ / /g;
1503 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1507 # quote control characters and escape filename to HTML
1512 return undef unless defined $str;
1514 $str = to_utf8
($str);
1515 $str = $cgi->escapeHTML($str);
1516 if ($opts{'-nbsp'}) {
1517 $str =~ s/ / /g;
1519 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1523 # Sanitize for use in XHTML + application/xml+xhtm (valid XML 1.0)
1527 return undef unless defined $str;
1529 $str = to_utf8
($str);
1530 $str =~ s
|([[:cntrl
:]])|($1 =~ /[\t\n\r]/ ?
$1 : quot_cec
($1))|eg
;
1534 # Make control characters "printable", using character escape codes (CEC)
1538 my %es = ( # character escape codes, aka escape sequences
1539 "\t" => '\t', # tab (HT)
1540 "\n" => '\n', # line feed (LF)
1541 "\r" => '\r', # carrige return (CR)
1542 "\f" => '\f', # form feed (FF)
1543 "\b" => '\b', # backspace (BS)
1544 "\a" => '\a', # alarm (bell) (BEL)
1545 "\e" => '\e', # escape (ESC)
1546 "\013" => '\v', # vertical tab (VT)
1547 "\000" => '\0', # nul character (NUL)
1549 my $chr = ( (exists $es{$cntrl})
1551 : sprintf('\%2x', ord($cntrl)) );
1552 if ($opts{-nohtml
}) {
1555 return "<span class=\"cntrl\">$chr</span>";
1559 # Alternatively use unicode control pictures codepoints,
1560 # Unicode "printable representation" (PR)
1565 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1566 if ($opts{-nohtml
}) {
1569 return "<span class=\"cntrl\">$chr</span>";
1573 # git may return quoted and escaped filenames
1579 my %es = ( # character escape codes, aka escape sequences
1580 't' => "\t", # tab (HT, TAB)
1581 'n' => "\n", # newline (NL)
1582 'r' => "\r", # return (CR)
1583 'f' => "\f", # form feed (FF)
1584 'b' => "\b", # backspace (BS)
1585 'a' => "\a", # alarm (bell) (BEL)
1586 'e' => "\e", # escape (ESC)
1587 'v' => "\013", # vertical tab (VT)
1590 if ($seq =~ m/^[0-7]{1,3}$/) {
1591 # octal char sequence
1592 return chr(oct($seq));
1593 } elsif (exists $es{$seq}) {
1594 # C escape sequence, aka character escape code
1597 # quoted ordinary character
1601 if ($str =~ m/^"(.*)"$/) {
1604 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1609 # escape tabs (convert tabs to spaces)
1613 while ((my $pos = index($line, "\t")) != -1) {
1614 if (my $count = (8 - ($pos % 8))) {
1615 my $spaces = ' ' x
$count;
1616 $line =~ s/\t/$spaces/;
1623 sub project_in_list
{
1624 my $project = shift;
1625 my @list = git_get_projects_list
();
1626 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1629 ## ----------------------------------------------------------------------
1630 ## HTML aware string manipulation
1632 # Try to chop given string on a word boundary between position
1633 # $len and $len+$add_len. If there is no word boundary there,
1634 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1635 # (marking chopped part) would be longer than given string.
1639 my $add_len = shift || 10;
1640 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1642 # Make sure perl knows it is utf8 encoded so we don't
1643 # cut in the middle of a utf8 multibyte char.
1644 $str = to_utf8
($str);
1646 # allow only $len chars, but don't cut a word if it would fit in $add_len
1647 # if it doesn't fit, cut it if it's still longer than the dots we would add
1648 # remove chopped character entities entirely
1650 # when chopping in the middle, distribute $len into left and right part
1651 # return early if chopping wouldn't make string shorter
1652 if ($where eq 'center') {
1653 return $str if ($len + 5 >= length($str)); # filler is length 5
1656 return $str if ($len + 4 >= length($str)); # filler is length 4
1659 # regexps: ending and beginning with word part up to $add_len
1660 my $endre = qr/.{$len}\w{0,$add_len}/;
1661 my $begre = qr/\w{0,$add_len}.{$len}/;
1663 if ($where eq 'left') {
1664 $str =~ m/^(.*?)($begre)$/;
1665 my ($lead, $body) = ($1, $2);
1666 if (length($lead) > 4) {
1669 return "$lead$body";
1671 } elsif ($where eq 'center') {
1672 $str =~ m/^($endre)(.*)$/;
1673 my ($left, $str) = ($1, $2);
1674 $str =~ m/^(.*?)($begre)$/;
1675 my ($mid, $right) = ($1, $2);
1676 if (length($mid) > 5) {
1679 return "$left$mid$right";
1682 $str =~ m/^($endre)(.*)$/;
1685 if (length($tail) > 4) {
1688 return "$body$tail";
1692 # takes the same arguments as chop_str, but also wraps a <span> around the
1693 # result with a title attribute if it does get chopped. Additionally, the
1694 # string is HTML-escaped.
1695 sub chop_and_escape_str
{
1698 my $chopped = chop_str
(@_);
1699 $str = to_utf8
($str);
1700 if ($chopped eq $str) {
1701 return esc_html
($chopped);
1703 $str =~ s/[[:cntrl:]]/?/g;
1704 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1708 ## ----------------------------------------------------------------------
1709 ## functions returning short strings
1711 # CSS class for given age value (in seconds)
1715 if (!defined $age) {
1717 } elsif ($age < 60*60*2) {
1719 } elsif ($age < 60*60*24*2) {
1726 # convert age in seconds to "nn units ago" string
1731 if ($age > 60*60*24*365*2) {
1732 $age_str = (int $age/60/60/24/365);
1733 $age_str .= " years ago";
1734 } elsif ($age > 60*60*24*(365/12)*2) {
1735 $age_str = int $age/60/60/24/(365/12);
1736 $age_str .= " months ago";
1737 } elsif ($age > 60*60*24*7*2) {
1738 $age_str = int $age/60/60/24/7;
1739 $age_str .= " weeks ago";
1740 } elsif ($age > 60*60*24*2) {
1741 $age_str = int $age/60/60/24;
1742 $age_str .= " days ago";
1743 } elsif ($age > 60*60*2) {
1744 $age_str = int $age/60/60;
1745 $age_str .= " hours ago";
1746 } elsif ($age > 60*2) {
1747 $age_str = int $age/60;
1748 $age_str .= " min ago";
1749 } elsif ($age > 2) {
1750 $age_str = int $age;
1751 $age_str .= " sec ago";
1753 $age_str .= " right now";
1759 S_IFINVALID
=> 0030000,
1760 S_IFGITLINK
=> 0160000,
1763 # submodule/subproject, a commit object reference
1767 return (($mode & S_IFMT
) == S_IFGITLINK
)
1770 # convert file mode in octal to symbolic file mode string
1772 my $mode = oct shift;
1774 if (S_ISGITLINK
($mode)) {
1775 return 'm---------';
1776 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1777 return 'drwxr-xr-x';
1778 } elsif (S_ISLNK
($mode)) {
1779 return 'lrwxrwxrwx';
1780 } elsif (S_ISREG
($mode)) {
1781 # git cares only about the executable bit
1782 if ($mode & S_IXUSR
) {
1783 return '-rwxr-xr-x';
1785 return '-rw-r--r--';
1788 return '----------';
1792 # convert file mode in octal to file type string
1796 if ($mode !~ m/^[0-7]+$/) {
1802 if (S_ISGITLINK
($mode)) {
1804 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1806 } elsif (S_ISLNK
($mode)) {
1808 } elsif (S_ISREG
($mode)) {
1815 # convert file mode in octal to file type description string
1816 sub file_type_long
{
1819 if ($mode !~ m/^[0-7]+$/) {
1825 if (S_ISGITLINK
($mode)) {
1827 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1829 } elsif (S_ISLNK
($mode)) {
1831 } elsif (S_ISREG
($mode)) {
1832 if ($mode & S_IXUSR
) {
1833 return "executable";
1843 ## ----------------------------------------------------------------------
1844 ## functions returning short HTML fragments, or transforming HTML fragments
1845 ## which don't belong to other sections
1847 # format line of commit message.
1848 sub format_log_line_html
{
1851 $line = esc_html
($line, -nbsp
=>1);
1852 $line =~ s
{\b([0-9a
-fA
-F
]{8,40})\b}{
1853 $cgi->a({-href
=> href
(action
=>"object", hash
=>$1),
1854 -class => "text"}, $1);
1860 # format marker of refs pointing to given object
1862 # the destination action is chosen based on object type and current context:
1863 # - for annotated tags, we choose the tag view unless it's the current view
1864 # already, in which case we go to shortlog view
1865 # - for other refs, we keep the current view if we're in history, shortlog or
1866 # log view, and select shortlog otherwise
1867 sub format_ref_marker
{
1868 my ($refs, $id) = @_;
1871 if (defined $refs->{$id}) {
1872 foreach my $ref (@
{$refs->{$id}}) {
1873 # this code exploits the fact that non-lightweight tags are the
1874 # only indirect objects, and that they are the only objects for which
1875 # we want to use tag instead of shortlog as action
1876 my ($type, $name) = qw();
1877 my $indirect = ($ref =~ s/\^\{\}$//);
1878 # e.g. tags/v2.6.11 or heads/next
1879 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1888 $class .= " indirect" if $indirect;
1890 my $dest_action = "shortlog";
1893 $dest_action = "tag" unless $action eq "tag";
1894 } elsif ($action =~ /^(history|(short)?log)$/) {
1895 $dest_action = $action;
1899 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1902 my $link = $cgi->a({
1904 action
=>$dest_action,
1908 $markers .= " <span class=\"".esc_attr
($class)."\" title=\"".esc_attr
($ref)."\">" .
1914 return ' <span class="refs">'. $markers . '</span>';
1920 # format, perhaps shortened and with markers, title line
1921 sub format_subject_html
{
1922 my ($long, $short, $href, $extra) = @_;
1923 $extra = '' unless defined($extra);
1925 if (length($short) < length($long)) {
1926 $long =~ s/[[:cntrl:]]/?/g;
1927 return $cgi->a({-href
=> $href, -class => "list subject",
1928 -title
=> to_utf8
($long)},
1929 esc_html
($short)) . $extra;
1931 return $cgi->a({-href
=> $href, -class => "list subject"},
1932 esc_html
($long)) . $extra;
1936 # Rather than recomputing the url for an email multiple times, we cache it
1937 # after the first hit. This gives a visible benefit in views where the avatar
1938 # for the same email is used repeatedly (e.g. shortlog).
1939 # The cache is shared by all avatar engines (currently gravatar only), which
1940 # are free to use it as preferred. Since only one avatar engine is used for any
1941 # given page, there's no risk for cache conflicts.
1942 our %avatar_cache = ();
1944 # Compute the picon url for a given email, by using the picon search service over at
1945 # http://www.cs.indiana.edu/picons/search.html
1947 my $email = lc shift;
1948 if (!$avatar_cache{$email}) {
1949 my ($user, $domain) = split('@', $email);
1950 $avatar_cache{$email} =
1951 "http://www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
1953 "users+domains+unknown/up/single";
1955 return $avatar_cache{$email};
1958 # Compute the gravatar url for a given email, if it's not in the cache already.
1959 # Gravatar stores only the part of the URL before the size, since that's the
1960 # one computationally more expensive. This also allows reuse of the cache for
1961 # different sizes (for this particular engine).
1963 my $email = lc shift;
1965 $avatar_cache{$email} ||=
1966 "http://www.gravatar.com/avatar/" .
1967 Digest
::MD5
::md5_hex
($email) . "?s=";
1968 return $avatar_cache{$email} . $size;
1971 # Insert an avatar for the given $email at the given $size if the feature
1973 sub git_get_avatar
{
1974 my ($email, %opts) = @_;
1975 my $pre_white = ($opts{-pad_before
} ?
" " : "");
1976 my $post_white = ($opts{-pad_after
} ?
" " : "");
1977 $opts{-size
} ||= 'default';
1978 my $size = $avatar_size{$opts{-size
}} || $avatar_size{'default'};
1980 if ($git_avatar eq 'gravatar') {
1981 $url = gravatar_url
($email, $size);
1982 } elsif ($git_avatar eq 'picon') {
1983 $url = picon_url
($email);
1985 # Other providers can be added by extending the if chain, defining $url
1986 # as needed. If no variant puts something in $url, we assume avatars
1987 # are completely disabled/unavailable.
1990 "<img width=\"$size\" " .
1991 "class=\"avatar\" " .
1992 "src=\"".esc_url
($url)."\" " .
2000 sub format_search_author
{
2001 my ($author, $searchtype, $displaytext) = @_;
2002 my $have_search = gitweb_check_feature
('search');
2006 if ($searchtype eq 'author') {
2007 $performed = "authored";
2008 } elsif ($searchtype eq 'committer') {
2009 $performed = "committed";
2012 return $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
2013 searchtext
=>$author,
2014 searchtype
=>$searchtype), class=>"list",
2015 title
=>"Search for commits $performed by $author"},
2019 return $displaytext;
2023 # format the author name of the given commit with the given tag
2024 # the author name is chopped and escaped according to the other
2025 # optional parameters (see chop_str).
2026 sub format_author_html
{
2029 my $author = chop_and_escape_str
($co->{'author_name'}, @_);
2030 return "<$tag class=\"author\">" .
2031 format_search_author
($co->{'author_name'}, "author",
2032 git_get_avatar
($co->{'author_email'}, -pad_after
=> 1) .
2037 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
2038 sub format_git_diff_header_line
{
2040 my $diffinfo = shift;
2041 my ($from, $to) = @_;
2043 if ($diffinfo->{'nparents'}) {
2045 $line =~ s!^(diff (.*?) )"?.*$!$1!;
2046 if ($to->{'href'}) {
2047 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2048 esc_path
($to->{'file'}));
2049 } else { # file was deleted (no href)
2050 $line .= esc_path
($to->{'file'});
2054 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
2055 if ($from->{'href'}) {
2056 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
2057 'a/' . esc_path
($from->{'file'}));
2058 } else { # file was added (no href)
2059 $line .= 'a/' . esc_path
($from->{'file'});
2062 if ($to->{'href'}) {
2063 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2064 'b/' . esc_path
($to->{'file'}));
2065 } else { # file was deleted
2066 $line .= 'b/' . esc_path
($to->{'file'});
2070 return "<div class=\"diff header\">$line</div>\n";
2073 # format extended diff header line, before patch itself
2074 sub format_extended_diff_header_line
{
2076 my $diffinfo = shift;
2077 my ($from, $to) = @_;
2080 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
2081 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2082 esc_path
($from->{'file'}));
2084 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
2085 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2086 esc_path
($to->{'file'}));
2088 # match single <mode>
2089 if ($line =~ m/\s(\d{6})$/) {
2090 $line .= '<span class="info"> (' .
2091 file_type_long
($1) .
2095 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
2096 # can match only for combined diff
2098 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2099 if ($from->{'href'}[$i]) {
2100 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
2102 substr($diffinfo->{'from_id'}[$i],0,7));
2107 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
2110 if ($to->{'href'}) {
2111 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2112 substr($diffinfo->{'to_id'},0,7));
2117 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
2118 # can match only for ordinary diff
2119 my ($from_link, $to_link);
2120 if ($from->{'href'}) {
2121 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
2122 substr($diffinfo->{'from_id'},0,7));
2124 $from_link = '0' x
7;
2126 if ($to->{'href'}) {
2127 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2128 substr($diffinfo->{'to_id'},0,7));
2132 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2133 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2136 return $line . "<br/>\n";
2139 # format from-file/to-file diff header
2140 sub format_diff_from_to_header
{
2141 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
2146 #assert($line =~ m/^---/) if DEBUG;
2147 # no extra formatting for "^--- /dev/null"
2148 if (! $diffinfo->{'nparents'}) {
2149 # ordinary (single parent) diff
2150 if ($line =~ m!^--- "?a/!) {
2151 if ($from->{'href'}) {
2153 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2154 esc_path
($from->{'file'}));
2157 esc_path
($from->{'file'});
2160 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2163 # combined diff (merge commit)
2164 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2165 if ($from->{'href'}[$i]) {
2167 $cgi->a({-href
=>href
(action
=>"blobdiff",
2168 hash_parent
=>$diffinfo->{'from_id'}[$i],
2169 hash_parent_base
=>$parents[$i],
2170 file_parent
=>$from->{'file'}[$i],
2171 hash
=>$diffinfo->{'to_id'},
2173 file_name
=>$to->{'file'}),
2175 -title
=>"diff" . ($i+1)},
2178 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
2179 esc_path
($from->{'file'}[$i]));
2181 $line = '--- /dev/null';
2183 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2188 #assert($line =~ m/^\+\+\+/) if DEBUG;
2189 # no extra formatting for "^+++ /dev/null"
2190 if ($line =~ m!^\+\+\+ "?b/!) {
2191 if ($to->{'href'}) {
2193 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2194 esc_path
($to->{'file'}));
2197 esc_path
($to->{'file'});
2200 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
2205 # create note for patch simplified by combined diff
2206 sub format_diff_cc_simplified
{
2207 my ($diffinfo, @parents) = @_;
2210 $result .= "<div class=\"diff header\">" .
2212 if (!is_deleted
($diffinfo)) {
2213 $result .= $cgi->a({-href
=> href
(action
=>"blob",
2215 hash
=>$diffinfo->{'to_id'},
2216 file_name
=>$diffinfo->{'to_file'}),
2218 esc_path
($diffinfo->{'to_file'}));
2220 $result .= esc_path
($diffinfo->{'to_file'});
2222 $result .= "</div>\n" . # class="diff header"
2223 "<div class=\"diff nodifferences\">" .
2225 "</div>\n"; # class="diff nodifferences"
2230 sub diff_line_class
{
2231 my ($line, $from, $to) = @_;
2236 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2237 $num_sign = scalar @
{$from->{'href'}};
2240 my @diff_line_classifier = (
2241 { regexp
=> qr/^\@\@{$num_sign} /, class => "chunk_header"},
2242 { regexp
=> qr/^\\/, class => "incomplete" },
2243 { regexp
=> qr/^ {$num_sign}/, class => "ctx" },
2244 # classifier for context must come before classifier add/rem,
2245 # or we would have to use more complicated regexp, for example
2246 # qr/(?= {0,$m}\+)[+ ]{$num_sign}/, where $m = $num_sign - 1;
2247 { regexp
=> qr/^[+ ]{$num_sign}/, class => "add" },
2248 { regexp
=> qr/^[- ]{$num_sign}/, class => "rem" },
2250 for my $clsfy (@diff_line_classifier) {
2251 return $clsfy->{'class'}
2252 if ($line =~ $clsfy->{'regexp'});
2259 # assumes that $from and $to are defined and correctly filled,
2260 # and that $line holds a line of chunk header for unified diff
2261 sub format_unidiff_chunk_header
{
2262 my ($line, $from, $to) = @_;
2264 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2265 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2267 $from_lines = 0 unless defined $from_lines;
2268 $to_lines = 0 unless defined $to_lines;
2270 if ($from->{'href'}) {
2271 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
2272 -class=>"list"}, $from_text);
2274 if ($to->{'href'}) {
2275 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2276 -class=>"list"}, $to_text);
2278 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2279 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2283 # assumes that $from and $to are defined and correctly filled,
2284 # and that $line holds a line of chunk header for combined diff
2285 sub format_cc_diff_chunk_header
{
2286 my ($line, $from, $to) = @_;
2288 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2289 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2291 @from_text = split(' ', $ranges);
2292 for (my $i = 0; $i < @from_text; ++$i) {
2293 ($from_start[$i], $from_nlines[$i]) =
2294 (split(',', substr($from_text[$i], 1)), 0);
2297 $to_text = pop @from_text;
2298 $to_start = pop @from_start;
2299 $to_nlines = pop @from_nlines;
2301 $line = "<span class=\"chunk_info\">$prefix ";
2302 for (my $i = 0; $i < @from_text; ++$i) {
2303 if ($from->{'href'}[$i]) {
2304 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
2305 -class=>"list"}, $from_text[$i]);
2307 $line .= $from_text[$i];
2311 if ($to->{'href'}) {
2312 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2313 -class=>"list"}, $to_text);
2317 $line .= " $prefix</span>" .
2318 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2322 # process patch (diff) line (not to be used for diff headers),
2323 # returning class and HTML-formatted (but not wrapped) line
2324 sub process_diff_line
{
2326 my ($from, $to) = @_;
2328 my $diff_class = diff_line_class
($line, $from, $to);
2331 $line = untabify
($line);
2333 if ($from && $to && $line =~ m/^\@{2} /) {
2334 $line = format_unidiff_chunk_header
($line, $from, $to);
2335 return $diff_class, $line;
2337 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2338 $line = format_cc_diff_chunk_header
($line, $from, $to);
2339 return $diff_class, $line;
2342 return $diff_class, esc_html
($line, -nbsp
=>1);
2345 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2346 # linked. Pass the hash of the tree/commit to snapshot.
2347 sub format_snapshot_links
{
2349 my $num_fmts = @snapshot_fmts;
2350 if ($num_fmts > 1) {
2351 # A parenthesized list of links bearing format names.
2352 # e.g. "snapshot (_tar.gz_ _zip_)"
2353 return "snapshot (" . join(' ', map
2360 }, $known_snapshot_formats{$_}{'display'})
2361 , @snapshot_fmts) . ")";
2362 } elsif ($num_fmts == 1) {
2363 # A single "snapshot" link whose tooltip bears the format name.
2365 my ($fmt) = @snapshot_fmts;
2371 snapshot_format
=>$fmt
2373 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
2375 } else { # $num_fmts == 0
2380 ## ......................................................................
2381 ## functions returning values to be passed, perhaps after some
2382 ## transformation, to other functions; e.g. returning arguments to href()
2384 # returns hash to be passed to href to generate gitweb URL
2385 # in -title key it returns description of link
2387 my $format = shift || 'Atom';
2388 my %res = (action
=> lc($format));
2390 # feed links are possible only for project views
2391 return unless (defined $project);
2392 # some views should link to OPML, or to generic project feed,
2393 # or don't have specific feed yet (so they should use generic)
2394 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
2397 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
2398 # from tag links; this also makes possible to detect branch links
2399 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
2400 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
2403 # find log type for feed description (title)
2405 if (defined $file_name) {
2406 $type = "history of $file_name";
2407 $type .= "/" if ($action eq 'tree');
2408 $type .= " on '$branch'" if (defined $branch);
2410 $type = "log of $branch" if (defined $branch);
2413 $res{-title
} = $type;
2414 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
2415 $res{'file_name'} = $file_name;
2420 ## ----------------------------------------------------------------------
2421 ## git utility subroutines, invoking git commands
2423 # returns path to the core git executable and the --git-dir parameter as list
2425 $number_of_git_cmds++;
2426 return $GIT, '--git-dir='.$git_dir;
2429 # quote the given arguments for passing them to the shell
2430 # quote_command("command", "arg 1", "arg with ' and ! characters")
2431 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2432 # Try to avoid using this function wherever possible.
2435 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
2438 # get HEAD ref of given project as hash
2439 sub git_get_head_hash
{
2440 return git_get_full_hash
(shift, 'HEAD');
2443 sub git_get_full_hash
{
2444 return git_get_hash
(@_);
2447 sub git_get_short_hash
{
2448 return git_get_hash
(@_, '--short=7');
2452 my ($project, $hash, @options) = @_;
2453 my $o_git_dir = $git_dir;
2455 $git_dir = "$projectroot/$project";
2456 if (open my $fd, '-|', git_cmd
(), 'rev-parse',
2457 '--verify', '-q', @options, $hash) {
2459 chomp $retval if defined $retval;
2462 if (defined $o_git_dir) {
2463 $git_dir = $o_git_dir;
2468 # get type of given object
2472 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
2474 close $fd or return;
2479 # repository configuration
2480 our $config_file = '';
2483 # store multiple values for single key as anonymous array reference
2484 # single values stored directly in the hash, not as [ <value> ]
2485 sub hash_set_multi
{
2486 my ($hash, $key, $value) = @_;
2488 if (!exists $hash->{$key}) {
2489 $hash->{$key} = $value;
2490 } elsif (!ref $hash->{$key}) {
2491 $hash->{$key} = [ $hash->{$key}, $value ];
2493 push @
{$hash->{$key}}, $value;
2497 # return hash of git project configuration
2498 # optionally limited to some section, e.g. 'gitweb'
2499 sub git_parse_project_config
{
2500 my $section_regexp = shift;
2505 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
2508 while (my $keyval = <$fh>) {
2510 my ($key, $value) = split(/\n/, $keyval, 2);
2512 hash_set_multi
(\
%config, $key, $value)
2513 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2520 # convert config value to boolean: 'true' or 'false'
2521 # no value, number > 0, 'true' and 'yes' values are true
2522 # rest of values are treated as false (never as error)
2523 sub config_to_bool
{
2526 return 1 if !defined $val; # section.key
2528 # strip leading and trailing whitespace
2532 return (($val =~ /^\d+$/ && $val) || # section.key = 1
2533 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2536 # convert config value to simple decimal number
2537 # an optional value suffix of 'k', 'm', or 'g' will cause the value
2538 # to be multiplied by 1024, 1048576, or 1073741824
2542 # strip leading and trailing whitespace
2546 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2548 # unknown unit is treated as 1
2549 return $num * ($unit eq 'g' ?
1073741824 :
2550 $unit eq 'm' ?
1048576 :
2551 $unit eq 'k' ?
1024 : 1);
2556 # convert config value to array reference, if needed
2557 sub config_to_multi
{
2560 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
2563 sub git_get_project_config
{
2564 my ($key, $type) = @_;
2566 return unless defined $git_dir;
2569 return unless ($key);
2570 # only subsection, if exists, is case sensitive,
2571 # and not lowercased by 'git config -z -l'
2572 if (my ($hi, $mi, $lo) = ($key =~ /^([^.]*)\.(.*)\.([^.]*)$/)) {
2573 $key = join(".", lc($hi), $mi, lc($lo));
2577 $key =~ s/^gitweb\.//;
2578 return if ($key =~ m/\W/);
2581 if (defined $type) {
2584 unless ($type eq 'bool' || $type eq 'int');
2588 if (!defined $config_file ||
2589 $config_file ne "$git_dir/config") {
2590 %config = git_parse_project_config
('gitweb');
2591 $config_file = "$git_dir/config";
2594 # check if config variable (key) exists
2595 return unless exists $config{"gitweb.$key"};
2598 if (!defined $type) {
2599 return $config{"gitweb.$key"};
2600 } elsif ($type eq 'bool') {
2601 # backward compatibility: 'git config --bool' returns true/false
2602 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
2603 } elsif ($type eq 'int') {
2604 return config_to_int
($config{"gitweb.$key"});
2606 return $config{"gitweb.$key"};
2609 # get hash of given path at given ref
2610 sub git_get_hash_by_path
{
2612 my $path = shift || return undef;
2617 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
2618 or die_error
(500, "Open git-ls-tree failed");
2620 close $fd or return undef;
2622 if (!defined $line) {
2623 # there is no tree or hash given by $path at $base
2627 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2628 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2629 if (defined $type && $type ne $2) {
2630 # type doesn't match
2636 # get path of entry with given hash at given tree-ish (ref)
2637 # used to get 'from' filename for combined diff (merge commit) for renames
2638 sub git_get_path_by_hash
{
2639 my $base = shift || return;
2640 my $hash = shift || return;
2644 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
2646 while (my $line = <$fd>) {
2649 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2650 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2651 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2660 ## ......................................................................
2661 ## git utility functions, directly accessing git repository
2663 # get the value of config variable either from file named as the variable
2664 # itself in the repository ($GIT_DIR/$name file), or from gitweb.$name
2665 # configuration variable in the repository config file.
2666 sub git_get_file_or_project_config
{
2667 my ($path, $name) = @_;
2669 $git_dir = "$projectroot/$path";
2670 open my $fd, '<', "$git_dir/$name"
2671 or return git_get_project_config
($name);
2674 if (defined $conf) {
2680 sub git_get_project_description
{
2682 return git_get_file_or_project_config
($path, 'description');
2685 sub git_get_project_category
{
2687 return git_get_file_or_project_config
($path, 'category');
2691 # supported formats:
2692 # * $GIT_DIR/ctags/<tagname> file (in 'ctags' subdirectory)
2693 # - if its contents is a number, use it as tag weight,
2694 # - otherwise add a tag with weight 1
2695 # * $GIT_DIR/ctags file, each line is a tag (with weight 1)
2696 # the same value multiple times increases tag weight
2697 # * `gitweb.ctag' multi-valued repo config variable
2698 sub git_get_project_ctags
{
2699 my $project = shift;
2702 $git_dir = "$projectroot/$project";
2703 if (opendir my $dh, "$git_dir/ctags") {
2704 my @files = grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir($dh);
2705 foreach my $tagfile (@files) {
2706 open my $ct, '<', $tagfile
2712 (my $ctag = $tagfile) =~ s
#.*/##;
2713 if ($val =~ /^\d+$/) {
2714 $ctags->{$ctag} = $val;
2716 $ctags->{$ctag} = 1;
2721 } elsif (open my $fh, '<', "$git_dir/ctags") {
2722 while (my $line = <$fh>) {
2724 $ctags->{$line}++ if $line;
2729 my $taglist = config_to_multi
(git_get_project_config
('ctag'));
2730 foreach my $tag (@
$taglist) {
2738 # return hash, where keys are content tags ('ctags'),
2739 # and values are sum of weights of given tag in every project
2740 sub git_gather_all_ctags
{
2741 my $projects = shift;
2744 foreach my $p (@
$projects) {
2745 foreach my $ct (keys %{$p->{'ctags'}}) {
2746 $ctags->{$ct} += $p->{'ctags'}->{$ct};
2753 sub git_populate_project_tagcloud
{
2756 # First, merge different-cased tags; tags vote on casing
2758 foreach (keys %$ctags) {
2759 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2760 if (not $ctags_lc{lc $_}->{topcount
}
2761 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2762 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2763 $ctags_lc{lc $_}->{topname
} = $_;
2768 my $matched = $cgi->param('by_tag');
2769 if (eval { require HTML
::TagCloud
; 1; }) {
2770 $cloud = HTML
::TagCloud
->new;
2771 foreach my $ctag (sort keys %ctags_lc) {
2772 # Pad the title with spaces so that the cloud looks
2774 my $title = esc_html
($ctags_lc{$ctag}->{topname
});
2775 $title =~ s/ / /g;
2776 $title =~ s/^/ /g;
2777 $title =~ s/$/ /g;
2778 if (defined $matched && $matched eq $ctag) {
2779 $title = qq(<span
class="match">$title</span
>);
2781 $cloud->add($title, href
(project
=>undef, ctag
=>$ctag),
2782 $ctags_lc{$ctag}->{count
});
2786 foreach my $ctag (keys %ctags_lc) {
2787 my $title = esc_html
($ctags_lc{$ctag}->{topname
}, -nbsp
=>1);
2788 if (defined $matched && $matched eq $ctag) {
2789 $title = qq(<span
class="match">$title</span
>);
2791 $cloud->{$ctag}{count
} = $ctags_lc{$ctag}->{count
};
2792 $cloud->{$ctag}{ctag
} =
2793 $cgi->a({-href
=>href
(project
=>undef, ctag
=>$ctag)}, $title);
2799 sub git_show_project_tagcloud
{
2800 my ($cloud, $count) = @_;
2801 if (ref $cloud eq 'HTML::TagCloud') {
2802 return $cloud->html_and_css($count);
2804 my @tags = sort { $cloud->{$a}->{'count'} <=> $cloud->{$b}->{'count'} } keys %$cloud;
2806 '<div id="htmltagcloud"'.($project ?
'' : ' align="center"').'>' .
2808 $cloud->{$_}->{'ctag'}
2809 } splice(@tags, 0, $count)) .
2814 sub git_get_project_url_list
{
2817 $git_dir = "$projectroot/$path";
2818 open my $fd, '<', "$git_dir/cloneurl"
2819 or return wantarray ?
2820 @
{ config_to_multi
(git_get_project_config
('url')) } :
2821 config_to_multi
(git_get_project_config
('url'));
2822 my @git_project_url_list = map { chomp; $_ } <$fd>;
2825 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2828 sub git_get_projects_list
{
2829 my $filter = shift || '';
2830 my $paranoid = shift;
2833 if (-d
$projects_list) {
2834 # search in directory
2835 my $dir = $projects_list;
2836 # remove the trailing "/"
2838 my $pfxlen = length("$dir");
2839 my $pfxdepth = ($dir =~ tr!/!!);
2840 # when filtering, search only given subdirectory
2841 if ($filter && !$paranoid) {
2847 follow_fast
=> 1, # follow symbolic links
2848 follow_skip
=> 2, # ignore duplicates
2849 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2852 our $project_maxdepth;
2854 # skip project-list toplevel, if we get it.
2855 return if (m!^[/.]$!);
2856 # only directories can be git repositories
2857 return unless (-d
$_);
2858 # don't traverse too deep (Find is super slow on os x)
2859 # $project_maxdepth excludes depth of $projectroot
2860 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2861 $File::Find
::prune
= 1;
2865 my $path = substr($File::Find
::name
, $pfxlen + 1);
2866 # paranoidly only filter here
2867 if ($paranoid && $filter && $path !~ m!^\Q$filter\E/!) {
2870 # we check related file in $projectroot
2871 if (check_export_ok
("$projectroot/$path")) {
2872 push @list, { path
=> $path };
2873 $File::Find
::prune
= 1;
2878 } elsif (-f
$projects_list) {
2879 # read from file(url-encoded):
2880 # 'git%2Fgit.git Linus+Torvalds'
2881 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2882 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2883 open my $fd, '<', $projects_list or return;
2885 while (my $line = <$fd>) {
2887 my ($path, $owner) = split ' ', $line;
2888 $path = unescape
($path);
2889 $owner = unescape
($owner);
2890 if (!defined $path) {
2893 # if $filter is rpovided, check if $path begins with $filter
2894 if ($filter && $path !~ m!^\Q$filter\E/!) {
2897 if (check_export_ok
("$projectroot/$path")) {
2900 owner
=> to_utf8
($owner),
2910 # written with help of Tree::Trie module (Perl Artistic License, GPL compatibile)
2911 # as side effects it sets 'forks' field to list of forks for forked projects
2912 sub filter_forks_from_projects_list
{
2913 my $projects = shift;
2915 my %trie; # prefix tree of directories (path components)
2916 # generate trie out of those directories that might contain forks
2917 foreach my $pr (@
$projects) {
2918 my $path = $pr->{'path'};
2919 $path =~ s/\.git$//; # forks of 'repo.git' are in 'repo/' directory
2920 next if ($path =~ m!/$!); # skip non-bare repositories, e.g. 'repo/.git'
2921 next unless ($path); # skip '.git' repository: tests, git-instaweb
2922 next unless (-d
"$projectroot/$path"); # containing directory exists
2923 $pr->{'forks'} = []; # there can be 0 or more forks of project
2926 my @dirs = split('/', $path);
2927 # walk the trie, until either runs out of components or out of trie
2929 while (scalar @dirs &&
2930 exists($ref->{$dirs[0]})) {
2931 $ref = $ref->{shift @dirs};
2933 # create rest of trie structure from rest of components
2934 foreach my $dir (@dirs) {
2935 $ref = $ref->{$dir} = {};
2937 # create end marker, store $pr as a data
2938 $ref->{''} = $pr if (!exists $ref->{''});
2941 # filter out forks, by finding shortest prefix match for paths
2944 foreach my $pr (@
$projects) {
2948 foreach my $dir (split('/', $pr->{'path'})) {
2949 if (exists $ref->{''}) {
2950 # found [shortest] prefix, is a fork - skip it
2951 push @
{$ref->{''}{'forks'}}, $pr;
2954 if (!exists $ref->{$dir}) {
2955 # not in trie, cannot have prefix, not a fork
2956 push @filtered, $pr;
2959 # If the dir is there, we just walk one step down the trie.
2960 $ref = $ref->{$dir};
2962 # we ran out of trie
2963 # (shouldn't happen: it's either no match, or end marker)
2964 push @filtered, $pr;
2970 # note: fill_project_list_info must be run first,
2971 # for 'descr_long' and 'ctags' to be filled
2972 sub search_projects_list
{
2973 my ($projlist, %opts) = @_;
2974 my $tagfilter = $opts{'tagfilter'};
2975 my $searchtext = $opts{'searchtext'};
2978 unless ($tagfilter || $searchtext);
2982 foreach my $pr (@
$projlist) {
2985 next unless ref($pr->{'ctags'}) eq 'HASH';
2987 grep { lc($_) eq lc($tagfilter) } keys %{$pr->{'ctags'}};
2992 $pr->{'path'} =~ /$searchtext/ ||
2993 $pr->{'descr_long'} =~ /$searchtext/;
2996 push @projects, $pr;
3002 our $gitweb_project_owner = undef;
3003 sub git_get_project_list_from_file
{
3005 return if (defined $gitweb_project_owner);
3007 $gitweb_project_owner = {};
3008 # read from file (url-encoded):
3009 # 'git%2Fgit.git Linus+Torvalds'
3010 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
3011 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
3012 if (-f
$projects_list) {
3013 open(my $fd, '<', $projects_list);
3014 while (my $line = <$fd>) {
3016 my ($pr, $ow) = split ' ', $line;
3017 $pr = unescape
($pr);
3018 $ow = unescape
($ow);
3019 $gitweb_project_owner->{$pr} = to_utf8
($ow);
3025 sub git_get_project_owner
{
3026 my $project = shift;
3029 return undef unless $project;
3030 $git_dir = "$projectroot/$project";
3032 if (!defined $gitweb_project_owner) {
3033 git_get_project_list_from_file
();
3036 if (exists $gitweb_project_owner->{$project}) {
3037 $owner = $gitweb_project_owner->{$project};
3039 if (!defined $owner){
3040 $owner = git_get_project_config
('owner');
3042 if (!defined $owner) {
3043 $owner = get_file_owner
("$git_dir");
3049 sub git_get_last_activity
{
3053 $git_dir = "$projectroot/$path";
3054 open($fd, "-|", git_cmd
(), 'for-each-ref',
3055 '--format=%(committer)',
3056 '--sort=-committerdate',
3058 'refs/heads') or return;
3059 my $most_recent = <$fd>;
3060 close $fd or return;
3061 if (defined $most_recent &&
3062 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
3064 my $age = time - $timestamp;
3065 return ($age, age_string
($age));
3067 return (undef, undef);
3070 # Implementation note: when a single remote is wanted, we cannot use 'git
3071 # remote show -n' because that command always work (assuming it's a remote URL
3072 # if it's not defined), and we cannot use 'git remote show' because that would
3073 # try to make a network roundtrip. So the only way to find if that particular
3074 # remote is defined is to walk the list provided by 'git remote -v' and stop if
3075 # and when we find what we want.
3076 sub git_get_remotes_list
{
3080 open my $fd, '-|' , git_cmd
(), 'remote', '-v';
3082 while (my $remote = <$fd>) {
3084 $remote =~ s!\t(.*?)\s+\((\w+)\)$!!;
3085 next if $wanted and not $remote eq $wanted;
3086 my ($url, $key) = ($1, $2);
3088 $remotes{$remote} ||= { 'heads' => () };
3089 $remotes{$remote}{$key} = $url;
3091 close $fd or return;
3092 return wantarray ?
%remotes : \
%remotes;
3095 # Takes a hash of remotes as first parameter and fills it by adding the
3096 # available remote heads for each of the indicated remotes.
3097 sub fill_remote_heads
{
3098 my $remotes = shift;
3099 my @heads = map { "remotes/$_" } keys %$remotes;
3100 my @remoteheads = git_get_heads_list
(undef, @heads);
3101 foreach my $remote (keys %$remotes) {
3102 $remotes->{$remote}{'heads'} = [ grep {
3103 $_->{'name'} =~ s!^$remote/!!
3108 sub git_get_references
{
3109 my $type = shift || "";
3111 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
3112 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
3113 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
3114 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
3117 while (my $line = <$fd>) {
3119 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
3120 if (defined $refs{$1}) {
3121 push @
{$refs{$1}}, $2;
3127 close $fd or return;
3131 sub git_get_rev_name_tags
{
3132 my $hash = shift || return undef;
3134 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
3136 my $name_rev = <$fd>;
3139 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
3142 # catches also '$hash undefined' output
3147 ## ----------------------------------------------------------------------
3148 ## parse to hash functions
3152 my $tz = shift || "-0000";
3155 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
3156 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
3157 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
3158 $date{'hour'} = $hour;
3159 $date{'minute'} = $min;
3160 $date{'mday'} = $mday;
3161 $date{'day'} = $days[$wday];
3162 $date{'month'} = $months[$mon];
3163 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
3164 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
3165 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
3166 $mday, $months[$mon], $hour ,$min;
3167 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
3168 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
3170 my ($tz_sign, $tz_hour, $tz_min) =
3171 ($tz =~ m/^([-+])(\d\d)(\d\d)$/);
3172 $tz_sign = ($tz_sign eq '-' ?
-1 : +1);
3173 my $local = $epoch + $tz_sign*((($tz_hour*60) + $tz_min)*60);
3174 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
3175 $date{'hour_local'} = $hour;
3176 $date{'minute_local'} = $min;
3177 $date{'tz_local'} = $tz;
3178 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
3179 1900+$year, $mon+1, $mday,
3180 $hour, $min, $sec, $tz);
3189 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
3190 $tag{'id'} = $tag_id;
3191 while (my $line = <$fd>) {
3193 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
3194 $tag{'object'} = $1;
3195 } elsif ($line =~ m/^type (.+)$/) {
3197 } elsif ($line =~ m/^tag (.+)$/) {
3199 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
3200 $tag{'author'} = $1;
3201 $tag{'author_epoch'} = $2;
3202 $tag{'author_tz'} = $3;
3203 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3204 $tag{'author_name'} = $1;
3205 $tag{'author_email'} = $2;
3207 $tag{'author_name'} = $tag{'author'};
3209 } elsif ($line =~ m/--BEGIN/) {
3210 push @comment, $line;
3212 } elsif ($line eq "") {
3216 push @comment, <$fd>;
3217 $tag{'comment'} = \
@comment;
3218 close $fd or return;
3219 if (!defined $tag{'name'}) {
3225 sub parse_commit_text
{
3226 my ($commit_text, $withparents) = @_;
3227 my @commit_lines = split '\n', $commit_text;
3230 pop @commit_lines; # Remove '\0'
3232 if (! @commit_lines) {
3236 my $header = shift @commit_lines;
3237 if ($header !~ m/^[0-9a-fA-F]{40}/) {
3240 ($co{'id'}, my @parents) = split ' ', $header;
3241 while (my $line = shift @commit_lines) {
3242 last if $line eq "\n";
3243 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
3245 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
3247 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
3248 $co{'author'} = to_utf8
($1);
3249 $co{'author_epoch'} = $2;
3250 $co{'author_tz'} = $3;
3251 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3252 $co{'author_name'} = $1;
3253 $co{'author_email'} = $2;
3255 $co{'author_name'} = $co{'author'};
3257 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
3258 $co{'committer'} = to_utf8
($1);
3259 $co{'committer_epoch'} = $2;
3260 $co{'committer_tz'} = $3;
3261 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
3262 $co{'committer_name'} = $1;
3263 $co{'committer_email'} = $2;
3265 $co{'committer_name'} = $co{'committer'};
3269 if (!defined $co{'tree'}) {
3272 $co{'parents'} = \
@parents;
3273 $co{'parent'} = $parents[0];
3275 foreach my $title (@commit_lines) {
3278 $co{'title'} = chop_str
($title, 80, 5);
3279 # remove leading stuff of merges to make the interesting part visible
3280 if (length($title) > 50) {
3281 $title =~ s/^Automatic //;
3282 $title =~ s/^merge (of|with) /Merge ... /i;
3283 if (length($title) > 50) {
3284 $title =~ s/(http|rsync):\/\///;
3286 if (length($title) > 50) {
3287 $title =~ s/(master|www|rsync)\.//;
3289 if (length($title) > 50) {
3290 $title =~ s/kernel.org:?//;
3292 if (length($title) > 50) {
3293 $title =~ s/\/pub\/scm//;
3296 $co{'title_short'} = chop_str
($title, 50, 5);
3300 if (! defined $co{'title'} || $co{'title'} eq "") {
3301 $co{'title'} = $co{'title_short'} = '(no commit message)';
3303 # remove added spaces
3304 foreach my $line (@commit_lines) {
3307 $co{'comment'} = \
@commit_lines;
3309 my $age = time - $co{'committer_epoch'};
3311 $co{'age_string'} = age_string
($age);
3312 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
3313 if ($age > 60*60*24*7*2) {
3314 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3315 $co{'age_string_age'} = $co{'age_string'};
3317 $co{'age_string_date'} = $co{'age_string'};
3318 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3324 my ($commit_id) = @_;
3329 open my $fd, "-|", git_cmd
(), "rev-list",
3335 or die_error
(500, "Open git-rev-list failed");
3336 %co = parse_commit_text
(<$fd>, 1);
3343 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
3351 open my $fd, "-|", git_cmd
(), "rev-list",
3354 ("--max-count=" . $maxcount),
3355 ("--skip=" . $skip),
3359 ($filename ?
($filename) : ())
3360 or die_error
(500, "Open git-rev-list failed");
3361 while (my $line = <$fd>) {
3362 my %co = parse_commit_text
($line);
3367 return wantarray ?
@cos : \
@cos;
3370 # parse line of git-diff-tree "raw" output
3371 sub parse_difftree_raw_line
{
3375 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3376 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
3377 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
3378 $res{'from_mode'} = $1;
3379 $res{'to_mode'} = $2;
3380 $res{'from_id'} = $3;
3382 $res{'status'} = $5;
3383 $res{'similarity'} = $6;
3384 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
3385 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
3387 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
3390 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3391 # combined diff (for merge commit)
3392 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
3393 $res{'nparents'} = length($1);
3394 $res{'from_mode'} = [ split(' ', $2) ];
3395 $res{'to_mode'} = pop @
{$res{'from_mode'}};
3396 $res{'from_id'} = [ split(' ', $3) ];
3397 $res{'to_id'} = pop @
{$res{'from_id'}};
3398 $res{'status'} = [ split('', $4) ];
3399 $res{'to_file'} = unquote
($5);
3401 # 'c512b523472485aef4fff9e57b229d9d243c967f'
3402 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
3403 $res{'commit'} = $1;
3406 return wantarray ?
%res : \
%res;
3409 # wrapper: return parsed line of git-diff-tree "raw" output
3410 # (the argument might be raw line, or parsed info)
3411 sub parsed_difftree_line
{
3412 my $line_or_ref = shift;
3414 if (ref($line_or_ref) eq "HASH") {
3415 # pre-parsed (or generated by hand)
3416 return $line_or_ref;
3418 return parse_difftree_raw_line
($line_or_ref);
3422 # parse line of git-ls-tree output
3423 sub parse_ls_tree_line
{
3429 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
3430 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40}) +(-|[0-9]+)\t(.+)$/s;
3439 $res{'name'} = unquote
($5);
3442 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
3443 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
3451 $res{'name'} = unquote
($4);
3455 return wantarray ?
%res : \
%res;
3458 # generates _two_ hashes, references to which are passed as 2 and 3 argument
3459 sub parse_from_to_diffinfo
{
3460 my ($diffinfo, $from, $to, @parents) = @_;
3462 if ($diffinfo->{'nparents'}) {
3464 $from->{'file'} = [];
3465 $from->{'href'} = [];
3466 fill_from_file_info
($diffinfo, @parents)
3467 unless exists $diffinfo->{'from_file'};
3468 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
3469 $from->{'file'}[$i] =
3470 defined $diffinfo->{'from_file'}[$i] ?
3471 $diffinfo->{'from_file'}[$i] :
3472 $diffinfo->{'to_file'};
3473 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3474 $from->{'href'}[$i] = href
(action
=>"blob",
3475 hash_base
=>$parents[$i],
3476 hash
=>$diffinfo->{'from_id'}[$i],
3477 file_name
=>$from->{'file'}[$i]);
3479 $from->{'href'}[$i] = undef;
3483 # ordinary (not combined) diff
3484 $from->{'file'} = $diffinfo->{'from_file'};
3485 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3486 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
3487 hash
=>$diffinfo->{'from_id'},
3488 file_name
=>$from->{'file'});
3490 delete $from->{'href'};
3494 $to->{'file'} = $diffinfo->{'to_file'};
3495 if (!is_deleted
($diffinfo)) { # file exists in result
3496 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
3497 hash
=>$diffinfo->{'to_id'},
3498 file_name
=>$to->{'file'});
3500 delete $to->{'href'};
3504 ## ......................................................................
3505 ## parse to array of hashes functions
3507 sub git_get_heads_list
{
3508 my ($limit, @classes) = @_;
3509 @classes = ('heads') unless @classes;
3510 my @patterns = map { "refs/$_" } @classes;
3513 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3514 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
3515 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
3518 while (my $line = <$fd>) {
3522 my ($refinfo, $committerinfo) = split(/\0/, $line);
3523 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3524 my ($committer, $epoch, $tz) =
3525 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
3526 $ref_item{'fullname'} = $name;
3527 $name =~ s!^refs/(?:head|remote)s/!!;
3529 $ref_item{'name'} = $name;
3530 $ref_item{'id'} = $hash;
3531 $ref_item{'title'} = $title || '(no commit message)';
3532 $ref_item{'epoch'} = $epoch;
3534 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3536 $ref_item{'age'} = "unknown";
3539 push @headslist, \
%ref_item;
3543 return wantarray ?
@headslist : \
@headslist;
3546 sub git_get_tags_list
{
3550 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3551 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
3552 '--format=%(objectname) %(objecttype) %(refname) '.
3553 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3556 while (my $line = <$fd>) {
3560 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3561 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3562 my ($creator, $epoch, $tz) =
3563 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
3564 $ref_item{'fullname'} = $name;
3565 $name =~ s!^refs/tags/!!;
3567 $ref_item{'type'} = $type;
3568 $ref_item{'id'} = $id;
3569 $ref_item{'name'} = $name;
3570 if ($type eq "tag") {
3571 $ref_item{'subject'} = $title;
3572 $ref_item{'reftype'} = $reftype;
3573 $ref_item{'refid'} = $refid;
3575 $ref_item{'reftype'} = $type;
3576 $ref_item{'refid'} = $id;
3579 if ($type eq "tag" || $type eq "commit") {
3580 $ref_item{'epoch'} = $epoch;
3582 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3584 $ref_item{'age'} = "unknown";
3588 push @tagslist, \
%ref_item;
3592 return wantarray ?
@tagslist : \
@tagslist;
3595 ## ----------------------------------------------------------------------
3596 ## filesystem-related functions
3598 sub get_file_owner
{
3601 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3602 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3603 if (!defined $gcos) {
3607 $owner =~ s/[,;].*$//;
3608 return to_utf8
($owner);
3611 # assume that file exists
3613 my $filename = shift;
3615 open my $fd, '<', $filename;
3616 print map { to_utf8
($_) } <$fd>;
3620 ## ......................................................................
3621 ## mimetype related functions
3623 sub mimetype_guess_file
{
3624 my $filename = shift;
3625 my $mimemap = shift;
3626 -r
$mimemap or return undef;
3629 open(my $mh, '<', $mimemap) or return undef;
3631 next if m/^#/; # skip comments
3632 my ($mimetype, @exts) = split(/\s+/);
3633 foreach my $ext (@exts) {
3634 $mimemap{$ext} = $mimetype;
3639 $filename =~ /\.([^.]*)$/;
3640 return $mimemap{$1};
3643 sub mimetype_guess
{
3644 my $filename = shift;
3646 $filename =~ /\./ or return undef;
3648 if ($mimetypes_file) {
3649 my $file = $mimetypes_file;
3650 if ($file !~ m!^/!) { # if it is relative path
3651 # it is relative to project
3652 $file = "$projectroot/$project/$file";
3654 $mime = mimetype_guess_file
($filename, $file);
3656 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
3662 my $filename = shift;
3665 my $mime = mimetype_guess
($filename);
3666 $mime and return $mime;
3670 return $default_blob_plain_mimetype unless $fd;
3673 return 'text/plain';
3674 } elsif (! $filename) {
3675 return 'application/octet-stream';
3676 } elsif ($filename =~ m/\.png$/i) {
3678 } elsif ($filename =~ m/\.gif$/i) {
3680 } elsif ($filename =~ m/\.jpe?g$/i) {
3681 return 'image/jpeg';
3683 return 'application/octet-stream';
3687 sub blob_contenttype
{
3688 my ($fd, $file_name, $type) = @_;
3690 $type ||= blob_mimetype
($fd, $file_name);
3691 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3692 $type .= "; charset=$default_text_plain_charset";
3698 # guess file syntax for syntax highlighting; return undef if no highlighting
3699 # the name of syntax can (in the future) depend on syntax highlighter used
3700 sub guess_file_syntax
{
3701 my ($highlight, $mimetype, $file_name) = @_;
3702 return undef unless ($highlight && defined $file_name);
3703 my $basename = basename
($file_name, '.in');
3704 return $highlight_basename{$basename}
3705 if exists $highlight_basename{$basename};
3707 $basename =~ /\.([^.]*)$/;
3708 my $ext = $1 or return undef;
3709 return $highlight_ext{$ext}
3710 if exists $highlight_ext{$ext};
3715 # run highlighter and return FD of its output,
3716 # or return original FD if no highlighting
3717 sub run_highlighter
{
3718 my ($fd, $highlight, $syntax) = @_;
3719 return $fd unless ($highlight && defined $syntax);
3722 open $fd, quote_command
(git_cmd
(), "cat-file", "blob", $hash)." | ".
3723 quote_command
($highlight_bin).
3724 " --replace-tabs=8 --fragment --syntax $syntax |"
3725 or die_error
(500, "Couldn't open file or run syntax highlighter");
3729 ## ======================================================================
3730 ## functions printing HTML: header, footer, error page
3732 sub get_page_title
{
3733 my $title = to_utf8
($site_name);
3735 return $title unless (defined $project);
3736 $title .= " - " . to_utf8
($project);
3738 return $title unless (defined $action);
3739 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
3741 return $title unless (defined $file_name);
3742 $title .= " - " . esc_path
($file_name);
3743 if ($action eq "tree" && $file_name !~ m
|/$|) {
3750 sub get_content_type_html
{
3751 # require explicit support from the UA if we are to send the page as
3752 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
3753 # we have to do this because MSIE sometimes globs '*/*', pretending to
3754 # support xhtml+xml but choking when it gets what it asked for.
3755 if (defined $cgi->http('HTTP_ACCEPT') &&
3756 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
3757 $cgi->Accept('application/xhtml+xml') != 0) {
3758 return 'application/xhtml+xml';
3764 sub print_feed_meta
{
3765 if (defined $project) {
3766 my %href_params = get_feed_info
();
3767 if (!exists $href_params{'-title'}) {
3768 $href_params{'-title'} = 'log';
3771 foreach my $format (qw(RSS Atom)) {
3772 my $type = lc($format);
3774 '-rel' => 'alternate',
3775 '-title' => esc_attr
("$project - $href_params{'-title'} - $format feed"),
3776 '-type' => "application/$type+xml"
3779 $href_params{'action'} = $type;
3780 $link_attr{'-href'} = href
(%href_params);
3782 "rel=\"$link_attr{'-rel'}\" ".
3783 "title=\"$link_attr{'-title'}\" ".
3784 "href=\"$link_attr{'-href'}\" ".
3785 "type=\"$link_attr{'-type'}\" ".
3788 $href_params{'extra_options'} = '--no-merges';
3789 $link_attr{'-href'} = href
(%href_params);
3790 $link_attr{'-title'} .= ' (no merges)';
3792 "rel=\"$link_attr{'-rel'}\" ".
3793 "title=\"$link_attr{'-title'}\" ".
3794 "href=\"$link_attr{'-href'}\" ".
3795 "type=\"$link_attr{'-type'}\" ".
3800 printf('<link rel="alternate" title="%s projects list" '.
3801 'href="%s" type="text/plain; charset=utf-8" />'."\n",
3802 esc_attr
($site_name), href
(project
=>undef, action
=>"project_index"));
3803 printf('<link rel="alternate" title="%s projects feeds" '.
3804 'href="%s" type="text/x-opml" />'."\n",
3805 esc_attr
($site_name), href
(project
=>undef, action
=>"opml"));
3809 sub print_header_links
{
3812 # print out each stylesheet that exist, providing backwards capability
3813 # for those people who defined $stylesheet in a config file
3814 if (defined $stylesheet) {
3815 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3817 foreach my $stylesheet (@stylesheets) {
3818 next unless $stylesheet;
3819 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3823 if ($status eq '200 OK');
3824 if (defined $favicon) {
3825 print qq(<link rel
="shortcut icon" href
=").esc_url($favicon).qq(" type
="image/png" />\n);
3829 sub print_nav_breadcrumbs
{
3832 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
3833 if (defined $project) {
3834 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
3835 if (defined $action) {
3836 my $action_print = $action ;
3837 if (defined $opts{-action_extra
}) {
3838 $action_print = $cgi->a({-href
=> href
(action
=>$action)},
3841 print " / $action_print";
3843 if (defined $opts{-action_extra
}) {
3844 print " / $opts{-action_extra}";
3850 sub print_search_form
{
3851 if (!defined $searchtext) {
3855 if (defined $hash_base) {
3856 $search_hash = $hash_base;
3857 } elsif (defined $hash) {
3858 $search_hash = $hash;
3860 $search_hash = "HEAD";
3862 my $action = $my_uri;
3863 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3864 if ($use_pathinfo) {
3865 $action .= "/".esc_url
($project);
3867 print $cgi->startform(-method
=> "get", -action
=> $action) .
3868 "<div class=\"search\">\n" .
3870 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3871 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3872 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3873 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3874 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3875 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3877 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
3878 "<span title=\"Extended regular expression\">" .
3879 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3880 -checked
=> $search_use_regexp) .
3883 $cgi->end_form() . "\n";
3886 sub git_header_html
{
3887 my $status = shift || "200 OK";
3888 my $expires = shift;
3891 my $title = get_page_title
();
3892 my $content_type = get_content_type_html
();
3893 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
3894 -status
=> $status, -expires
=> $expires)
3895 unless ($opts{'-no_http_header'});
3896 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
3898 <?xml version="1.0" encoding="utf-8"?>
3899 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3900 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
3901 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
3902 <!-- git core binaries version $git_version -->
3904 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
3905 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
3906 <meta name="robots" content="index, nofollow"/>
3907 <title>$title</title>
3909 # the stylesheet, favicon etc urls won't work correctly with path_info
3910 # unless we set the appropriate base URL
3911 if ($ENV{'PATH_INFO'}) {
3912 print "<base href=\"".esc_url
($base_url)."\" />\n";
3914 print_header_links
($status);
3916 if (defined $site_html_head_string) {
3917 print to_utf8
($site_html_head_string);
3923 if (defined $site_header && -f
$site_header) {
3924 insert_file
($site_header);
3927 print "<div class=\"page_header\">\n";
3928 if (defined $logo) {
3929 print $cgi->a({-href
=> esc_url
($logo_url),
3930 -title
=> $logo_label},
3931 $cgi->img({-src
=> esc_url
($logo),
3932 -width
=> 72, -height
=> 27,
3934 -class => "logo"}));
3936 print_nav_breadcrumbs
(%opts);
3939 my $have_search = gitweb_check_feature
('search');
3940 if (defined $project && $have_search) {
3941 print_search_form
();
3945 sub git_footer_html
{
3946 my $feed_class = 'rss_logo';
3948 print "<div class=\"page_footer\">\n";
3949 if (defined $project) {
3950 my $descr = git_get_project_description
($project);
3951 if (defined $descr) {
3952 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3955 my %href_params = get_feed_info
();
3956 if (!%href_params) {
3957 $feed_class .= ' generic';
3959 $href_params{'-title'} ||= 'log';
3961 foreach my $format (qw(RSS Atom)) {
3962 $href_params{'action'} = lc($format);
3963 print $cgi->a({-href
=> href
(%href_params),
3964 -title
=> "$href_params{'-title'} $format feed",
3965 -class => $feed_class}, $format)."\n";
3969 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3970 -class => $feed_class}, "OPML") . " ";
3971 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3972 -class => $feed_class}, "TXT") . "\n";
3974 print "</div>\n"; # class="page_footer"
3976 if (defined $t0 && gitweb_check_feature
('timed')) {
3977 print "<div id=\"generating_info\">\n";
3978 print 'This page took '.
3979 '<span id="generating_time" class="time_span">'.
3980 tv_interval
($t0, [ gettimeofday
() ]).
3983 '<span id="generating_cmd">'.
3984 $number_of_git_cmds.
3985 '</span> git commands '.
3987 print "</div>\n"; # class="page_footer"
3990 if (defined $site_footer && -f
$site_footer) {
3991 insert_file
($site_footer);
3994 print qq!<script type
="text/javascript" src
="!.esc_url($javascript).qq!"></script
>\n!;
3995 if (defined $action &&
3996 $action eq 'blame_incremental') {
3997 print qq!<script type
="text/javascript">\n!.
3998 qq!startBlame
("!. href(action=>"blame_data
", -replay=>1) .qq!",\n!.
3999 qq! "!. href() .qq!");\n!.
4002 my ($jstimezone, $tz_cookie, $datetime_class) =
4003 gitweb_get_feature
('javascript-timezone');
4005 print qq!<script type
="text/javascript">\n!.
4006 qq!window
.onload
= function
() {\n!;
4007 if (gitweb_check_feature
('javascript-actions')) {
4008 print qq! fixLinks
();\n!;
4010 if ($jstimezone && $tz_cookie && $datetime_class) {
4011 print qq! var tz_cookie
= { name
: '$tz_cookie', expires
: 14, path
: '/' };\n!. # in days
4012 qq! onloadTZSetup
('$jstimezone', tz_cookie
, '$datetime_class');\n!;
4022 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
4023 # Example: die_error(404, 'Hash not found')
4024 # By convention, use the following status codes (as defined in RFC 2616):
4025 # 400: Invalid or missing CGI parameters, or
4026 # requested object exists but has wrong type.
4027 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
4028 # this server or project.
4029 # 404: Requested object/revision/project doesn't exist.
4030 # 500: The server isn't configured properly, or
4031 # an internal error occurred (e.g. failed assertions caused by bugs), or
4032 # an unknown error occurred (e.g. the git binary died unexpectedly).
4033 # 503: The server is currently unavailable (because it is overloaded,
4034 # or down for maintenance). Generally, this is a temporary state.
4036 my $status = shift || 500;
4037 my $error = esc_html
(shift) || "Internal Server Error";
4041 my %http_responses = (
4042 400 => '400 Bad Request',
4043 403 => '403 Forbidden',
4044 404 => '404 Not Found',
4045 500 => '500 Internal Server Error',
4046 503 => '503 Service Unavailable',
4048 git_header_html
($http_responses{$status}, undef, %opts);
4050 <div class="page_body">
4055 if (defined $extra) {
4063 unless ($opts{'-error_handler'});
4066 ## ----------------------------------------------------------------------
4067 ## functions printing or outputting HTML: navigation
4069 sub git_print_page_nav
{
4070 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
4071 $extra = '' if !defined $extra; # pager or formats
4073 my @navs = qw(summary shortlog log commit commitdiff tree);
4075 @navs = grep { $_ ne $suppress } @navs;
4078 my %arg = map { $_ => {action
=>$_} } @navs;
4079 if (defined $head) {
4080 for (qw(commit commitdiff)) {
4081 $arg{$_}{'hash'} = $head;
4083 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
4084 for (qw(shortlog log)) {
4085 $arg{$_}{'hash'} = $head;
4090 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
4091 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
4093 my @actions = gitweb_get_feature
('actions');
4096 'n' => $project, # project name
4097 'f' => $git_dir, # project path within filesystem
4098 'h' => $treehead || '', # current hash ('h' parameter)
4099 'b' => $treebase || '', # hash base ('hb' parameter)
4102 my ($label, $link, $pos) = splice(@actions,0,3);
4104 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
4106 $link =~ s/%([%nfhb])/$repl{$1}/g;
4107 $arg{$label}{'_href'} = $link;
4110 print "<div class=\"page_nav\">\n" .
4112 map { $_ eq $current ?
4113 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
4115 print "<br/>\n$extra<br/>\n" .
4119 # returns a submenu for the nagivation of the refs views (tags, heads,
4120 # remotes) with the current view disabled and the remotes view only
4121 # available if the feature is enabled
4122 sub format_ref_views
{
4124 my @ref_views = qw{tags heads
};
4125 push @ref_views, 'remotes' if gitweb_check_feature
('remote_heads');
4126 return join " | ", map {
4127 $_ eq $current ?
$_ :
4128 $cgi->a({-href
=> href
(action
=>$_)}, $_)
4132 sub format_paging_nav
{
4133 my ($action, $page, $has_next_link) = @_;
4139 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)}, "first") .
4141 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
4142 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
4144 $paging_nav .= "first ⋅ prev";
4147 if ($has_next_link) {
4148 $paging_nav .= " ⋅ " .
4149 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
4150 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
4152 $paging_nav .= " ⋅ next";
4158 ## ......................................................................
4159 ## functions printing or outputting HTML: div
4161 sub git_print_header_div
{
4162 my ($action, $title, $hash, $hash_base) = @_;
4165 $args{'action'} = $action;
4166 $args{'hash'} = $hash if $hash;
4167 $args{'hash_base'} = $hash_base if $hash_base;
4169 print "<div class=\"header\">\n" .
4170 $cgi->a({-href
=> href
(%args), -class => "title"},
4171 $title ?
$title : $action) .
4175 sub format_repo_url
{
4176 my ($name, $url) = @_;
4177 return "<tr class=\"metadata_url\"><td>$name</td><td>$url</td></tr>\n";
4180 # Group output by placing it in a DIV element and adding a header.
4181 # Options for start_div() can be provided by passing a hash reference as the
4182 # first parameter to the function.
4183 # Options to git_print_header_div() can be provided by passing an array
4184 # reference. This must follow the options to start_div if they are present.
4185 # The content can be a scalar, which is output as-is, a scalar reference, which
4186 # is output after html escaping, an IO handle passed either as *handle or
4187 # *handle{IO}, or a function reference. In the latter case all following
4188 # parameters will be taken as argument to the content function call.
4189 sub git_print_section
{
4190 my ($div_args, $header_args, $content);
4192 if (ref($arg) eq 'HASH') {
4196 if (ref($arg) eq 'ARRAY') {
4197 $header_args = $arg;
4202 print $cgi->start_div($div_args);
4203 git_print_header_div
(@
$header_args);
4205 if (ref($content) eq 'CODE') {
4207 } elsif (ref($content) eq 'SCALAR') {
4208 print esc_html
($$content);
4209 } elsif (ref($content) eq 'GLOB' or ref($content) eq 'IO::Handle') {
4211 } elsif (!ref($content) && defined($content)) {
4215 print $cgi->end_div;
4218 sub format_timestamp_html
{
4220 my $strtime = $date->{'rfc2822'};
4222 my (undef, undef, $datetime_class) =
4223 gitweb_get_feature
('javascript-timezone');
4224 if ($datetime_class) {
4225 $strtime = qq!<span
class="$datetime_class">$strtime</span
>!;
4228 my $localtime_format = '(%02d:%02d %s)';
4229 if ($date->{'hour_local'} < 6) {
4230 $localtime_format = '(<span class="atnight">%02d:%02d</span> %s)';
4233 sprintf($localtime_format,
4234 $date->{'hour_local'}, $date->{'minute_local'}, $date->{'tz_local'});
4239 # Outputs the author name and date in long form
4240 sub git_print_authorship
{
4243 my $tag = $opts{-tag
} || 'div';
4244 my $author = $co->{'author_name'};
4246 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
4247 print "<$tag class=\"author_date\">" .
4248 format_search_author
($author, "author", esc_html
($author)) .
4249 " [".format_timestamp_html
(\
%ad)."]".
4250 git_get_avatar
($co->{'author_email'}, -pad_before
=> 1) .
4254 # Outputs table rows containing the full author or committer information,
4255 # in the format expected for 'commit' view (& similar).
4256 # Parameters are a commit hash reference, followed by the list of people
4257 # to output information for. If the list is empty it defaults to both
4258 # author and committer.
4259 sub git_print_authorship_rows
{
4261 # too bad we can't use @people = @_ || ('author', 'committer')
4263 @people = ('author', 'committer') unless @people;
4264 foreach my $who (@people) {
4265 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
4266 print "<tr><td>$who</td><td>" .
4267 format_search_author
($co->{"${who}_name"}, $who,
4268 esc_html
($co->{"${who}_name"})) . " " .
4269 format_search_author
($co->{"${who}_email"}, $who,
4270 esc_html
("<" . $co->{"${who}_email"} . ">")) .
4271 "</td><td rowspan=\"2\">" .
4272 git_get_avatar
($co->{"${who}_email"}, -size
=> 'double') .
4276 format_timestamp_html
(\
%wd) .
4282 sub git_print_page_path
{
4288 print "<div class=\"page_path\">";
4289 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
4290 -title
=> 'tree root'}, to_utf8
("[$project]"));
4292 if (defined $name) {
4293 my @dirname = split '/', $name;
4294 my $basename = pop @dirname;
4297 foreach my $dir (@dirname) {
4298 $fullname .= ($fullname ?
'/' : '') . $dir;
4299 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
4301 -title
=> $fullname}, esc_path
($dir));
4304 if (defined $type && $type eq 'blob') {
4305 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
4307 -title
=> $name}, esc_path
($basename));
4308 } elsif (defined $type && $type eq 'tree') {
4309 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
4311 -title
=> $name}, esc_path
($basename));
4314 print esc_path
($basename);
4317 print "<br/></div>\n";
4324 if ($opts{'-remove_title'}) {
4325 # remove title, i.e. first line of log
4328 # remove leading empty lines
4329 while (defined $log->[0] && $log->[0] eq "") {
4336 foreach my $line (@
$log) {
4337 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
4340 if (! $opts{'-remove_signoff'}) {
4341 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
4344 # remove signoff lines
4351 # print only one empty line
4352 # do not print empty line after signoff
4354 next if ($empty || $signoff);
4360 print format_log_line_html
($line) . "<br/>\n";
4363 if ($opts{'-final_empty_line'}) {
4364 # end with single empty line
4365 print "<br/>\n" unless $empty;
4369 # return link target (what link points to)
4370 sub git_get_link_target
{
4375 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4379 $link_target = <$fd>;
4384 return $link_target;
4387 # given link target, and the directory (basedir) the link is in,
4388 # return target of link relative to top directory (top tree);
4389 # return undef if it is not possible (including absolute links).
4390 sub normalize_link_target
{
4391 my ($link_target, $basedir) = @_;
4393 # absolute symlinks (beginning with '/') cannot be normalized
4394 return if (substr($link_target, 0, 1) eq '/');
4396 # normalize link target to path from top (root) tree (dir)
4399 $path = $basedir . '/' . $link_target;
4401 # we are in top (root) tree (dir)
4402 $path = $link_target;
4405 # remove //, /./, and /../
4407 foreach my $part (split('/', $path)) {
4408 # discard '.' and ''
4409 next if (!$part || $part eq '.');
4411 if ($part eq '..') {
4415 # link leads outside repository (outside top dir)
4419 push @path_parts, $part;
4422 $path = join('/', @path_parts);
4427 # print tree entry (row of git_tree), but without encompassing <tr> element
4428 sub git_print_tree_entry
{
4429 my ($t, $basedir, $hash_base, $have_blame) = @_;
4432 $base_key{'hash_base'} = $hash_base if defined $hash_base;
4434 # The format of a table row is: mode list link. Where mode is
4435 # the mode of the entry, list is the name of the entry, an href,
4436 # and link is the action links of the entry.
4438 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
4439 if (exists $t->{'size'}) {
4440 print "<td class=\"size\">$t->{'size'}</td>\n";
4442 if ($t->{'type'} eq "blob") {
4443 print "<td class=\"list\">" .
4444 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4445 file_name
=>"$basedir$t->{'name'}", %base_key),
4446 -class => "list"}, esc_path
($t->{'name'}));
4447 if (S_ISLNK
(oct $t->{'mode'})) {
4448 my $link_target = git_get_link_target
($t->{'hash'});
4450 my $norm_target = normalize_link_target
($link_target, $basedir);
4451 if (defined $norm_target) {
4453 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
4454 file_name
=>$norm_target),
4455 -title
=> $norm_target}, esc_path
($link_target));
4457 print " -> " . esc_path
($link_target);
4462 print "<td class=\"link\">";
4463 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4464 file_name
=>"$basedir$t->{'name'}", %base_key)},
4468 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
4469 file_name
=>"$basedir$t->{'name'}", %base_key)},
4472 if (defined $hash_base) {
4474 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4475 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
4479 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
4480 file_name
=>"$basedir$t->{'name'}")},
4484 } elsif ($t->{'type'} eq "tree") {
4485 print "<td class=\"list\">";
4486 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4487 file_name
=>"$basedir$t->{'name'}",
4489 esc_path
($t->{'name'}));
4491 print "<td class=\"link\">";
4492 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4493 file_name
=>"$basedir$t->{'name'}",
4496 if (defined $hash_base) {
4498 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4499 file_name
=>"$basedir$t->{'name'}")},
4504 # unknown object: we can only present history for it
4505 # (this includes 'commit' object, i.e. submodule support)
4506 print "<td class=\"list\">" .
4507 esc_path
($t->{'name'}) .
4509 print "<td class=\"link\">";
4510 if (defined $hash_base) {
4511 print $cgi->a({-href
=> href
(action
=>"history",
4512 hash_base
=>$hash_base,
4513 file_name
=>"$basedir$t->{'name'}")},
4520 ## ......................................................................
4521 ## functions printing large fragments of HTML
4523 # get pre-image filenames for merge (combined) diff
4524 sub fill_from_file_info
{
4525 my ($diff, @parents) = @_;
4527 $diff->{'from_file'} = [ ];
4528 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4529 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4530 if ($diff->{'status'}[$i] eq 'R' ||
4531 $diff->{'status'}[$i] eq 'C') {
4532 $diff->{'from_file'}[$i] =
4533 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
4540 # is current raw difftree line of file deletion
4542 my $diffinfo = shift;
4544 return $diffinfo->{'to_id'} eq ('0' x
40);
4547 # does patch correspond to [previous] difftree raw line
4548 # $diffinfo - hashref of parsed raw diff format
4549 # $patchinfo - hashref of parsed patch diff format
4550 # (the same keys as in $diffinfo)
4551 sub is_patch_split
{
4552 my ($diffinfo, $patchinfo) = @_;
4554 return defined $diffinfo && defined $patchinfo
4555 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4559 sub git_difftree_body
{
4560 my ($difftree, $hash, @parents) = @_;
4561 my ($parent) = $parents[0];
4562 my $have_blame = gitweb_check_feature
('blame');
4563 print "<div class=\"list_head\">\n";
4564 if ($#{$difftree} > 10) {
4565 print(($#{$difftree} + 1) . " files changed:\n");
4569 print "<table class=\"" .
4570 (@parents > 1 ?
"combined " : "") .
4573 # header only for combined diff in 'commitdiff' view
4574 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
4577 print "<thead><tr>\n" .
4578 "<th></th><th></th>\n"; # filename, patchN link
4579 for (my $i = 0; $i < @parents; $i++) {
4580 my $par = $parents[$i];
4582 $cgi->a({-href
=> href
(action
=>"commitdiff",
4583 hash
=>$hash, hash_parent
=>$par),
4584 -title
=> 'commitdiff to parent number ' .
4585 ($i+1) . ': ' . substr($par,0,7)},
4589 print "</tr></thead>\n<tbody>\n";
4594 foreach my $line (@
{$difftree}) {
4595 my $diff = parsed_difftree_line
($line);
4598 print "<tr class=\"dark\">\n";
4600 print "<tr class=\"light\">\n";
4604 if (exists $diff->{'nparents'}) { # combined diff
4606 fill_from_file_info
($diff, @parents)
4607 unless exists $diff->{'from_file'};
4609 if (!is_deleted
($diff)) {
4610 # file exists in the result (child) commit
4612 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4613 file_name
=>$diff->{'to_file'},
4615 -class => "list"}, esc_path
($diff->{'to_file'})) .
4619 esc_path
($diff->{'to_file'}) .
4623 if ($action eq 'commitdiff') {
4626 print "<td class=\"link\">" .
4627 $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4633 my $has_history = 0;
4634 my $not_deleted = 0;
4635 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4636 my $hash_parent = $parents[$i];
4637 my $from_hash = $diff->{'from_id'}[$i];
4638 my $from_path = $diff->{'from_file'}[$i];
4639 my $status = $diff->{'status'}[$i];
4641 $has_history ||= ($status ne 'A');
4642 $not_deleted ||= ($status ne 'D');
4644 if ($status eq 'A') {
4645 print "<td class=\"link\" align=\"right\"> | </td>\n";
4646 } elsif ($status eq 'D') {
4647 print "<td class=\"link\">" .
4648 $cgi->a({-href
=> href
(action
=>"blob",
4651 file_name
=>$from_path)},
4655 if ($diff->{'to_id'} eq $from_hash) {
4656 print "<td class=\"link nochange\">";
4658 print "<td class=\"link\">";
4660 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4661 hash
=>$diff->{'to_id'},
4662 hash_parent
=>$from_hash,
4664 hash_parent_base
=>$hash_parent,
4665 file_name
=>$diff->{'to_file'},
4666 file_parent
=>$from_path)},
4672 print "<td class=\"link\">";
4674 print $cgi->a({-href
=> href
(action
=>"blob",
4675 hash
=>$diff->{'to_id'},
4676 file_name
=>$diff->{'to_file'},
4679 print " | " if ($has_history);
4682 print $cgi->a({-href
=> href
(action
=>"history",
4683 file_name
=>$diff->{'to_file'},
4690 next; # instead of 'else' clause, to avoid extra indent
4692 # else ordinary diff
4694 my ($to_mode_oct, $to_mode_str, $to_file_type);
4695 my ($from_mode_oct, $from_mode_str, $from_file_type);
4696 if ($diff->{'to_mode'} ne ('0' x
6)) {
4697 $to_mode_oct = oct $diff->{'to_mode'};
4698 if (S_ISREG
($to_mode_oct)) { # only for regular file
4699 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4701 $to_file_type = file_type
($diff->{'to_mode'});
4703 if ($diff->{'from_mode'} ne ('0' x
6)) {
4704 $from_mode_oct = oct $diff->{'from_mode'};
4705 if (S_ISREG
($from_mode_oct)) { # only for regular file
4706 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4708 $from_file_type = file_type
($diff->{'from_mode'});
4711 if ($diff->{'status'} eq "A") { # created
4712 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4713 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4714 $mode_chng .= "]</span>";
4716 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4717 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4718 -class => "list"}, esc_path
($diff->{'file'}));
4720 print "<td>$mode_chng</td>\n";
4721 print "<td class=\"link\">";
4722 if ($action eq 'commitdiff') {
4725 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4729 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4730 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4734 } elsif ($diff->{'status'} eq "D") { # deleted
4735 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4737 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4738 hash_base
=>$parent, file_name
=>$diff->{'file'}),
4739 -class => "list"}, esc_path
($diff->{'file'}));
4741 print "<td>$mode_chng</td>\n";
4742 print "<td class=\"link\">";
4743 if ($action eq 'commitdiff') {
4746 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4750 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4751 hash_base
=>$parent, file_name
=>$diff->{'file'})},
4754 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
4755 file_name
=>$diff->{'file'})},
4758 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
4759 file_name
=>$diff->{'file'})},
4763 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4764 my $mode_chnge = "";
4765 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4766 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4767 if ($from_file_type ne $to_file_type) {
4768 $mode_chnge .= " from $from_file_type to $to_file_type";
4770 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4771 if ($from_mode_str && $to_mode_str) {
4772 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4773 } elsif ($to_mode_str) {
4774 $mode_chnge .= " mode: $to_mode_str";
4777 $mode_chnge .= "]</span>\n";
4780 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4781 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4782 -class => "list"}, esc_path
($diff->{'file'}));
4784 print "<td>$mode_chnge</td>\n";
4785 print "<td class=\"link\">";
4786 if ($action eq 'commitdiff') {
4789 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4792 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4793 # "commit" view and modified file (not onlu mode changed)
4794 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4795 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4796 hash_base
=>$hash, hash_parent_base
=>$parent,
4797 file_name
=>$diff->{'file'})},
4801 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4802 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4805 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4806 file_name
=>$diff->{'file'})},
4809 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4810 file_name
=>$diff->{'file'})},
4814 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4815 my %status_name = ('R' => 'moved', 'C' => 'copied');
4816 my $nstatus = $status_name{$diff->{'status'}};
4818 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4819 # mode also for directories, so we cannot use $to_mode_str
4820 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4823 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
4824 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
4825 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
4826 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4827 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
4828 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
4829 -class => "list"}, esc_path
($diff->{'from_file'})) .
4830 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4831 "<td class=\"link\">";
4832 if ($action eq 'commitdiff') {
4835 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4838 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4839 # "commit" view and modified file (not only pure rename or copy)
4840 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4841 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4842 hash_base
=>$hash, hash_parent_base
=>$parent,
4843 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
4847 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4848 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
4851 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4852 file_name
=>$diff->{'to_file'})},
4855 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4856 file_name
=>$diff->{'to_file'})},
4860 } # we should not encounter Unmerged (U) or Unknown (X) status
4863 print "</tbody>" if $has_header;
4867 sub print_sidebyside_diff_chunk
{
4869 my (@ctx, @rem, @add);
4871 return unless @chunk;
4873 # incomplete last line might be among removed or added lines,
4874 # or both, or among context lines: find which
4875 for (my $i = 1; $i < @chunk; $i++) {
4876 if ($chunk[$i][0] eq 'incomplete') {
4877 $chunk[$i][0] = $chunk[$i-1][0];
4882 push @chunk, ["", ""];
4884 foreach my $line_info (@chunk) {
4885 my ($class, $line) = @
$line_info;
4887 # print chunk headers
4888 if ($class && $class eq 'chunk_header') {
4893 ## print from accumulator when type of class of lines change
4894 # empty contents block on start rem/add block, or end of chunk
4895 if (@ctx && (!$class || $class eq 'rem' || $class eq 'add')) {
4897 '<div class="chunk_block ctx">',
4898 '<div class="old">',
4901 '<div class="new">',
4907 # empty add/rem block on start context block, or end of chunk
4908 if ((@rem || @add) && (!$class || $class eq 'ctx')) {
4912 '<div class="chunk_block rem">',
4913 '<div class="old">',
4920 '<div class="chunk_block add">',
4921 '<div class="new">',
4926 # assume that it is change
4928 '<div class="chunk_block chg">',
4929 '<div class="old">',
4932 '<div class="new">',
4940 ## adding lines to accumulator
4943 # rem, add or change
4944 if ($class eq 'rem') {
4946 } elsif ($class eq 'add') {
4950 if ($class eq 'ctx') {
4956 sub git_patchset_body
{
4957 my ($fd, $diff_style, $difftree, $hash, @hash_parents) = @_;
4958 my ($hash_parent) = $hash_parents[0];
4960 my $is_combined = (@hash_parents > 1);
4962 my $patch_number = 0;
4967 my @chunk; # for side-by-side diff
4969 print "<div class=\"patchset\">\n";
4971 # skip to first patch
4972 while ($patch_line = <$fd>) {
4975 last if ($patch_line =~ m/^diff /);
4979 while ($patch_line) {
4981 # parse "git diff" header line
4982 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
4983 # $1 is from_name, which we do not use
4984 $to_name = unquote
($2);
4985 $to_name =~ s!^b/!!;
4986 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
4987 # $1 is 'cc' or 'combined', which we do not use
4988 $to_name = unquote
($2);
4993 # check if current patch belong to current raw line
4994 # and parse raw git-diff line if needed
4995 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
4996 # this is continuation of a split patch
4997 print "<div class=\"patch cont\">\n";
4999 # advance raw git-diff output if needed
5000 $patch_idx++ if defined $diffinfo;
5002 # read and prepare patch information
5003 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5005 # compact combined diff output can have some patches skipped
5006 # find which patch (using pathname of result) we are at now;
5008 while ($to_name ne $diffinfo->{'to_file'}) {
5009 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5010 format_diff_cc_simplified
($diffinfo, @hash_parents) .
5011 "</div>\n"; # class="patch"
5016 last if $patch_idx > $#$difftree;
5017 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5021 # modifies %from, %to hashes
5022 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
5024 # this is first patch for raw difftree line with $patch_idx index
5025 # we index @$difftree array from 0, but number patches from 1
5026 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
5030 #assert($patch_line =~ m/^diff /) if DEBUG;
5031 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
5033 # print "git diff" header
5034 print format_git_diff_header_line
($patch_line, $diffinfo,
5037 # print extended diff header
5038 print "<div class=\"diff extended_header\">\n";
5040 while ($patch_line = <$fd>) {
5043 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
5045 print format_extended_diff_header_line
($patch_line, $diffinfo,
5048 print "</div>\n"; # class="diff extended_header"
5050 # from-file/to-file diff header
5051 if (! $patch_line) {
5052 print "</div>\n"; # class="patch"
5055 next PATCH
if ($patch_line =~ m/^diff /);
5056 #assert($patch_line =~ m/^---/) if DEBUG;
5058 my $last_patch_line = $patch_line;
5059 $patch_line = <$fd>;
5061 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
5063 print format_diff_from_to_header
($last_patch_line, $patch_line,
5064 $diffinfo, \
%from, \
%to,
5069 while ($patch_line = <$fd>) {
5072 next PATCH
if ($patch_line =~ m/^diff /);
5074 my ($class, $line) = process_diff_line
($patch_line, \
%from, \
%to);
5075 my $diff_classes = "diff";
5076 $diff_classes .= " $class" if ($class);
5077 $line = "<div class=\"$diff_classes\">$line</div>\n";
5079 if ($diff_style eq 'sidebyside' && !$is_combined) {
5080 if ($class eq 'chunk_header') {
5081 print_sidebyside_diff_chunk
(@chunk);
5082 @chunk = ( [ $class, $line ] );
5084 push @chunk, [ $class, $line ];
5087 # default 'inline' style and unknown styles
5094 print_sidebyside_diff_chunk
(@chunk);
5097 print "</div>\n"; # class="patch"
5100 # for compact combined (--cc) format, with chunk and patch simplification
5101 # the patchset might be empty, but there might be unprocessed raw lines
5102 for (++$patch_idx if $patch_number > 0;
5103 $patch_idx < @
$difftree;
5105 # read and prepare patch information
5106 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5108 # generate anchor for "patch" links in difftree / whatchanged part
5109 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5110 format_diff_cc_simplified
($diffinfo, @hash_parents) .
5111 "</div>\n"; # class="patch"
5116 if ($patch_number == 0) {
5117 if (@hash_parents > 1) {
5118 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
5120 print "<div class=\"diff nodifferences\">No differences found</div>\n";
5124 print "</div>\n"; # class="patchset"
5127 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5129 # fills project list info (age, description, owner, category, forks)
5130 # for each project in the list, removing invalid projects from
5132 # NOTE: modifies $projlist, but does not remove entries from it
5133 sub fill_project_list_info
{
5134 my $projlist = shift;
5137 my $show_ctags = gitweb_check_feature
('ctags');
5139 foreach my $pr (@
$projlist) {
5140 my (@activity) = git_get_last_activity
($pr->{'path'});
5141 unless (@activity) {
5144 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
5145 if (!defined $pr->{'descr'}) {
5146 my $descr = git_get_project_description
($pr->{'path'}) || "";
5147 $descr = to_utf8
($descr);
5148 $pr->{'descr_long'} = $descr;
5149 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
5151 if (!defined $pr->{'owner'}) {
5152 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
5155 $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
5157 if ($projects_list_group_categories && !defined $pr->{'category'}) {
5158 my $cat = git_get_project_category
($pr->{'path'}) ||
5159 $project_list_default_category;
5160 $pr->{'category'} = to_utf8
($cat);
5163 push @projects, $pr;
5169 sub sort_projects_list
{
5170 my ($projlist, $order) = @_;
5174 project
=> { key
=> 'path', type
=> 'str' },
5175 descr
=> { key
=> 'descr_long', type
=> 'str' },
5176 owner
=> { key
=> 'owner', type
=> 'str' },
5177 age
=> { key
=> 'age', type
=> 'num' }
5179 my $oi = $order_info{$order};
5180 return @
$projlist unless defined $oi;
5181 if ($oi->{'type'} eq 'str') {
5182 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @
$projlist;
5184 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @
$projlist;
5190 # returns a hash of categories, containing the list of project
5191 # belonging to each category
5192 sub build_projlist_by_category
{
5193 my ($projlist, $from, $to) = @_;
5196 $from = 0 unless defined $from;
5197 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5199 for (my $i = $from; $i <= $to; $i++) {
5200 my $pr = $projlist->[$i];
5201 push @
{$categories{ $pr->{'category'} }}, $pr;
5204 return wantarray ?
%categories : \
%categories;
5207 # print 'sort by' <th> element, generating 'sort by $name' replay link
5208 # if that order is not selected
5210 print format_sort_th
(@_);
5213 sub format_sort_th
{
5214 my ($name, $order, $header) = @_;
5216 $header ||= ucfirst($name);
5218 if ($order eq $name) {
5219 $sort_th .= "<th>$header</th>\n";
5221 $sort_th .= "<th>" .
5222 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
5223 -class => "header"}, $header) .
5230 sub git_project_list_rows
{
5231 my ($projlist, $from, $to, $check_forks) = @_;
5233 $from = 0 unless defined $from;
5234 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5237 for (my $i = $from; $i <= $to; $i++) {
5238 my $pr = $projlist->[$i];
5241 print "<tr class=\"dark\">\n";
5243 print "<tr class=\"light\">\n";
5249 if ($pr->{'forks'}) {
5250 my $nforks = scalar @
{$pr->{'forks'}};
5252 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks"),
5253 -title
=> "$nforks forks"}, "+");
5255 print $cgi->span({-title
=> "$nforks forks"}, "+");
5260 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5261 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
5262 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5263 -class => "list", -title
=> $pr->{'descr_long'}},
5264 esc_html
($pr->{'descr'})) . "</td>\n" .
5265 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
5266 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
5267 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
5268 "<td class=\"link\">" .
5269 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
5270 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
5271 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
5272 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
5273 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
5279 sub git_project_list_body
{
5280 # actually uses global variable $project
5281 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
5282 my @projects = @
$projlist;
5284 my $check_forks = gitweb_check_feature
('forks');
5285 my $show_ctags = gitweb_check_feature
('ctags');
5286 my $tagfilter = $show_ctags ?
$cgi->param('by_tag') : undef;
5287 $check_forks = undef
5288 if ($tagfilter || $searchtext);
5290 # filtering out forks before filling info allows to do less work
5291 @projects = filter_forks_from_projects_list
(\
@projects)
5293 @projects = fill_project_list_info
(\
@projects);
5294 # searching projects require filling to be run before it
5295 @projects = search_projects_list
(\
@projects,
5296 'searchtext' => $searchtext,
5297 'tagfilter' => $tagfilter)
5298 if ($tagfilter || $searchtext);
5300 $order ||= $default_projects_order;
5301 $from = 0 unless defined $from;
5302 $to = $#projects if (!defined $to || $#projects < $to);
5307 "<b>No such projects found</b><br />\n".
5308 "Click ".$cgi->a({-href
=>href
(project
=>undef)},"here")." to view all projects<br />\n".
5309 "</center>\n<br />\n";
5313 @projects = sort_projects_list
(\
@projects, $order);
5316 my $ctags = git_gather_all_ctags
(\
@projects);
5317 my $cloud = git_populate_project_tagcloud
($ctags);
5318 print git_show_project_tagcloud
($cloud, 64);
5321 print "<table class=\"project_list\">\n";
5322 unless ($no_header) {
5325 print "<th></th>\n";
5327 print_sort_th
('project', $order, 'Project');
5328 print_sort_th
('descr', $order, 'Description');
5329 print_sort_th
('owner', $order, 'Owner');
5330 print_sort_th
('age', $order, 'Last Change');
5331 print "<th></th>\n" . # for links
5335 if ($projects_list_group_categories) {
5336 # only display categories with projects in the $from-$to window
5337 @projects = sort {$a->{'category'} cmp $b->{'category'}} @projects[$from..$to];
5338 my %categories = build_projlist_by_category
(\
@projects, $from, $to);
5339 foreach my $cat (sort keys %categories) {
5340 unless ($cat eq "") {
5343 print "<td></td>\n";
5345 print "<td class=\"category\" colspan=\"5\">".esc_html
($cat)."</td>\n";
5349 git_project_list_rows
($categories{$cat}, undef, undef, $check_forks);
5352 git_project_list_rows
(\
@projects, $from, $to, $check_forks);
5355 if (defined $extra) {
5358 print "<td></td>\n";
5360 print "<td colspan=\"5\">$extra</td>\n" .
5367 # uses global variable $project
5368 my ($commitlist, $from, $to, $refs, $extra) = @_;
5370 $from = 0 unless defined $from;
5371 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5373 for (my $i = 0; $i <= $to; $i++) {
5374 my %co = %{$commitlist->[$i]};
5376 my $commit = $co{'id'};
5377 my $ref = format_ref_marker
($refs, $commit);
5378 git_print_header_div
('commit',
5379 "<span class=\"age\">$co{'age_string'}</span>" .
5380 esc_html
($co{'title'}) . $ref,
5382 print "<div class=\"title_text\">\n" .
5383 "<div class=\"log_link\">\n" .
5384 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
5386 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
5388 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
5391 git_print_authorship
(\
%co, -tag
=> 'span');
5392 print "<br/>\n</div>\n";
5394 print "<div class=\"log_body\">\n";
5395 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
5399 print "<div class=\"page_nav\">\n";
5405 sub git_shortlog_body
{
5406 # uses global variable $project
5407 my ($commitlist, $from, $to, $refs, $extra) = @_;
5409 $from = 0 unless defined $from;
5410 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5412 print "<table class=\"shortlog\">\n";
5414 for (my $i = $from; $i <= $to; $i++) {
5415 my %co = %{$commitlist->[$i]};
5416 my $commit = $co{'id'};
5417 my $ref = format_ref_marker
($refs, $commit);
5419 print "<tr class=\"dark\">\n";
5421 print "<tr class=\"light\">\n";
5424 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
5425 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5426 format_author_html
('td', \
%co, 10) . "<td>";
5427 print format_subject_html
($co{'title'}, $co{'title_short'},
5428 href
(action
=>"commit", hash
=>$commit), $ref);
5430 "<td class=\"link\">" .
5431 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
5432 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
5433 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
5434 my $snapshot_links = format_snapshot_links
($commit);
5435 if (defined $snapshot_links) {
5436 print " | " . $snapshot_links;
5441 if (defined $extra) {
5443 "<td colspan=\"4\">$extra</td>\n" .
5449 sub git_history_body
{
5450 # Warning: assumes constant type (blob or tree) during history
5451 my ($commitlist, $from, $to, $refs, $extra,
5452 $file_name, $file_hash, $ftype) = @_;
5454 $from = 0 unless defined $from;
5455 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
5457 print "<table class=\"history\">\n";
5459 for (my $i = $from; $i <= $to; $i++) {
5460 my %co = %{$commitlist->[$i]};
5464 my $commit = $co{'id'};
5466 my $ref = format_ref_marker
($refs, $commit);
5469 print "<tr class=\"dark\">\n";
5471 print "<tr class=\"light\">\n";
5474 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5475 # shortlog: format_author_html('td', \%co, 10)
5476 format_author_html
('td', \
%co, 15, 3) . "<td>";
5477 # originally git_history used chop_str($co{'title'}, 50)
5478 print format_subject_html
($co{'title'}, $co{'title_short'},
5479 href
(action
=>"commit", hash
=>$commit), $ref);
5481 "<td class=\"link\">" .
5482 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
5483 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
5485 if ($ftype eq 'blob') {
5486 my $blob_current = $file_hash;
5487 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
5488 if (defined $blob_current && defined $blob_parent &&
5489 $blob_current ne $blob_parent) {
5491 $cgi->a({-href
=> href
(action
=>"blobdiff",
5492 hash
=>$blob_current, hash_parent
=>$blob_parent,
5493 hash_base
=>$hash_base, hash_parent_base
=>$commit,
5494 file_name
=>$file_name)},
5501 if (defined $extra) {
5503 "<td colspan=\"4\">$extra</td>\n" .
5510 # uses global variable $project
5511 my ($taglist, $from, $to, $extra) = @_;
5512 $from = 0 unless defined $from;
5513 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
5515 print "<table class=\"tags\">\n";
5517 for (my $i = $from; $i <= $to; $i++) {
5518 my $entry = $taglist->[$i];
5520 my $comment = $tag{'subject'};
5522 if (defined $comment) {
5523 $comment_short = chop_str
($comment, 30, 5);
5526 print "<tr class=\"dark\">\n";
5528 print "<tr class=\"light\">\n";
5531 if (defined $tag{'age'}) {
5532 print "<td><i>$tag{'age'}</i></td>\n";
5534 print "<td></td>\n";
5537 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
5538 -class => "list name"}, esc_html
($tag{'name'})) .
5541 if (defined $comment) {
5542 print format_subject_html
($comment, $comment_short,
5543 href
(action
=>"tag", hash
=>$tag{'id'}));
5546 "<td class=\"selflink\">";
5547 if ($tag{'type'} eq "tag") {
5548 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
5553 "<td class=\"link\">" . " | " .
5554 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
5555 if ($tag{'reftype'} eq "commit") {
5556 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
5557 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
5558 } elsif ($tag{'reftype'} eq "blob") {
5559 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
5564 if (defined $extra) {
5566 "<td colspan=\"5\">$extra</td>\n" .
5572 sub git_heads_body
{
5573 # uses global variable $project
5574 my ($headlist, $head, $from, $to, $extra) = @_;
5575 $from = 0 unless defined $from;
5576 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
5578 print "<table class=\"heads\">\n";
5580 for (my $i = $from; $i <= $to; $i++) {
5581 my $entry = $headlist->[$i];
5583 my $curr = $ref{'id'} eq $head;
5585 print "<tr class=\"dark\">\n";
5587 print "<tr class=\"light\">\n";
5590 print "<td><i>$ref{'age'}</i></td>\n" .
5591 ($curr ?
"<td class=\"current_head\">" : "<td>") .
5592 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
5593 -class => "list name"},esc_html
($ref{'name'})) .
5595 "<td class=\"link\">" .
5596 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
5597 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
5598 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'fullname'})}, "tree") .
5602 if (defined $extra) {
5604 "<td colspan=\"3\">$extra</td>\n" .
5610 # Display a single remote block
5611 sub git_remote_block
{
5612 my ($remote, $rdata, $limit, $head) = @_;
5614 my $heads = $rdata->{'heads'};
5615 my $fetch = $rdata->{'fetch'};
5616 my $push = $rdata->{'push'};
5618 my $urls_table = "<table class=\"projects_list\">\n" ;
5620 if (defined $fetch) {
5621 if ($fetch eq $push) {
5622 $urls_table .= format_repo_url
("URL", $fetch);
5624 $urls_table .= format_repo_url
("Fetch URL", $fetch);
5625 $urls_table .= format_repo_url
("Push URL", $push) if defined $push;
5627 } elsif (defined $push) {
5628 $urls_table .= format_repo_url
("Push URL", $push);
5630 $urls_table .= format_repo_url
("", "No remote URL");
5633 $urls_table .= "</table>\n";
5636 if (defined $limit && $limit < @
$heads) {
5637 $dots = $cgi->a({-href
=> href
(action
=>"remotes", hash
=>$remote)}, "...");
5641 git_heads_body
($heads, $head, 0, $limit, $dots);
5644 # Display a list of remote names with the respective fetch and push URLs
5645 sub git_remotes_list
{
5646 my ($remotedata, $limit) = @_;
5647 print "<table class=\"heads\">\n";
5649 my @remotes = sort keys %$remotedata;
5651 my $limited = $limit && $limit < @remotes;
5653 $#remotes = $limit - 1 if $limited;
5655 while (my $remote = shift @remotes) {
5656 my $rdata = $remotedata->{$remote};
5657 my $fetch = $rdata->{'fetch'};
5658 my $push = $rdata->{'push'};
5660 print "<tr class=\"dark\">\n";
5662 print "<tr class=\"light\">\n";
5666 $cgi->a({-href
=> href
(action
=>'remotes', hash
=>$remote),
5667 -class=> "list name"},esc_html
($remote)) .
5669 print "<td class=\"link\">" .
5670 (defined $fetch ?
$cgi->a({-href
=> $fetch}, "fetch") : "fetch") .
5672 (defined $push ?
$cgi->a({-href
=> $push}, "push") : "push") .
5680 "<td colspan=\"3\">" .
5681 $cgi->a({-href
=> href
(action
=>"remotes")}, "...") .
5682 "</td>\n" . "</tr>\n";
5688 # Display remote heads grouped by remote, unless there are too many
5689 # remotes, in which case we only display the remote names
5690 sub git_remotes_body
{
5691 my ($remotedata, $limit, $head) = @_;
5692 if ($limit and $limit < keys %$remotedata) {
5693 git_remotes_list
($remotedata, $limit);
5695 fill_remote_heads
($remotedata);
5696 while (my ($remote, $rdata) = each %$remotedata) {
5697 git_print_section
({-class=>"remote", -id
=>$remote},
5698 ["remotes", $remote, $remote], sub {
5699 git_remote_block
($remote, $rdata, $limit, $head);
5705 sub git_search_message
{
5709 if ($searchtype eq 'commit') {
5710 $greptype = "--grep=";
5711 } elsif ($searchtype eq 'author') {
5712 $greptype = "--author=";
5713 } elsif ($searchtype eq 'committer') {
5714 $greptype = "--committer=";
5716 $greptype .= $searchtext;
5717 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5718 $greptype, '--regexp-ignore-case',
5719 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5721 my $paging_nav = '';
5724 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)},
5727 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5728 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5730 $paging_nav .= "first ⋅ prev";
5733 if ($#commitlist >= 100) {
5735 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5736 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5737 $paging_nav .= " ⋅ $next_link";
5739 $paging_nav .= " ⋅ next";
5744 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5745 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5746 if ($page == 0 && !@commitlist) {
5747 print "<p>No match.</p>\n";
5749 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5755 sub git_search_changes
{
5759 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5760 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5761 ($search_use_regexp ?
'--pickaxe-regex' : ())
5762 or die_error
(500, "Open git-log failed");
5766 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5767 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5769 print "<table class=\"pickaxe search\">\n";
5773 while (my $line = <$fd>) {
5777 my %set = parse_difftree_raw_line
($line);
5778 if (defined $set{'commit'}) {
5779 # finish previous commit
5782 "<td class=\"link\">" .
5783 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5786 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5787 hash_base
=>$co{'id'})},
5794 print "<tr class=\"dark\">\n";
5796 print "<tr class=\"light\">\n";
5799 %co = parse_commit
($set{'commit'});
5800 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5801 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5802 "<td><i>$author</i></td>\n" .
5804 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5805 -class => "list subject"},
5806 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5807 } elsif (defined $set{'to_id'}) {
5808 next if ($set{'to_id'} =~ m/^0{40}$/);
5810 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5811 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5813 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5819 # finish last commit (warning: repetition!)
5822 "<td class=\"link\">" .
5823 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5826 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5827 hash_base
=>$co{'id'})},
5838 sub git_search_files
{
5842 open my $fd, "-|", git_cmd
(), 'grep', '-n', '-z',
5843 $search_use_regexp ?
('-E', '-i') : '-F',
5844 $searchtext, $co{'tree'}
5845 or die_error
(500, "Open git-grep failed");
5849 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5850 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5852 print "<table class=\"grep_search\">\n";
5856 while (my $line = <$fd>) {
5858 my ($file, $file_href, $lno, $ltext, $binary);
5859 last if ($matches++ > 1000);
5860 if ($line =~ /^Binary file (.+) matches$/) {
5864 ($file, $lno, $ltext) = split(/\0/, $line, 3);
5865 $file =~ s/^$co{'tree'}://;
5867 if ($file ne $lastfile) {
5868 $lastfile and print "</td></tr>\n";
5870 print "<tr class=\"dark\">\n";
5872 print "<tr class=\"light\">\n";
5874 $file_href = href
(action
=>"blob", hash_base
=>$co{'id'},
5876 print "<td class=\"list\">".
5877 $cgi->a({-href
=> $file_href, -class => "list"}, esc_path
($file));
5878 print "</td><td>\n";
5882 print "<div class=\"binary\">Binary file</div>\n";
5884 $ltext = untabify
($ltext);
5885 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5886 $ltext = esc_html
($1, -nbsp
=>1);
5887 $ltext .= '<span class="match">';
5888 $ltext .= esc_html
($2, -nbsp
=>1);
5889 $ltext .= '</span>';
5890 $ltext .= esc_html
($3, -nbsp
=>1);
5892 $ltext = esc_html
($ltext, -nbsp
=>1);
5894 print "<div class=\"pre\">" .
5895 $cgi->a({-href
=> $file_href.'#l'.$lno,
5896 -class => "linenr"}, sprintf('%4i', $lno)) .
5897 ' ' . $ltext . "</div>\n";
5901 print "</td></tr>\n";
5902 if ($matches > 1000) {
5903 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5906 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5915 sub git_search_grep_body
{
5916 my ($commitlist, $from, $to, $extra) = @_;
5917 $from = 0 unless defined $from;
5918 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5920 print "<table class=\"commit_search\">\n";
5922 for (my $i = $from; $i <= $to; $i++) {
5923 my %co = %{$commitlist->[$i]};
5927 my $commit = $co{'id'};
5929 print "<tr class=\"dark\">\n";
5931 print "<tr class=\"light\">\n";
5934 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5935 format_author_html
('td', \
%co, 15, 5) .
5937 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5938 -class => "list subject"},
5939 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5940 my $comment = $co{'comment'};
5941 foreach my $line (@
$comment) {
5942 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5943 my ($lead, $match, $trail) = ($1, $2, $3);
5944 $match = chop_str
($match, 70, 5, 'center');
5945 my $contextlen = int((80 - length($match))/2);
5946 $contextlen = 30 if ($contextlen > 30);
5947 $lead = chop_str
($lead, $contextlen, 10, 'left');
5948 $trail = chop_str
($trail, $contextlen, 10, 'right');
5950 $lead = esc_html
($lead);
5951 $match = esc_html
($match);
5952 $trail = esc_html
($trail);
5954 print "$lead<span class=\"match\">$match</span>$trail<br />";
5958 "<td class=\"link\">" .
5959 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5961 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
5963 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5967 if (defined $extra) {
5969 "<td colspan=\"3\">$extra</td>\n" .
5975 ## ======================================================================
5976 ## ======================================================================
5979 sub git_project_list
{
5980 my $order = $input_params{'order'};
5981 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5982 die_error
(400, "Unknown order parameter");
5985 my @list = git_get_projects_list
();
5987 die_error
(404, "No projects found");
5991 if (defined $home_text && -f
$home_text) {
5992 print "<div class=\"index_include\">\n";
5993 insert_file
($home_text);
5996 print $cgi->startform(-method
=> "get") .
5997 "<p class=\"projsearch\">Search:\n" .
5998 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
6000 $cgi->end_form() . "\n";
6001 git_project_list_body
(\
@list, $order);
6006 my $order = $input_params{'order'};
6007 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
6008 die_error
(400, "Unknown order parameter");
6011 my $filter = $project;
6012 $filter =~ s/\.git$//;
6013 my @list = git_get_projects_list
($filter);
6015 die_error
(404, "No forks found");
6019 git_print_page_nav
('','');
6020 git_print_header_div
('summary', "$project forks");
6021 git_project_list_body
(\
@list, $order);
6025 sub git_project_index
{
6026 my @projects = git_get_projects_list
();
6028 die_error
(404, "No projects found");
6032 -type
=> 'text/plain',
6033 -charset
=> 'utf-8',
6034 -content_disposition
=> 'inline; filename="index.aux"');
6036 foreach my $pr (@projects) {
6037 if (!exists $pr->{'owner'}) {
6038 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
6041 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
6042 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
6043 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
6044 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
6048 print "$path $owner\n";
6053 my $descr = git_get_project_description
($project) || "none";
6054 my %co = parse_commit
("HEAD");
6055 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
6056 my $head = $co{'id'};
6057 my $remote_heads = gitweb_check_feature
('remote_heads');
6059 my $owner = git_get_project_owner
($project);
6061 my $refs = git_get_references
();
6062 # These get_*_list functions return one more to allow us to see if
6063 # there are more ...
6064 my @taglist = git_get_tags_list
(16);
6065 my @headlist = git_get_heads_list
(16);
6066 my %remotedata = $remote_heads ? git_get_remotes_list
() : ();
6068 my $check_forks = gitweb_check_feature
('forks');
6071 # find forks of a project
6072 my $filter = $project;
6073 $filter =~ s/\.git$//;
6074 @forklist = git_get_projects_list
($filter);
6075 # filter out forks of forks
6076 @forklist = filter_forks_from_projects_list
(\
@forklist)
6081 git_print_page_nav
('summary','', $head);
6083 print "<div class=\"title\"> </div>\n";
6084 print "<table class=\"projects_list\">\n" .
6085 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
6086 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
6087 if (defined $cd{'rfc2822'}) {
6088 print "<tr id=\"metadata_lchange\"><td>last change</td>" .
6089 "<td>".format_timestamp_html
(\
%cd)."</td></tr>\n";
6092 # use per project git URL list in $projectroot/$project/cloneurl
6093 # or make project git URL from git base URL and project name
6094 my $url_tag = "URL";
6095 my @url_list = git_get_project_url_list
($project);
6096 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
6097 foreach my $git_url (@url_list) {
6098 next unless $git_url;
6099 print format_repo_url
($url_tag, $git_url);
6104 my $show_ctags = gitweb_check_feature
('ctags');
6106 my $ctags = git_get_project_ctags
($project);
6108 # without ability to add tags, don't show if there are none
6109 my $cloud = git_populate_project_tagcloud
($ctags);
6110 print "<tr id=\"metadata_ctags\">" .
6111 "<td>content tags</td>" .
6112 "<td>".git_show_project_tagcloud
($cloud, 48)."</td>" .
6119 # If XSS prevention is on, we don't include README.html.
6120 # TODO: Allow a readme in some safe format.
6121 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
6122 print "<div class=\"title\">readme</div>\n" .
6123 "<div class=\"readme\">\n";
6124 insert_file
("$projectroot/$project/README.html");
6125 print "\n</div>\n"; # class="readme"
6128 # we need to request one more than 16 (0..15) to check if
6130 my @commitlist = $head ? parse_commits
($head, 17) : ();
6132 git_print_header_div
('shortlog');
6133 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
6134 $#commitlist <= 15 ?
undef :
6135 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
6139 git_print_header_div
('tags');
6140 git_tags_body
(\
@taglist, 0, 15,
6141 $#taglist <= 15 ?
undef :
6142 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
6146 git_print_header_div
('heads');
6147 git_heads_body
(\
@headlist, $head, 0, 15,
6148 $#headlist <= 15 ?
undef :
6149 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
6153 git_print_header_div
('remotes');
6154 git_remotes_body
(\
%remotedata, 15, $head);
6158 git_print_header_div
('forks');
6159 git_project_list_body
(\
@forklist, 'age', 0, 15,
6160 $#forklist <= 15 ?
undef :
6161 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
6169 my %tag = parse_tag
($hash);
6172 die_error
(404, "Unknown tag object");
6175 my $head = git_get_head_hash
($project);
6177 git_print_page_nav
('','', $head,undef,$head);
6178 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
6179 print "<div class=\"title_text\">\n" .
6180 "<table class=\"object_header\">\n" .
6182 "<td>object</td>\n" .
6183 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6184 $tag{'object'}) . "</td>\n" .
6185 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6186 $tag{'type'}) . "</td>\n" .
6188 if (defined($tag{'author'})) {
6189 git_print_authorship_rows
(\
%tag, 'author');
6191 print "</table>\n\n" .
6193 print "<div class=\"page_body\">";
6194 my $comment = $tag{'comment'};
6195 foreach my $line (@
$comment) {
6197 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
6203 sub git_blame_common
{
6204 my $format = shift || 'porcelain';
6205 if ($format eq 'porcelain' && $cgi->param('js')) {
6206 $format = 'incremental';
6207 $action = 'blame_incremental'; # for page title etc
6211 gitweb_check_feature
('blame')
6212 or die_error
(403, "Blame view not allowed");
6215 die_error
(400, "No file name given") unless $file_name;
6216 $hash_base ||= git_get_head_hash
($project);
6217 die_error
(404, "Couldn't find base commit") unless $hash_base;
6218 my %co = parse_commit
($hash_base)
6219 or die_error
(404, "Commit not found");
6221 if (!defined $hash) {
6222 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
6223 or die_error
(404, "Error looking up file");
6225 $ftype = git_get_type
($hash);
6226 if ($ftype !~ "blob") {
6227 die_error
(400, "Object is not a blob");
6232 if ($format eq 'incremental') {
6233 # get file contents (as base)
6234 open $fd, "-|", git_cmd
(), 'cat-file', 'blob', $hash
6235 or die_error
(500, "Open git-cat-file failed");
6236 } elsif ($format eq 'data') {
6237 # run git-blame --incremental
6238 open $fd, "-|", git_cmd
(), "blame", "--incremental",
6239 $hash_base, "--", $file_name
6240 or die_error
(500, "Open git-blame --incremental failed");
6242 # run git-blame --porcelain
6243 open $fd, "-|", git_cmd
(), "blame", '-p',
6244 $hash_base, '--', $file_name
6245 or die_error
(500, "Open git-blame --porcelain failed");
6248 # incremental blame data returns early
6249 if ($format eq 'data') {
6251 -type
=>"text/plain", -charset
=> "utf-8",
6252 -status
=> "200 OK");
6253 local $| = 1; # output autoflush
6254 while (my $line = <$fd>) {
6255 print to_utf8
($line);
6258 or print "ERROR $!\n";
6261 if (defined $t0 && gitweb_check_feature
('timed')) {
6263 tv_interval
($t0, [ gettimeofday
() ]).
6264 ' '.$number_of_git_cmds;
6274 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
6277 if ($format eq 'incremental') {
6279 $cgi->a({-href
=> href
(action
=>"blame", javascript
=>0, -replay
=>1)},
6280 "blame") . " (non-incremental)";
6283 $cgi->a({-href
=> href
(action
=>"blame_incremental", -replay
=>1)},
6284 "blame") . " (incremental)";
6288 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6291 $cgi->a({-href
=> href
(action
=>$action, file_name
=>$file_name)},
6293 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6294 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6295 git_print_page_path
($file_name, $ftype, $hash_base);
6298 if ($format eq 'incremental') {
6299 print "<noscript>\n<div class=\"error\"><center><b>\n".
6300 "This page requires JavaScript to run.\n Use ".
6301 $cgi->a({-href
=> href
(action
=>'blame',javascript
=>0,-replay
=>1)},
6304 "</b></center></div>\n</noscript>\n";
6306 print qq!<div id
="progress_bar" style
="width: 100%; background-color: yellow"></div
>\n!;
6309 print qq!<div
class="page_body">\n!;
6310 print qq!<div id
="progress_info">... / ...</div
>\n!
6311 if ($format eq 'incremental');
6312 print qq!<table id
="blame_table" class="blame" width
="100%">\n!.
6313 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
6315 qq!<tr
><th
>Commit
</th><th>Line</th
><th
>Data
</th></tr
>\n!.
6319 my @rev_color = qw(light dark);
6320 my $num_colors = scalar(@rev_color);
6321 my $current_color = 0;
6323 if ($format eq 'incremental') {
6324 my $color_class = $rev_color[$current_color];
6329 while (my $line = <$fd>) {
6333 print qq!<tr id
="l$linenr" class="$color_class">!.
6334 qq!<td
class="sha1"><a href
=""> </a></td
>!.
6335 qq!<td
class="linenr">!.
6336 qq!<a
class="linenr" href
="">$linenr</a></td
>!;
6337 print qq!<td
class="pre">! . esc_html
($line) . "</td>\n";
6341 } else { # porcelain, i.e. ordinary blame
6342 my %metainfo = (); # saves information about commits
6346 while (my $line = <$fd>) {
6348 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
6349 # no <lines in group> for subsequent lines in group of lines
6350 my ($full_rev, $orig_lineno, $lineno, $group_size) =
6351 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
6352 if (!exists $metainfo{$full_rev}) {
6353 $metainfo{$full_rev} = { 'nprevious' => 0 };
6355 my $meta = $metainfo{$full_rev};
6357 while ($data = <$fd>) {
6359 last if ($data =~ s/^\t//); # contents of line
6360 if ($data =~ /^(\S+)(?: (.*))?$/) {
6361 $meta->{$1} = $2 unless exists $meta->{$1};
6363 if ($data =~ /^previous /) {
6364 $meta->{'nprevious'}++;
6367 my $short_rev = substr($full_rev, 0, 8);
6368 my $author = $meta->{'author'};
6370 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
6371 my $date = $date{'iso-tz'};
6373 $current_color = ($current_color + 1) % $num_colors;
6375 my $tr_class = $rev_color[$current_color];
6376 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
6377 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
6378 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
6379 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
6381 print "<td class=\"sha1\"";
6382 print " title=\"". esc_html
($author) . ", $date\"";
6383 print " rowspan=\"$group_size\"" if ($group_size > 1);
6385 print $cgi->a({-href
=> href
(action
=>"commit",
6387 file_name
=>$file_name)},
6388 esc_html
($short_rev));
6389 if ($group_size >= 2) {
6390 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
6391 if (@author_initials) {
6393 esc_html
(join('', @author_initials));
6399 # 'previous' <sha1 of parent commit> <filename at commit>
6400 if (exists $meta->{'previous'} &&
6401 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
6402 $meta->{'parent'} = $1;
6403 $meta->{'file_parent'} = unquote
($2);
6406 exists($meta->{'parent'}) ?
6407 $meta->{'parent'} : $full_rev;
6408 my $linenr_filename =
6409 exists($meta->{'file_parent'}) ?
6410 $meta->{'file_parent'} : unquote
($meta->{'filename'});
6411 my $blamed = href
(action
=> 'blame',
6412 file_name
=> $linenr_filename,
6413 hash_base
=> $linenr_commit);
6414 print "<td class=\"linenr\">";
6415 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
6416 -class => "linenr" },
6419 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
6427 "</table>\n"; # class="blame"
6428 print "</div>\n"; # class="blame_body"
6430 or print "Reading blob failed\n";
6439 sub git_blame_incremental
{
6440 git_blame_common
('incremental');
6443 sub git_blame_data
{
6444 git_blame_common
('data');
6448 my $head = git_get_head_hash
($project);
6450 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('tags'));
6451 git_print_header_div
('summary', $project);
6453 my @tagslist = git_get_tags_list
();
6455 git_tags_body
(\
@tagslist);
6461 my $head = git_get_head_hash
($project);
6463 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('heads'));
6464 git_print_header_div
('summary', $project);
6466 my @headslist = git_get_heads_list
();
6468 git_heads_body
(\
@headslist, $head);
6473 # used both for single remote view and for list of all the remotes
6475 gitweb_check_feature
('remote_heads')
6476 or die_error
(403, "Remote heads view is disabled");
6478 my $head = git_get_head_hash
($project);
6479 my $remote = $input_params{'hash'};
6481 my $remotedata = git_get_remotes_list
($remote);
6482 die_error
(500, "Unable to get remote information") unless defined $remotedata;
6484 unless (%$remotedata) {
6485 die_error
(404, defined $remote ?
6486 "Remote $remote not found" :
6487 "No remotes found");
6490 git_header_html
(undef, undef, -action_extra
=> $remote);
6491 git_print_page_nav
('', '', $head, undef, $head,
6492 format_ref_views
($remote ?
'' : 'remotes'));
6494 fill_remote_heads
($remotedata);
6495 if (defined $remote) {
6496 git_print_header_div
('remotes', "$remote remote for $project");
6497 git_remote_block
($remote, $remotedata->{$remote}, undef, $head);
6499 git_print_header_div
('summary', "$project remotes");
6500 git_remotes_body
($remotedata, undef, $head);
6506 sub git_blob_plain
{
6510 if (!defined $hash) {
6511 if (defined $file_name) {
6512 my $base = $hash_base || git_get_head_hash
($project);
6513 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6514 or die_error
(404, "Cannot find file");
6516 die_error
(400, "No file name defined");
6518 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6519 # blobs defined by non-textual hash id's can be cached
6523 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6524 or die_error
(500, "Open git-cat-file blob '$hash' failed");
6526 # content-type (can include charset)
6527 $type = blob_contenttype
($fd, $file_name, $type);
6529 # "save as" filename, even when no $file_name is given
6530 my $save_as = "$hash";
6531 if (defined $file_name) {
6532 $save_as = $file_name;
6533 } elsif ($type =~ m/^text\//) {
6537 # With XSS prevention on, blobs of all types except a few known safe
6538 # ones are served with "Content-Disposition: attachment" to make sure
6539 # they don't run in our security domain. For certain image types,
6540 # blob view writes an <img> tag referring to blob_plain view, and we
6541 # want to be sure not to break that by serving the image as an
6542 # attachment (though Firefox 3 doesn't seem to care).
6543 my $sandbox = $prevent_xss &&
6544 $type !~ m!^(?:text/[a-z]+|image/(?:gif|png|jpeg))(?:[ ;]|$)!;
6546 # serve text/* as text/plain
6548 ($type =~ m!^text/[a-z]+\b(.*)$! ||
6549 ($type =~ m!^[a-z]+/[a-z]\+xml\b(.*)$! && -T
$fd))) {
6551 $rest = defined $rest ?
$rest : '';
6552 $type = "text/plain$rest";
6557 -expires
=> $expires,
6558 -content_disposition
=>
6559 ($sandbox ?
'attachment' : 'inline')
6560 . '; filename="' . $save_as . '"');
6562 binmode STDOUT
, ':raw';
6564 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6571 if (!defined $hash) {
6572 if (defined $file_name) {
6573 my $base = $hash_base || git_get_head_hash
($project);
6574 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6575 or die_error
(404, "Cannot find file");
6577 die_error
(400, "No file name defined");
6579 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6580 # blobs defined by non-textual hash id's can be cached
6584 my $have_blame = gitweb_check_feature
('blame');
6585 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6586 or die_error
(500, "Couldn't cat $file_name, $hash");
6587 my $mimetype = blob_mimetype
($fd, $file_name);
6588 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
6589 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
6591 return git_blob_plain
($mimetype);
6593 # we can have blame only for text/* mimetype
6594 $have_blame &&= ($mimetype =~ m!^text/!);
6596 my $highlight = gitweb_check_feature
('highlight');
6597 my $syntax = guess_file_syntax
($highlight, $mimetype, $file_name);
6598 $fd = run_highlighter
($fd, $highlight, $syntax)
6601 git_header_html
(undef, $expires);
6602 my $formats_nav = '';
6603 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6604 if (defined $file_name) {
6607 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
6612 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6615 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6618 $cgi->a({-href
=> href
(action
=>"blob",
6619 hash_base
=>"HEAD", file_name
=>$file_name)},
6623 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6626 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6627 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6629 print "<div class=\"page_nav\">\n" .
6630 "<br/><br/></div>\n" .
6631 "<div class=\"title\">".esc_html
($hash)."</div>\n";
6633 git_print_page_path
($file_name, "blob", $hash_base);
6634 print "<div class=\"page_body\">\n";
6635 if ($mimetype =~ m!^image/!) {
6636 print qq!<img type
="!.esc_attr($mimetype).qq!"!;
6638 print qq! alt
="!.esc_attr($file_name).qq!" title
="!.esc_attr($file_name).qq!"!;
6641 href(action=>"blob_plain
", hash=>$hash,
6642 hash_base=>$hash_base, file_name=>$file_name) .
6646 while (my $line = <$fd>) {
6649 $line = untabify
($line);
6650 printf qq!<div
class="pre"><a id
="l%i" href
="%s#l%i" class="linenr">%4i</a> %s</div
>\n!,
6651 $nr, esc_attr
(href
(-replay
=> 1)), $nr, $nr,
6652 $syntax ? sanitize
($line) : esc_html
($line, -nbsp
=>1);
6656 or print "Reading blob failed.\n";
6662 if (!defined $hash_base) {
6663 $hash_base = "HEAD";
6665 if (!defined $hash) {
6666 if (defined $file_name) {
6667 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
6672 die_error
(404, "No such tree") unless defined($hash);
6674 my $show_sizes = gitweb_check_feature
('show-sizes');
6675 my $have_blame = gitweb_check_feature
('blame');
6680 open my $fd, "-|", git_cmd
(), "ls-tree", '-z',
6681 ($show_sizes ?
'-l' : ()), @extra_options, $hash
6682 or die_error
(500, "Open git-ls-tree failed");
6683 @entries = map { chomp; $_ } <$fd>;
6685 or die_error
(404, "Reading tree failed");
6688 my $refs = git_get_references
();
6689 my $ref = format_ref_marker
($refs, $hash_base);
6692 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6694 if (defined $file_name) {
6696 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6698 $cgi->a({-href
=> href
(action
=>"tree",
6699 hash_base
=>"HEAD", file_name
=>$file_name)},
6702 my $snapshot_links = format_snapshot_links
($hash);
6703 if (defined $snapshot_links) {
6704 # FIXME: Should be available when we have no hash base as well.
6705 push @views_nav, $snapshot_links;
6707 git_print_page_nav
('tree','', $hash_base, undef, undef,
6708 join(' | ', @views_nav));
6709 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
6712 print "<div class=\"page_nav\">\n";
6713 print "<br/><br/></div>\n";
6714 print "<div class=\"title\">".esc_html
($hash)."</div>\n";
6716 if (defined $file_name) {
6717 $basedir = $file_name;
6718 if ($basedir ne '' && substr($basedir, -1) ne '/') {
6721 git_print_page_path
($file_name, 'tree', $hash_base);
6723 print "<div class=\"page_body\">\n";
6724 print "<table class=\"tree\">\n";
6726 # '..' (top directory) link if possible
6727 if (defined $hash_base &&
6728 defined $file_name && $file_name =~ m![^/]+$!) {
6730 print "<tr class=\"dark\">\n";
6732 print "<tr class=\"light\">\n";
6736 my $up = $file_name;
6737 $up =~ s!/?[^/]+$!!;
6738 undef $up unless $up;
6739 # based on git_print_tree_entry
6740 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
6741 print '<td class="size"> </td>'."\n" if $show_sizes;
6742 print '<td class="list">';
6743 print $cgi->a({-href
=> href
(action
=>"tree",
6744 hash_base
=>$hash_base,
6748 print "<td class=\"link\"></td>\n";
6752 foreach my $line (@entries) {
6753 my %t = parse_ls_tree_line
($line, -z
=> 1, -l
=> $show_sizes);
6756 print "<tr class=\"dark\">\n";
6758 print "<tr class=\"light\">\n";
6762 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
6766 print "</table>\n" .
6772 my ($project, $hash) = @_;
6774 # path/to/project.git -> project
6775 # path/to/project/.git -> project
6776 my $name = to_utf8
($project);
6777 $name =~ s
,([^/])/*\
.git
$,$1,;
6778 $name = basename
($name);
6780 $name =~ s/[[:cntrl:]]/?/g;
6783 if ($hash =~ /^[0-9a-fA-F]+$/) {
6784 # shorten SHA-1 hash
6785 my $full_hash = git_get_full_hash
($project, $hash);
6786 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
6787 $ver = git_get_short_hash
($project, $hash);
6789 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
6790 # tags don't need shortened SHA-1 hash
6793 # branches and other need shortened SHA-1 hash
6794 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
6797 $ver .= '-' . git_get_short_hash
($project, $hash);
6799 # in case of hierarchical branch names
6802 # name = project-version_string
6803 $name = "$name-$ver";
6805 return wantarray ?
($name, $name) : $name;
6809 my $format = $input_params{'snapshot_format'};
6810 if (!@snapshot_fmts) {
6811 die_error
(403, "Snapshots not allowed");
6813 # default to first supported snapshot format
6814 $format ||= $snapshot_fmts[0];
6815 if ($format !~ m/^[a-z0-9]+$/) {
6816 die_error
(400, "Invalid snapshot format parameter");
6817 } elsif (!exists($known_snapshot_formats{$format})) {
6818 die_error
(400, "Unknown snapshot format");
6819 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
6820 die_error
(403, "Snapshot format not allowed");
6821 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
6822 die_error
(403, "Unsupported snapshot format");
6825 my $type = git_get_type
("$hash^{}");
6827 die_error
(404, 'Object does not exist');
6828 } elsif ($type eq 'blob') {
6829 die_error
(400, 'Object is not a tree-ish');
6832 my ($name, $prefix) = snapshot_name
($project, $hash);
6833 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
6834 my $cmd = quote_command
(
6835 git_cmd
(), 'archive',
6836 "--format=$known_snapshot_formats{$format}{'format'}",
6837 "--prefix=$prefix/", $hash);
6838 if (exists $known_snapshot_formats{$format}{'compressor'}) {
6839 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
6842 $filename =~ s/(["\\])/\\$1/g;
6844 -type
=> $known_snapshot_formats{$format}{'type'},
6845 -content_disposition
=> 'inline; filename="' . $filename . '"',
6846 -status
=> '200 OK');
6848 open my $fd, "-|", $cmd
6849 or die_error
(500, "Execute git-archive failed");
6850 binmode STDOUT
, ':raw';
6852 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6856 sub git_log_generic
{
6857 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
6859 my $head = git_get_head_hash
($project);
6860 if (!defined $base) {
6863 if (!defined $page) {
6866 my $refs = git_get_references
();
6868 my $commit_hash = $base;
6869 if (defined $parent) {
6870 $commit_hash = "$parent..$base";
6873 parse_commits
($commit_hash, 101, (100 * $page),
6874 defined $file_name ?
($file_name, "--full-history") : ());
6877 if (!defined $file_hash && defined $file_name) {
6878 # some commits could have deleted file in question,
6879 # and not have it in tree, but one of them has to have it
6880 for (my $i = 0; $i < @commitlist; $i++) {
6881 $file_hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
6882 last if defined $file_hash;
6885 if (defined $file_hash) {
6886 $ftype = git_get_type
($file_hash);
6888 if (defined $file_name && !defined $ftype) {
6889 die_error
(500, "Unknown type of object");
6892 if (defined $file_name) {
6893 %co = parse_commit
($base)
6894 or die_error
(404, "Unknown commit object");
6898 my $paging_nav = format_paging_nav
($fmt_name, $page, $#commitlist >= 100);
6900 if ($#commitlist >= 100) {
6902 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6903 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
6905 my $patch_max = gitweb_get_feature
('patches');
6906 if ($patch_max && !defined $file_name) {
6907 if ($patch_max < 0 || @commitlist <= $patch_max) {
6908 $paging_nav .= " ⋅ " .
6909 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
6915 git_print_page_nav
($fmt_name,'', $hash,$hash,$hash, $paging_nav);
6916 if (defined $file_name) {
6917 git_print_header_div
('commit', esc_html
($co{'title'}), $base);
6919 git_print_header_div
('summary', $project)
6921 git_print_page_path
($file_name, $ftype, $hash_base)
6922 if (defined $file_name);
6924 $body_subr->(\
@commitlist, 0, 99, $refs, $next_link,
6925 $file_name, $file_hash, $ftype);
6931 git_log_generic
('log', \
&git_log_body
,
6932 $hash, $hash_parent);
6936 $hash ||= $hash_base || "HEAD";
6937 my %co = parse_commit
($hash)
6938 or die_error
(404, "Unknown commit object");
6940 my $parent = $co{'parent'};
6941 my $parents = $co{'parents'}; # listref
6943 # we need to prepare $formats_nav before any parameter munging
6945 if (!defined $parent) {
6947 $formats_nav .= '(initial)';
6948 } elsif (@
$parents == 1) {
6949 # single parent commit
6952 $cgi->a({-href
=> href
(action
=>"commit",
6954 esc_html
(substr($parent, 0, 7))) .
6961 $cgi->a({-href
=> href
(action
=>"commit",
6963 esc_html
(substr($_, 0, 7)));
6967 if (gitweb_check_feature
('patches') && @
$parents <= 1) {
6968 $formats_nav .= " | " .
6969 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6973 if (!defined $parent) {
6977 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
6979 (@
$parents <= 1 ?
$parent : '-c'),
6981 or die_error
(500, "Open git-diff-tree failed");
6982 @difftree = map { chomp; $_ } <$fd>;
6983 close $fd or die_error
(404, "Reading git-diff-tree failed");
6985 # non-textual hash id's can be cached
6987 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6990 my $refs = git_get_references
();
6991 my $ref = format_ref_marker
($refs, $co{'id'});
6993 git_header_html
(undef, $expires);
6994 git_print_page_nav
('commit', '',
6995 $hash, $co{'tree'}, $hash,
6998 if (defined $co{'parent'}) {
6999 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
7001 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
7003 print "<div class=\"title_text\">\n" .
7004 "<table class=\"object_header\">\n";
7005 git_print_authorship_rows
(\
%co);
7006 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
7009 "<td class=\"sha1\">" .
7010 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
7011 class => "list"}, $co{'tree'}) .
7013 "<td class=\"link\">" .
7014 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
7016 my $snapshot_links = format_snapshot_links
($hash);
7017 if (defined $snapshot_links) {
7018 print " | " . $snapshot_links;
7023 foreach my $par (@
$parents) {
7026 "<td class=\"sha1\">" .
7027 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
7028 class => "list"}, $par) .
7030 "<td class=\"link\">" .
7031 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
7033 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
7040 print "<div class=\"page_body\">\n";
7041 git_print_log
($co{'comment'});
7044 git_difftree_body
(\
@difftree, $hash, @
$parents);
7050 # object is defined by:
7051 # - hash or hash_base alone
7052 # - hash_base and file_name
7055 # - hash or hash_base alone
7056 if ($hash || ($hash_base && !defined $file_name)) {
7057 my $object_id = $hash || $hash_base;
7059 open my $fd, "-|", quote_command
(
7060 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
7061 or die_error
(404, "Object does not exist");
7065 or die_error
(404, "Object does not exist");
7067 # - hash_base and file_name
7068 } elsif ($hash_base && defined $file_name) {
7069 $file_name =~ s
,/+$,,;
7071 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
7072 or die_error
(404, "Base object does not exist");
7074 # here errors should not hapen
7075 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
7076 or die_error
(500, "Open git-ls-tree failed");
7080 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
7081 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
7082 die_error
(404, "File or directory for given base does not exist");
7087 die_error
(400, "Not enough information to find object");
7090 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
7091 hash
=>$hash, hash_base
=>$hash_base,
7092 file_name
=>$file_name),
7093 -status
=> '302 Found');
7097 my $format = shift || 'html';
7098 my $diff_style = $input_params{'diff_style'} || 'inline';
7105 # preparing $fd and %diffinfo for git_patchset_body
7107 if (defined $hash_base && defined $hash_parent_base) {
7108 if (defined $file_name) {
7110 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7111 $hash_parent_base, $hash_base,
7112 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7113 or die_error
(500, "Open git-diff-tree failed");
7114 @difftree = map { chomp; $_ } <$fd>;
7116 or die_error
(404, "Reading git-diff-tree failed");
7118 or die_error
(404, "Blob diff not found");
7120 } elsif (defined $hash &&
7121 $hash =~ /[0-9a-fA-F]{40}/) {
7122 # try to find filename from $hash
7124 # read filtered raw output
7125 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7126 $hash_parent_base, $hash_base, "--"
7127 or die_error
(500, "Open git-diff-tree failed");
7129 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
7131 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
7132 map { chomp; $_ } <$fd>;
7134 or die_error
(404, "Reading git-diff-tree failed");
7136 or die_error
(404, "Blob diff not found");
7139 die_error
(400, "Missing one of the blob diff parameters");
7142 if (@difftree > 1) {
7143 die_error
(400, "Ambiguous blob diff specification");
7146 %diffinfo = parse_difftree_raw_line
($difftree[0]);
7147 $file_parent ||= $diffinfo{'from_file'} || $file_name;
7148 $file_name ||= $diffinfo{'to_file'};
7150 $hash_parent ||= $diffinfo{'from_id'};
7151 $hash ||= $diffinfo{'to_id'};
7153 # non-textual hash id's can be cached
7154 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
7155 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
7160 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7161 '-p', ($format eq 'html' ?
"--full-index" : ()),
7162 $hash_parent_base, $hash_base,
7163 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7164 or die_error
(500, "Open git-diff-tree failed");
7167 # old/legacy style URI -- not generated anymore since 1.4.3.
7169 die_error
('404 Not Found', "Missing one of the blob diff parameters")
7173 if ($format eq 'html') {
7175 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
7177 $formats_nav .= diff_style_nav
($diff_style);
7178 git_header_html
(undef, $expires);
7179 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
7180 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
7181 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
7183 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
7184 print "<div class=\"title\">".esc_html
("$hash vs $hash_parent")."</div>\n";
7186 if (defined $file_name) {
7187 git_print_page_path
($file_name, "blob", $hash_base);
7189 print "<div class=\"page_path\"></div>\n";
7192 } elsif ($format eq 'plain') {
7194 -type
=> 'text/plain',
7195 -charset
=> 'utf-8',
7196 -expires
=> $expires,
7197 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
7199 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7202 die_error
(400, "Unknown blobdiff format");
7206 if ($format eq 'html') {
7207 print "<div class=\"page_body\">\n";
7209 git_patchset_body
($fd, $diff_style,
7210 [ \
%diffinfo ], $hash_base, $hash_parent_base);
7213 print "</div>\n"; # class="page_body"
7217 while (my $line = <$fd>) {
7218 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
7219 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
7223 last if $line =~ m!^\+\+\+!;
7231 sub git_blobdiff_plain
{
7232 git_blobdiff
('plain');
7235 # assumes that it is added as later part of already existing navigation,
7236 # so it returns "| foo | bar" rather than just "foo | bar"
7237 sub diff_style_nav
{
7238 my ($diff_style, $is_combined) = @_;
7239 $diff_style ||= 'inline';
7241 return "" if ($is_combined);
7243 my @styles = (inline
=> 'inline', 'sidebyside' => 'side by side');
7244 my %styles = @styles;
7246 @styles[ map { $_ * 2 } 0..$#styles/2 ];
7251 $_ eq $diff_style ?
$styles{$_} :
7252 $cgi->a({-href
=> href
(-replay
=>1, diff_style
=> $_)}, $styles{$_})
7256 sub git_commitdiff
{
7258 my $format = $params{-format
} || 'html';
7259 my $diff_style = $input_params{'diff_style'} || 'inline';
7261 my ($patch_max) = gitweb_get_feature
('patches');
7262 if ($format eq 'patch') {
7263 die_error
(403, "Patch view not allowed") unless $patch_max;
7266 $hash ||= $hash_base || "HEAD";
7267 my %co = parse_commit
($hash)
7268 or die_error
(404, "Unknown commit object");
7270 # choose format for commitdiff for merge
7271 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
7272 $hash_parent = '--cc';
7274 # we need to prepare $formats_nav before almost any parameter munging
7276 if ($format eq 'html') {
7278 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
7280 if ($patch_max && @
{$co{'parents'}} <= 1) {
7281 $formats_nav .= " | " .
7282 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
7285 $formats_nav .= diff_style_nav
($diff_style, @
{$co{'parents'}} > 1);
7287 if (defined $hash_parent &&
7288 $hash_parent ne '-c' && $hash_parent ne '--cc') {
7289 # commitdiff with two commits given
7290 my $hash_parent_short = $hash_parent;
7291 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
7292 $hash_parent_short = substr($hash_parent, 0, 7);
7296 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
7297 if ($co{'parents'}[$i] eq $hash_parent) {
7298 $formats_nav .= ' parent ' . ($i+1);
7302 $formats_nav .= ': ' .
7303 $cgi->a({-href
=> href
(-replay
=>1,
7304 hash
=>$hash_parent, hash_base
=>undef)},
7305 esc_html
($hash_parent_short)) .
7307 } elsif (!$co{'parent'}) {
7309 $formats_nav .= ' (initial)';
7310 } elsif (scalar @
{$co{'parents'}} == 1) {
7311 # single parent commit
7314 $cgi->a({-href
=> href
(-replay
=>1,
7315 hash
=>$co{'parent'}, hash_base
=>undef)},
7316 esc_html
(substr($co{'parent'}, 0, 7))) .
7320 if ($hash_parent eq '--cc') {
7321 $formats_nav .= ' | ' .
7322 $cgi->a({-href
=> href
(-replay
=>1,
7323 hash
=>$hash, hash_parent
=>'-c')},
7325 } else { # $hash_parent eq '-c'
7326 $formats_nav .= ' | ' .
7327 $cgi->a({-href
=> href
(-replay
=>1,
7328 hash
=>$hash, hash_parent
=>'--cc')},
7334 $cgi->a({-href
=> href
(-replay
=>1,
7335 hash
=>$_, hash_base
=>undef)},
7336 esc_html
(substr($_, 0, 7)));
7337 } @
{$co{'parents'}} ) .
7342 my $hash_parent_param = $hash_parent;
7343 if (!defined $hash_parent_param) {
7344 # --cc for multiple parents, --root for parentless
7345 $hash_parent_param =
7346 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
7352 if ($format eq 'html') {
7353 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7354 "--no-commit-id", "--patch-with-raw", "--full-index",
7355 $hash_parent_param, $hash, "--"
7356 or die_error
(500, "Open git-diff-tree failed");
7358 while (my $line = <$fd>) {
7360 # empty line ends raw part of diff-tree output
7362 push @difftree, scalar parse_difftree_raw_line
($line);
7365 } elsif ($format eq 'plain') {
7366 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7367 '-p', $hash_parent_param, $hash, "--"
7368 or die_error
(500, "Open git-diff-tree failed");
7369 } elsif ($format eq 'patch') {
7370 # For commit ranges, we limit the output to the number of
7371 # patches specified in the 'patches' feature.
7372 # For single commits, we limit the output to a single patch,
7373 # diverging from the git-format-patch default.
7374 my @commit_spec = ();
7376 if ($patch_max > 0) {
7377 push @commit_spec, "-$patch_max";
7379 push @commit_spec, '-n', "$hash_parent..$hash";
7381 if ($params{-single
}) {
7382 push @commit_spec, '-1';
7384 if ($patch_max > 0) {
7385 push @commit_spec, "-$patch_max";
7387 push @commit_spec, "-n";
7389 push @commit_spec, '--root', $hash;
7391 open $fd, "-|", git_cmd
(), "format-patch", @diff_opts,
7392 '--encoding=utf8', '--stdout', @commit_spec
7393 or die_error
(500, "Open git-format-patch failed");
7395 die_error
(400, "Unknown commitdiff format");
7398 # non-textual hash id's can be cached
7400 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
7404 # write commit message
7405 if ($format eq 'html') {
7406 my $refs = git_get_references
();
7407 my $ref = format_ref_marker
($refs, $co{'id'});
7409 git_header_html
(undef, $expires);
7410 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
7411 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
7412 print "<div class=\"title_text\">\n" .
7413 "<table class=\"object_header\">\n";
7414 git_print_authorship_rows
(\
%co);
7417 print "<div class=\"page_body\">\n";
7418 if (@
{$co{'comment'}} > 1) {
7419 print "<div class=\"log\">\n";
7420 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
7421 print "</div>\n"; # class="log"
7424 } elsif ($format eq 'plain') {
7425 my $refs = git_get_references
("tags");
7426 my $tagname = git_get_rev_name_tags
($hash);
7427 my $filename = basename
($project) . "-$hash.patch";
7430 -type
=> 'text/plain',
7431 -charset
=> 'utf-8',
7432 -expires
=> $expires,
7433 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7434 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7435 print "From: " . to_utf8
($co{'author'}) . "\n";
7436 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
7437 print "Subject: " . to_utf8
($co{'title'}) . "\n";
7439 print "X-Git-Tag: $tagname\n" if $tagname;
7440 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7442 foreach my $line (@
{$co{'comment'}}) {
7443 print to_utf8
($line) . "\n";
7446 } elsif ($format eq 'patch') {
7447 my $filename = basename
($project) . "-$hash.patch";
7450 -type
=> 'text/plain',
7451 -charset
=> 'utf-8',
7452 -expires
=> $expires,
7453 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7457 if ($format eq 'html') {
7458 my $use_parents = !defined $hash_parent ||
7459 $hash_parent eq '-c' || $hash_parent eq '--cc';
7460 git_difftree_body
(\
@difftree, $hash,
7461 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7464 git_patchset_body
($fd, $diff_style,
7466 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7468 print "</div>\n"; # class="page_body"
7471 } elsif ($format eq 'plain') {
7475 or print "Reading git-diff-tree failed\n";
7476 } elsif ($format eq 'patch') {
7480 or print "Reading git-format-patch failed\n";
7484 sub git_commitdiff_plain
{
7485 git_commitdiff
(-format
=> 'plain');
7488 # format-patch-style patches
7490 git_commitdiff
(-format
=> 'patch', -single
=> 1);
7494 git_commitdiff
(-format
=> 'patch');
7498 git_log_generic
('history', \
&git_history_body
,
7499 $hash_base, $hash_parent_base,
7504 $searchtype ||= 'commit';
7506 # check if appropriate features are enabled
7507 gitweb_check_feature
('search')
7508 or die_error
(403, "Search is disabled");
7509 if ($searchtype eq 'pickaxe') {
7510 # pickaxe may take all resources of your box and run for several minutes
7511 # with every query - so decide by yourself how public you make this feature
7512 gitweb_check_feature
('pickaxe')
7513 or die_error
(403, "Pickaxe search is disabled");
7515 if ($searchtype eq 'grep') {
7516 # grep search might be potentially CPU-intensive, too
7517 gitweb_check_feature
('grep')
7518 or die_error
(403, "Grep search is disabled");
7521 if (!defined $searchtext) {
7522 die_error
(400, "Text field is empty");
7524 if (!defined $hash) {
7525 $hash = git_get_head_hash
($project);
7527 my %co = parse_commit
($hash);
7529 die_error
(404, "Unknown commit object");
7531 if (!defined $page) {
7535 if ($searchtype eq 'commit' ||
7536 $searchtype eq 'author' ||
7537 $searchtype eq 'committer') {
7538 git_search_message
(%co);
7539 } elsif ($searchtype eq 'pickaxe') {
7540 git_search_changes
(%co);
7541 } elsif ($searchtype eq 'grep') {
7542 git_search_files
(%co);
7544 die_error
(400, "Unknown search type");
7548 sub git_search_help
{
7550 git_print_page_nav
('','', $hash,$hash,$hash);
7552 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
7553 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
7554 the pattern entered is recognized as the POSIX extended
7555 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
7558 <dt><b>commit</b></dt>
7559 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
7561 my $have_grep = gitweb_check_feature
('grep');
7564 <dt><b>grep</b></dt>
7565 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
7566 a different one) are searched for the given pattern. On large trees, this search can take
7567 a while and put some strain on the server, so please use it with some consideration. Note that
7568 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
7569 case-sensitive.</dd>
7573 <dt><b>author</b></dt>
7574 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
7575 <dt><b>committer</b></dt>
7576 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
7578 my $have_pickaxe = gitweb_check_feature
('pickaxe');
7579 if ($have_pickaxe) {
7581 <dt><b>pickaxe</b></dt>
7582 <dd>All commits that caused the string to appear or disappear from any file (changes that
7583 added, removed or "modified" the string) will be listed. This search can take a while and
7584 takes a lot of strain on the server, so please use it wisely. Note that since you may be
7585 interested even in changes just changing the case as well, this search is case sensitive.</dd>
7593 git_log_generic
('shortlog', \
&git_shortlog_body
,
7594 $hash, $hash_parent);
7597 ## ......................................................................
7598 ## feeds (RSS, Atom; OPML)
7601 my $format = shift || 'atom';
7602 my $have_blame = gitweb_check_feature
('blame');
7604 # Atom: http://www.atomenabled.org/developers/syndication/
7605 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
7606 if ($format ne 'rss' && $format ne 'atom') {
7607 die_error
(400, "Unknown web feed format");
7610 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
7611 my $head = $hash || 'HEAD';
7612 my @commitlist = parse_commits
($head, 150, 0, $file_name);
7616 my $content_type = "application/$format+xml";
7617 if (defined $cgi->http('HTTP_ACCEPT') &&
7618 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
7619 # browser (feed reader) prefers text/xml
7620 $content_type = 'text/xml';
7622 if (defined($commitlist[0])) {
7623 %latest_commit = %{$commitlist[0]};
7624 my $latest_epoch = $latest_commit{'committer_epoch'};
7625 %latest_date = parse_date
($latest_epoch, $latest_commit{'comitter_tz'});
7626 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
7627 if (defined $if_modified) {
7629 if (eval { require HTTP
::Date
; 1; }) {
7630 $since = HTTP
::Date
::str2time
($if_modified);
7631 } elsif (eval { require Time
::ParseDate
; 1; }) {
7632 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
7634 if (defined $since && $latest_epoch <= $since) {
7636 -type
=> $content_type,
7637 -charset
=> 'utf-8',
7638 -last_modified
=> $latest_date{'rfc2822'},
7639 -status
=> '304 Not Modified');
7644 -type
=> $content_type,
7645 -charset
=> 'utf-8',
7646 -last_modified
=> $latest_date{'rfc2822'});
7649 -type
=> $content_type,
7650 -charset
=> 'utf-8');
7653 # Optimization: skip generating the body if client asks only
7654 # for Last-Modified date.
7655 return if ($cgi->request_method() eq 'HEAD');
7658 my $title = "$site_name - $project/$action";
7659 my $feed_type = 'log';
7660 if (defined $hash) {
7661 $title .= " - '$hash'";
7662 $feed_type = 'branch log';
7663 if (defined $file_name) {
7664 $title .= " :: $file_name";
7665 $feed_type = 'history';
7667 } elsif (defined $file_name) {
7668 $title .= " - $file_name";
7669 $feed_type = 'history';
7671 $title .= " $feed_type";
7672 my $descr = git_get_project_description
($project);
7673 if (defined $descr) {
7674 $descr = esc_html
($descr);
7676 $descr = "$project " .
7677 ($format eq 'rss' ?
'RSS' : 'Atom') .
7680 my $owner = git_get_project_owner
($project);
7681 $owner = esc_html
($owner);
7685 if (defined $file_name) {
7686 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
7687 } elsif (defined $hash) {
7688 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
7690 $alt_url = href
(-full
=>1, action
=>"summary");
7692 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
7693 if ($format eq 'rss') {
7695 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
7698 print "<title>$title</title>\n" .
7699 "<link>$alt_url</link>\n" .
7700 "<description>$descr</description>\n" .
7701 "<language>en</language>\n" .
7702 # project owner is responsible for 'editorial' content
7703 "<managingEditor>$owner</managingEditor>\n";
7704 if (defined $logo || defined $favicon) {
7705 # prefer the logo to the favicon, since RSS
7706 # doesn't allow both
7707 my $img = esc_url
($logo || $favicon);
7709 "<url>$img</url>\n" .
7710 "<title>$title</title>\n" .
7711 "<link>$alt_url</link>\n" .
7715 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
7716 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
7718 print "<generator>gitweb v.$version/$git_version</generator>\n";
7719 } elsif ($format eq 'atom') {
7721 <feed xmlns="http://www.w3.org/2005/Atom">
7723 print "<title>$title</title>\n" .
7724 "<subtitle>$descr</subtitle>\n" .
7725 '<link rel="alternate" type="text/html" href="' .
7726 $alt_url . '" />' . "\n" .
7727 '<link rel="self" type="' . $content_type . '" href="' .
7728 $cgi->self_url() . '" />' . "\n" .
7729 "<id>" . href
(-full
=>1) . "</id>\n" .
7730 # use project owner for feed author
7731 "<author><name>$owner</name></author>\n";
7732 if (defined $favicon) {
7733 print "<icon>" . esc_url
($favicon) . "</icon>\n";
7735 if (defined $logo) {
7736 # not twice as wide as tall: 72 x 27 pixels
7737 print "<logo>" . esc_url
($logo) . "</logo>\n";
7739 if (! %latest_date) {
7740 # dummy date to keep the feed valid until commits trickle in:
7741 print "<updated>1970-01-01T00:00:00Z</updated>\n";
7743 print "<updated>$latest_date{'iso-8601'}</updated>\n";
7745 print "<generator version='$version/$git_version'>gitweb</generator>\n";
7749 for (my $i = 0; $i <= $#commitlist; $i++) {
7750 my %co = %{$commitlist[$i]};
7751 my $commit = $co{'id'};
7752 # we read 150, we always show 30 and the ones more recent than 48 hours
7753 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
7756 my %cd = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7758 # get list of changed files
7759 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7760 $co{'parent'} || "--root",
7761 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
7763 my @difftree = map { chomp; $_ } <$fd>;
7767 # print element (entry, item)
7768 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
7769 if ($format eq 'rss') {
7771 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
7772 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
7773 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
7774 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
7775 "<link>$co_url</link>\n" .
7776 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
7777 "<content:encoded>" .
7779 } elsif ($format eq 'atom') {
7781 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
7782 "<updated>$cd{'iso-8601'}</updated>\n" .
7784 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
7785 if ($co{'author_email'}) {
7786 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
7788 print "</author>\n" .
7789 # use committer for contributor
7791 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
7792 if ($co{'committer_email'}) {
7793 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
7795 print "</contributor>\n" .
7796 "<published>$cd{'iso-8601'}</published>\n" .
7797 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
7798 "<id>$co_url</id>\n" .
7799 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
7800 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
7802 my $comment = $co{'comment'};
7804 foreach my $line (@
$comment) {
7805 $line = esc_html
($line);
7808 print "</pre><ul>\n";
7809 foreach my $difftree_line (@difftree) {
7810 my %difftree = parse_difftree_raw_line
($difftree_line);
7811 next if !$difftree{'from_id'};
7813 my $file = $difftree{'file'} || $difftree{'to_file'};
7817 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
7818 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
7819 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
7820 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
7821 -title
=> "diff"}, 'D');
7823 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
7824 file_name
=>$file, hash_base
=>$commit),
7825 -title
=> "blame"}, 'B');
7827 # if this is not a feed of a file history
7828 if (!defined $file_name || $file_name ne $file) {
7829 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
7830 file_name
=>$file, hash
=>$commit),
7831 -title
=> "history"}, 'H');
7833 $file = esc_path
($file);
7837 if ($format eq 'rss') {
7838 print "</ul>]]>\n" .
7839 "</content:encoded>\n" .
7841 } elsif ($format eq 'atom') {
7842 print "</ul>\n</div>\n" .
7849 if ($format eq 'rss') {
7850 print "</channel>\n</rss>\n";
7851 } elsif ($format eq 'atom') {
7865 my @list = git_get_projects_list
();
7867 die_error
(404, "No projects found");
7871 -type
=> 'text/xml',
7872 -charset
=> 'utf-8',
7873 -content_disposition
=> 'inline; filename="opml.xml"');
7875 my $title = esc_html
($site_name);
7877 <?xml version="1.0" encoding="utf-8"?>
7878 <opml version="1.0">
7880 <title>$title OPML Export</title>
7883 <outline text="git RSS feeds">
7886 foreach my $pr (@list) {
7888 my $head = git_get_head_hash
($proj{'path'});
7889 if (!defined $head) {
7892 $git_dir = "$projectroot/$proj{'path'}";
7893 my %co = parse_commit
($head);
7898 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
7899 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
7900 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
7901 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";