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 = decode_utf8
($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} = [ map { decode_utf8
($_) } $cgi->param($symbol) ];
821 $input_params{$name} = decode_utf8
($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 if ($search_use_regexp) {
1077 $search_regexp = $searchtext;
1078 if (!eval { qr/$search_regexp/; 1; }) {
1079 (my $error = $@
) =~ s/ at \S+ line \d+.*\n?//;
1080 die_error
(400, "Invalid search regexp '$search_regexp'",
1084 $search_regexp = quotemeta $searchtext;
1089 # path to the current git repository
1091 sub evaluate_git_dir
{
1092 our $git_dir = "$projectroot/$project" if $project;
1095 our (@snapshot_fmts, $git_avatar);
1096 sub configure_gitweb_features
{
1097 # list of supported snapshot formats
1098 our @snapshot_fmts = gitweb_get_feature
('snapshot');
1099 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1101 # check that the avatar feature is set to a known provider name,
1102 # and for each provider check if the dependencies are satisfied.
1103 # if the provider name is invalid or the dependencies are not met,
1104 # reset $git_avatar to the empty string.
1105 our ($git_avatar) = gitweb_get_feature
('avatar');
1106 if ($git_avatar eq 'gravatar') {
1107 $git_avatar = '' unless (eval { require Digest
::MD5
; 1; });
1108 } elsif ($git_avatar eq 'picon') {
1115 # custom error handler: 'die <message>' is Internal Server Error
1116 sub handle_errors_html
{
1117 my $msg = shift; # it is already HTML escaped
1119 # to avoid infinite loop where error occurs in die_error,
1120 # change handler to default handler, disabling handle_errors_html
1121 set_message
("Error occured when inside die_error:\n$msg");
1123 # you cannot jump out of die_error when called as error handler;
1124 # the subroutine set via CGI::Carp::set_message is called _after_
1125 # HTTP headers are already written, so it cannot write them itself
1126 die_error
(undef, undef, $msg, -error_handler
=> 1, -no_http_header
=> 1);
1128 set_message
(\
&handle_errors_html
);
1132 if (!defined $action) {
1133 if (defined $hash) {
1134 $action = git_get_type
($hash);
1135 $action or die_error
(404, "Object does not exist");
1136 } elsif (defined $hash_base && defined $file_name) {
1137 $action = git_get_type
("$hash_base:$file_name");
1138 $action or die_error
(404, "File or directory does not exist");
1139 } elsif (defined $project) {
1140 $action = 'summary';
1142 $action = 'project_list';
1145 if (!defined($actions{$action})) {
1146 die_error
(400, "Unknown action");
1148 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1150 die_error
(400, "Project needed");
1152 $actions{$action}->();
1156 our $t0 = [ gettimeofday
() ]
1158 our $number_of_git_cmds = 0;
1161 our $first_request = 1;
1166 if ($first_request) {
1167 evaluate_gitweb_config
();
1168 evaluate_git_version
();
1170 if ($per_request_config) {
1171 if (ref($per_request_config) eq 'CODE') {
1172 $per_request_config->();
1173 } elsif (!$first_request) {
1174 evaluate_gitweb_config
();
1179 # $projectroot and $projects_list might be set in gitweb config file
1180 $projects_list ||= $projectroot;
1182 evaluate_query_params
();
1183 evaluate_path_info
();
1184 evaluate_and_validate_params
();
1187 configure_gitweb_features
();
1192 our $is_last_request = sub { 1 };
1193 our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1196 sub configure_as_fcgi
{
1198 our $CGI = 'CGI::Fast';
1200 my $request_number = 0;
1201 # let each child service 100 requests
1202 our $is_last_request = sub { ++$request_number > 100 };
1205 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__
;
1207 if $script_name =~ /\.fcgi$/;
1209 return unless (@ARGV);
1211 require Getopt
::Long
;
1212 Getopt
::Long
::GetOptions
(
1213 'fastcgi|fcgi|f' => \
&configure_as_fcgi
,
1214 'nproc|n=i' => sub {
1215 my ($arg, $val) = @_;
1216 return unless eval { require FCGI
::ProcManager
; 1; };
1217 my $proc_manager = FCGI
::ProcManager
->new({
1218 n_processes
=> $val,
1220 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1221 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1222 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1231 $pre_listen_hook->()
1232 if $pre_listen_hook;
1235 while ($cgi = $CGI->new()) {
1236 $pre_dispatch_hook->()
1237 if $pre_dispatch_hook;
1241 $post_dispatch_hook->()
1242 if $post_dispatch_hook;
1245 last REQUEST
if ($is_last_request->());
1254 if (defined caller) {
1255 # wrapped in a subroutine processing requests,
1256 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1259 # pure CGI script, serving single request
1263 ## ======================================================================
1266 # possible values of extra options
1267 # -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1268 # -replay => 1 - start from a current view (replay with modifications)
1269 # -path_info => 0|1 - don't use/use path_info URL (if possible)
1270 # -anchor => ANCHOR - add #ANCHOR to end of URL, implies -replay if used alone
1273 # default is to use -absolute url() i.e. $my_uri
1274 my $href = $params{-full
} ?
$my_url : $my_uri;
1276 # implicit -replay, must be first of implicit params
1277 $params{-replay
} = 1 if (keys %params == 1 && $params{-anchor
});
1279 $params{'project'} = $project unless exists $params{'project'};
1281 if ($params{-replay
}) {
1282 while (my ($name, $symbol) = each %cgi_param_mapping) {
1283 if (!exists $params{$name}) {
1284 $params{$name} = $input_params{$name};
1289 my $use_pathinfo = gitweb_check_feature
('pathinfo');
1290 if (defined $params{'project'} &&
1291 (exists $params{-path_info
} ?
$params{-path_info
} : $use_pathinfo)) {
1292 # try to put as many parameters as possible in PATH_INFO:
1295 # - hash_parent or hash_parent_base:/file_parent
1296 # - hash or hash_base:/filename
1297 # - the snapshot_format as an appropriate suffix
1299 # When the script is the root DirectoryIndex for the domain,
1300 # $href here would be something like http://gitweb.example.com/
1301 # Thus, we strip any trailing / from $href, to spare us double
1302 # slashes in the final URL
1305 # Then add the project name, if present
1306 $href .= "/".esc_path_info
($params{'project'});
1307 delete $params{'project'};
1309 # since we destructively absorb parameters, we keep this
1310 # boolean that remembers if we're handling a snapshot
1311 my $is_snapshot = $params{'action'} eq 'snapshot';
1313 # Summary just uses the project path URL, any other action is
1315 if (defined $params{'action'}) {
1316 $href .= "/".esc_path_info
($params{'action'})
1317 unless $params{'action'} eq 'summary';
1318 delete $params{'action'};
1321 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1322 # stripping nonexistent or useless pieces
1323 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1324 || $params{'hash_parent'} || $params{'hash'});
1325 if (defined $params{'hash_base'}) {
1326 if (defined $params{'hash_parent_base'}) {
1327 $href .= esc_path_info
($params{'hash_parent_base'});
1328 # skip the file_parent if it's the same as the file_name
1329 if (defined $params{'file_parent'}) {
1330 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1331 delete $params{'file_parent'};
1332 } elsif ($params{'file_parent'} !~ /\.\./) {
1333 $href .= ":/".esc_path_info
($params{'file_parent'});
1334 delete $params{'file_parent'};
1338 delete $params{'hash_parent'};
1339 delete $params{'hash_parent_base'};
1340 } elsif (defined $params{'hash_parent'}) {
1341 $href .= esc_path_info
($params{'hash_parent'}). "..";
1342 delete $params{'hash_parent'};
1345 $href .= esc_path_info
($params{'hash_base'});
1346 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
1347 $href .= ":/".esc_path_info
($params{'file_name'});
1348 delete $params{'file_name'};
1350 delete $params{'hash'};
1351 delete $params{'hash_base'};
1352 } elsif (defined $params{'hash'}) {
1353 $href .= esc_path_info
($params{'hash'});
1354 delete $params{'hash'};
1357 # If the action was a snapshot, we can absorb the
1358 # snapshot_format parameter too
1360 my $fmt = $params{'snapshot_format'};
1361 # snapshot_format should always be defined when href()
1362 # is called, but just in case some code forgets, we
1363 # fall back to the default
1364 $fmt ||= $snapshot_fmts[0];
1365 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1366 delete $params{'snapshot_format'};
1370 # now encode the parameters explicitly
1372 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1373 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
1374 if (defined $params{$name}) {
1375 if (ref($params{$name}) eq "ARRAY") {
1376 foreach my $par (@
{$params{$name}}) {
1377 push @result, $symbol . "=" . esc_param
($par);
1380 push @result, $symbol . "=" . esc_param
($params{$name});
1384 $href .= "?" . join(';', @result) if scalar @result;
1386 # final transformation: trailing spaces must be escaped (URI-encoded)
1387 $href =~ s/(\s+)$/CGI::escape($1)/e;
1389 if ($params{-anchor
}) {
1390 $href .= "#".esc_param
($params{-anchor
});
1397 ## ======================================================================
1398 ## validation, quoting/unquoting and escaping
1400 sub validate_action
{
1401 my $input = shift || return undef;
1402 return undef unless exists $actions{$input};
1406 sub validate_project
{
1407 my $input = shift || return undef;
1408 if (!validate_pathname
($input) ||
1409 !(-d
"$projectroot/$input") ||
1410 !check_export_ok
("$projectroot/$input") ||
1411 ($strict_export && !project_in_list
($input))) {
1418 sub validate_pathname
{
1419 my $input = shift || return undef;
1421 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1422 # at the beginning, at the end, and between slashes.
1423 # also this catches doubled slashes
1424 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1427 # no null characters
1428 if ($input =~ m!\0!) {
1434 sub validate_refname
{
1435 my $input = shift || return undef;
1437 # textual hashes are O.K.
1438 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1441 # it must be correct pathname
1442 $input = validate_pathname
($input)
1444 # restrictions on ref name according to git-check-ref-format
1445 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1451 # decode sequences of octets in utf8 into Perl's internal form,
1452 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1453 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1456 return undef unless defined $str;
1458 if (utf8
::is_utf8
($str) || utf8
::decode
($str)) {
1461 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
1465 # quote unsafe chars, but keep the slash, even when it's not
1466 # correct, but quoted slashes look too horrible in bookmarks
1469 return undef unless defined $str;
1470 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI
::escape
($1)/eg
;
1475 # the quoting rules for path_info fragment are slightly different
1478 return undef unless defined $str;
1480 # path_info doesn't treat '+' as space (specially), but '?' must be escaped
1481 $str =~ s/([^A-Za-z0-9\-_.~();\/;:@&= +]+)/CGI
::escape
($1)/eg
;
1486 # quote unsafe chars in whole URL, so some characters cannot be quoted
1489 return undef unless defined $str;
1490 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI
::escape
($1)/eg
;
1495 # quote unsafe characters in HTML attributes
1498 # for XHTML conformance escaping '"' to '"' is not enough
1499 return esc_html
(@_);
1502 # replace invalid utf8 character with SUBSTITUTION sequence
1507 return undef unless defined $str;
1509 $str = to_utf8
($str);
1510 $str = $cgi->escapeHTML($str);
1511 if ($opts{'-nbsp'}) {
1512 $str =~ s/ / /g;
1514 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1518 # quote control characters and escape filename to HTML
1523 return undef unless defined $str;
1525 $str = to_utf8
($str);
1526 $str = $cgi->escapeHTML($str);
1527 if ($opts{'-nbsp'}) {
1528 $str =~ s/ / /g;
1530 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1534 # Sanitize for use in XHTML + application/xml+xhtm (valid XML 1.0)
1538 return undef unless defined $str;
1540 $str = to_utf8
($str);
1541 $str =~ s
|([[:cntrl
:]])|($1 =~ /[\t\n\r]/ ?
$1 : quot_cec
($1))|eg
;
1545 # Make control characters "printable", using character escape codes (CEC)
1549 my %es = ( # character escape codes, aka escape sequences
1550 "\t" => '\t', # tab (HT)
1551 "\n" => '\n', # line feed (LF)
1552 "\r" => '\r', # carrige return (CR)
1553 "\f" => '\f', # form feed (FF)
1554 "\b" => '\b', # backspace (BS)
1555 "\a" => '\a', # alarm (bell) (BEL)
1556 "\e" => '\e', # escape (ESC)
1557 "\013" => '\v', # vertical tab (VT)
1558 "\000" => '\0', # nul character (NUL)
1560 my $chr = ( (exists $es{$cntrl})
1562 : sprintf('\%2x', ord($cntrl)) );
1563 if ($opts{-nohtml
}) {
1566 return "<span class=\"cntrl\">$chr</span>";
1570 # Alternatively use unicode control pictures codepoints,
1571 # Unicode "printable representation" (PR)
1576 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1577 if ($opts{-nohtml
}) {
1580 return "<span class=\"cntrl\">$chr</span>";
1584 # git may return quoted and escaped filenames
1590 my %es = ( # character escape codes, aka escape sequences
1591 't' => "\t", # tab (HT, TAB)
1592 'n' => "\n", # newline (NL)
1593 'r' => "\r", # return (CR)
1594 'f' => "\f", # form feed (FF)
1595 'b' => "\b", # backspace (BS)
1596 'a' => "\a", # alarm (bell) (BEL)
1597 'e' => "\e", # escape (ESC)
1598 'v' => "\013", # vertical tab (VT)
1601 if ($seq =~ m/^[0-7]{1,3}$/) {
1602 # octal char sequence
1603 return chr(oct($seq));
1604 } elsif (exists $es{$seq}) {
1605 # C escape sequence, aka character escape code
1608 # quoted ordinary character
1612 if ($str =~ m/^"(.*)"$/) {
1615 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1620 # escape tabs (convert tabs to spaces)
1624 while ((my $pos = index($line, "\t")) != -1) {
1625 if (my $count = (8 - ($pos % 8))) {
1626 my $spaces = ' ' x
$count;
1627 $line =~ s/\t/$spaces/;
1634 sub project_in_list
{
1635 my $project = shift;
1636 my @list = git_get_projects_list
();
1637 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1640 ## ----------------------------------------------------------------------
1641 ## HTML aware string manipulation
1643 # Try to chop given string on a word boundary between position
1644 # $len and $len+$add_len. If there is no word boundary there,
1645 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1646 # (marking chopped part) would be longer than given string.
1650 my $add_len = shift || 10;
1651 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1653 # Make sure perl knows it is utf8 encoded so we don't
1654 # cut in the middle of a utf8 multibyte char.
1655 $str = to_utf8
($str);
1657 # allow only $len chars, but don't cut a word if it would fit in $add_len
1658 # if it doesn't fit, cut it if it's still longer than the dots we would add
1659 # remove chopped character entities entirely
1661 # when chopping in the middle, distribute $len into left and right part
1662 # return early if chopping wouldn't make string shorter
1663 if ($where eq 'center') {
1664 return $str if ($len + 5 >= length($str)); # filler is length 5
1667 return $str if ($len + 4 >= length($str)); # filler is length 4
1670 # regexps: ending and beginning with word part up to $add_len
1671 my $endre = qr/.{$len}\w{0,$add_len}/;
1672 my $begre = qr/\w{0,$add_len}.{$len}/;
1674 if ($where eq 'left') {
1675 $str =~ m/^(.*?)($begre)$/;
1676 my ($lead, $body) = ($1, $2);
1677 if (length($lead) > 4) {
1680 return "$lead$body";
1682 } elsif ($where eq 'center') {
1683 $str =~ m/^($endre)(.*)$/;
1684 my ($left, $str) = ($1, $2);
1685 $str =~ m/^(.*?)($begre)$/;
1686 my ($mid, $right) = ($1, $2);
1687 if (length($mid) > 5) {
1690 return "$left$mid$right";
1693 $str =~ m/^($endre)(.*)$/;
1696 if (length($tail) > 4) {
1699 return "$body$tail";
1703 # takes the same arguments as chop_str, but also wraps a <span> around the
1704 # result with a title attribute if it does get chopped. Additionally, the
1705 # string is HTML-escaped.
1706 sub chop_and_escape_str
{
1709 my $chopped = chop_str
(@_);
1710 $str = to_utf8
($str);
1711 if ($chopped eq $str) {
1712 return esc_html
($chopped);
1714 $str =~ s/[[:cntrl:]]/?/g;
1715 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1719 ## ----------------------------------------------------------------------
1720 ## functions returning short strings
1722 # CSS class for given age value (in seconds)
1726 if (!defined $age) {
1728 } elsif ($age < 60*60*2) {
1730 } elsif ($age < 60*60*24*2) {
1737 # convert age in seconds to "nn units ago" string
1742 if ($age > 60*60*24*365*2) {
1743 $age_str = (int $age/60/60/24/365);
1744 $age_str .= " years ago";
1745 } elsif ($age > 60*60*24*(365/12)*2) {
1746 $age_str = int $age/60/60/24/(365/12);
1747 $age_str .= " months ago";
1748 } elsif ($age > 60*60*24*7*2) {
1749 $age_str = int $age/60/60/24/7;
1750 $age_str .= " weeks ago";
1751 } elsif ($age > 60*60*24*2) {
1752 $age_str = int $age/60/60/24;
1753 $age_str .= " days ago";
1754 } elsif ($age > 60*60*2) {
1755 $age_str = int $age/60/60;
1756 $age_str .= " hours ago";
1757 } elsif ($age > 60*2) {
1758 $age_str = int $age/60;
1759 $age_str .= " min ago";
1760 } elsif ($age > 2) {
1761 $age_str = int $age;
1762 $age_str .= " sec ago";
1764 $age_str .= " right now";
1770 S_IFINVALID
=> 0030000,
1771 S_IFGITLINK
=> 0160000,
1774 # submodule/subproject, a commit object reference
1778 return (($mode & S_IFMT
) == S_IFGITLINK
)
1781 # convert file mode in octal to symbolic file mode string
1783 my $mode = oct shift;
1785 if (S_ISGITLINK
($mode)) {
1786 return 'm---------';
1787 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1788 return 'drwxr-xr-x';
1789 } elsif (S_ISLNK
($mode)) {
1790 return 'lrwxrwxrwx';
1791 } elsif (S_ISREG
($mode)) {
1792 # git cares only about the executable bit
1793 if ($mode & S_IXUSR
) {
1794 return '-rwxr-xr-x';
1796 return '-rw-r--r--';
1799 return '----------';
1803 # convert file mode in octal to file type string
1807 if ($mode !~ m/^[0-7]+$/) {
1813 if (S_ISGITLINK
($mode)) {
1815 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1817 } elsif (S_ISLNK
($mode)) {
1819 } elsif (S_ISREG
($mode)) {
1826 # convert file mode in octal to file type description string
1827 sub file_type_long
{
1830 if ($mode !~ m/^[0-7]+$/) {
1836 if (S_ISGITLINK
($mode)) {
1838 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1840 } elsif (S_ISLNK
($mode)) {
1842 } elsif (S_ISREG
($mode)) {
1843 if ($mode & S_IXUSR
) {
1844 return "executable";
1854 ## ----------------------------------------------------------------------
1855 ## functions returning short HTML fragments, or transforming HTML fragments
1856 ## which don't belong to other sections
1858 # format line of commit message.
1859 sub format_log_line_html
{
1862 $line = esc_html
($line, -nbsp
=>1);
1863 $line =~ s
{\b([0-9a
-fA
-F
]{8,40})\b}{
1864 $cgi->a({-href
=> href
(action
=>"object", hash
=>$1),
1865 -class => "text"}, $1);
1871 # format marker of refs pointing to given object
1873 # the destination action is chosen based on object type and current context:
1874 # - for annotated tags, we choose the tag view unless it's the current view
1875 # already, in which case we go to shortlog view
1876 # - for other refs, we keep the current view if we're in history, shortlog or
1877 # log view, and select shortlog otherwise
1878 sub format_ref_marker
{
1879 my ($refs, $id) = @_;
1882 if (defined $refs->{$id}) {
1883 foreach my $ref (@
{$refs->{$id}}) {
1884 # this code exploits the fact that non-lightweight tags are the
1885 # only indirect objects, and that they are the only objects for which
1886 # we want to use tag instead of shortlog as action
1887 my ($type, $name) = qw();
1888 my $indirect = ($ref =~ s/\^\{\}$//);
1889 # e.g. tags/v2.6.11 or heads/next
1890 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1899 $class .= " indirect" if $indirect;
1901 my $dest_action = "shortlog";
1904 $dest_action = "tag" unless $action eq "tag";
1905 } elsif ($action =~ /^(history|(short)?log)$/) {
1906 $dest_action = $action;
1910 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1913 my $link = $cgi->a({
1915 action
=>$dest_action,
1919 $markers .= " <span class=\"".esc_attr
($class)."\" title=\"".esc_attr
($ref)."\">" .
1925 return ' <span class="refs">'. $markers . '</span>';
1931 # format, perhaps shortened and with markers, title line
1932 sub format_subject_html
{
1933 my ($long, $short, $href, $extra) = @_;
1934 $extra = '' unless defined($extra);
1936 if (length($short) < length($long)) {
1937 $long =~ s/[[:cntrl:]]/?/g;
1938 return $cgi->a({-href
=> $href, -class => "list subject",
1939 -title
=> to_utf8
($long)},
1940 esc_html
($short)) . $extra;
1942 return $cgi->a({-href
=> $href, -class => "list subject"},
1943 esc_html
($long)) . $extra;
1947 # Rather than recomputing the url for an email multiple times, we cache it
1948 # after the first hit. This gives a visible benefit in views where the avatar
1949 # for the same email is used repeatedly (e.g. shortlog).
1950 # The cache is shared by all avatar engines (currently gravatar only), which
1951 # are free to use it as preferred. Since only one avatar engine is used for any
1952 # given page, there's no risk for cache conflicts.
1953 our %avatar_cache = ();
1955 # Compute the picon url for a given email, by using the picon search service over at
1956 # http://www.cs.indiana.edu/picons/search.html
1958 my $email = lc shift;
1959 if (!$avatar_cache{$email}) {
1960 my ($user, $domain) = split('@', $email);
1961 $avatar_cache{$email} =
1962 "http://www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
1964 "users+domains+unknown/up/single";
1966 return $avatar_cache{$email};
1969 # Compute the gravatar url for a given email, if it's not in the cache already.
1970 # Gravatar stores only the part of the URL before the size, since that's the
1971 # one computationally more expensive. This also allows reuse of the cache for
1972 # different sizes (for this particular engine).
1974 my $email = lc shift;
1976 $avatar_cache{$email} ||=
1977 "http://www.gravatar.com/avatar/" .
1978 Digest
::MD5
::md5_hex
($email) . "?s=";
1979 return $avatar_cache{$email} . $size;
1982 # Insert an avatar for the given $email at the given $size if the feature
1984 sub git_get_avatar
{
1985 my ($email, %opts) = @_;
1986 my $pre_white = ($opts{-pad_before
} ?
" " : "");
1987 my $post_white = ($opts{-pad_after
} ?
" " : "");
1988 $opts{-size
} ||= 'default';
1989 my $size = $avatar_size{$opts{-size
}} || $avatar_size{'default'};
1991 if ($git_avatar eq 'gravatar') {
1992 $url = gravatar_url
($email, $size);
1993 } elsif ($git_avatar eq 'picon') {
1994 $url = picon_url
($email);
1996 # Other providers can be added by extending the if chain, defining $url
1997 # as needed. If no variant puts something in $url, we assume avatars
1998 # are completely disabled/unavailable.
2001 "<img width=\"$size\" " .
2002 "class=\"avatar\" " .
2003 "src=\"".esc_url
($url)."\" " .
2011 sub format_search_author
{
2012 my ($author, $searchtype, $displaytext) = @_;
2013 my $have_search = gitweb_check_feature
('search');
2017 if ($searchtype eq 'author') {
2018 $performed = "authored";
2019 } elsif ($searchtype eq 'committer') {
2020 $performed = "committed";
2023 return $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
2024 searchtext
=>$author,
2025 searchtype
=>$searchtype), class=>"list",
2026 title
=>"Search for commits $performed by $author"},
2030 return $displaytext;
2034 # format the author name of the given commit with the given tag
2035 # the author name is chopped and escaped according to the other
2036 # optional parameters (see chop_str).
2037 sub format_author_html
{
2040 my $author = chop_and_escape_str
($co->{'author_name'}, @_);
2041 return "<$tag class=\"author\">" .
2042 format_search_author
($co->{'author_name'}, "author",
2043 git_get_avatar
($co->{'author_email'}, -pad_after
=> 1) .
2048 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
2049 sub format_git_diff_header_line
{
2051 my $diffinfo = shift;
2052 my ($from, $to) = @_;
2054 if ($diffinfo->{'nparents'}) {
2056 $line =~ s!^(diff (.*?) )"?.*$!$1!;
2057 if ($to->{'href'}) {
2058 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2059 esc_path
($to->{'file'}));
2060 } else { # file was deleted (no href)
2061 $line .= esc_path
($to->{'file'});
2065 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
2066 if ($from->{'href'}) {
2067 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
2068 'a/' . esc_path
($from->{'file'}));
2069 } else { # file was added (no href)
2070 $line .= 'a/' . esc_path
($from->{'file'});
2073 if ($to->{'href'}) {
2074 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2075 'b/' . esc_path
($to->{'file'}));
2076 } else { # file was deleted
2077 $line .= 'b/' . esc_path
($to->{'file'});
2081 return "<div class=\"diff header\">$line</div>\n";
2084 # format extended diff header line, before patch itself
2085 sub format_extended_diff_header_line
{
2087 my $diffinfo = shift;
2088 my ($from, $to) = @_;
2091 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
2092 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2093 esc_path
($from->{'file'}));
2095 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
2096 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2097 esc_path
($to->{'file'}));
2099 # match single <mode>
2100 if ($line =~ m/\s(\d{6})$/) {
2101 $line .= '<span class="info"> (' .
2102 file_type_long
($1) .
2106 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
2107 # can match only for combined diff
2109 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2110 if ($from->{'href'}[$i]) {
2111 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
2113 substr($diffinfo->{'from_id'}[$i],0,7));
2118 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
2121 if ($to->{'href'}) {
2122 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2123 substr($diffinfo->{'to_id'},0,7));
2128 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
2129 # can match only for ordinary diff
2130 my ($from_link, $to_link);
2131 if ($from->{'href'}) {
2132 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
2133 substr($diffinfo->{'from_id'},0,7));
2135 $from_link = '0' x
7;
2137 if ($to->{'href'}) {
2138 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2139 substr($diffinfo->{'to_id'},0,7));
2143 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2144 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2147 return $line . "<br/>\n";
2150 # format from-file/to-file diff header
2151 sub format_diff_from_to_header
{
2152 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
2157 #assert($line =~ m/^---/) if DEBUG;
2158 # no extra formatting for "^--- /dev/null"
2159 if (! $diffinfo->{'nparents'}) {
2160 # ordinary (single parent) diff
2161 if ($line =~ m!^--- "?a/!) {
2162 if ($from->{'href'}) {
2164 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2165 esc_path
($from->{'file'}));
2168 esc_path
($from->{'file'});
2171 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2174 # combined diff (merge commit)
2175 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2176 if ($from->{'href'}[$i]) {
2178 $cgi->a({-href
=>href
(action
=>"blobdiff",
2179 hash_parent
=>$diffinfo->{'from_id'}[$i],
2180 hash_parent_base
=>$parents[$i],
2181 file_parent
=>$from->{'file'}[$i],
2182 hash
=>$diffinfo->{'to_id'},
2184 file_name
=>$to->{'file'}),
2186 -title
=>"diff" . ($i+1)},
2189 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
2190 esc_path
($from->{'file'}[$i]));
2192 $line = '--- /dev/null';
2194 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2199 #assert($line =~ m/^\+\+\+/) if DEBUG;
2200 # no extra formatting for "^+++ /dev/null"
2201 if ($line =~ m!^\+\+\+ "?b/!) {
2202 if ($to->{'href'}) {
2204 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2205 esc_path
($to->{'file'}));
2208 esc_path
($to->{'file'});
2211 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
2216 # create note for patch simplified by combined diff
2217 sub format_diff_cc_simplified
{
2218 my ($diffinfo, @parents) = @_;
2221 $result .= "<div class=\"diff header\">" .
2223 if (!is_deleted
($diffinfo)) {
2224 $result .= $cgi->a({-href
=> href
(action
=>"blob",
2226 hash
=>$diffinfo->{'to_id'},
2227 file_name
=>$diffinfo->{'to_file'}),
2229 esc_path
($diffinfo->{'to_file'}));
2231 $result .= esc_path
($diffinfo->{'to_file'});
2233 $result .= "</div>\n" . # class="diff header"
2234 "<div class=\"diff nodifferences\">" .
2236 "</div>\n"; # class="diff nodifferences"
2241 sub diff_line_class
{
2242 my ($line, $from, $to) = @_;
2247 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2248 $num_sign = scalar @
{$from->{'href'}};
2251 my @diff_line_classifier = (
2252 { regexp
=> qr/^\@\@{$num_sign} /, class => "chunk_header"},
2253 { regexp
=> qr/^\\/, class => "incomplete" },
2254 { regexp
=> qr/^ {$num_sign}/, class => "ctx" },
2255 # classifier for context must come before classifier add/rem,
2256 # or we would have to use more complicated regexp, for example
2257 # qr/(?= {0,$m}\+)[+ ]{$num_sign}/, where $m = $num_sign - 1;
2258 { regexp
=> qr/^[+ ]{$num_sign}/, class => "add" },
2259 { regexp
=> qr/^[- ]{$num_sign}/, class => "rem" },
2261 for my $clsfy (@diff_line_classifier) {
2262 return $clsfy->{'class'}
2263 if ($line =~ $clsfy->{'regexp'});
2270 # assumes that $from and $to are defined and correctly filled,
2271 # and that $line holds a line of chunk header for unified diff
2272 sub format_unidiff_chunk_header
{
2273 my ($line, $from, $to) = @_;
2275 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2276 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2278 $from_lines = 0 unless defined $from_lines;
2279 $to_lines = 0 unless defined $to_lines;
2281 if ($from->{'href'}) {
2282 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
2283 -class=>"list"}, $from_text);
2285 if ($to->{'href'}) {
2286 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2287 -class=>"list"}, $to_text);
2289 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2290 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2294 # assumes that $from and $to are defined and correctly filled,
2295 # and that $line holds a line of chunk header for combined diff
2296 sub format_cc_diff_chunk_header
{
2297 my ($line, $from, $to) = @_;
2299 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2300 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2302 @from_text = split(' ', $ranges);
2303 for (my $i = 0; $i < @from_text; ++$i) {
2304 ($from_start[$i], $from_nlines[$i]) =
2305 (split(',', substr($from_text[$i], 1)), 0);
2308 $to_text = pop @from_text;
2309 $to_start = pop @from_start;
2310 $to_nlines = pop @from_nlines;
2312 $line = "<span class=\"chunk_info\">$prefix ";
2313 for (my $i = 0; $i < @from_text; ++$i) {
2314 if ($from->{'href'}[$i]) {
2315 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
2316 -class=>"list"}, $from_text[$i]);
2318 $line .= $from_text[$i];
2322 if ($to->{'href'}) {
2323 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2324 -class=>"list"}, $to_text);
2328 $line .= " $prefix</span>" .
2329 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2333 # process patch (diff) line (not to be used for diff headers),
2334 # returning class and HTML-formatted (but not wrapped) line
2335 sub process_diff_line
{
2337 my ($from, $to) = @_;
2339 my $diff_class = diff_line_class
($line, $from, $to);
2342 $line = untabify
($line);
2344 if ($from && $to && $line =~ m/^\@{2} /) {
2345 $line = format_unidiff_chunk_header
($line, $from, $to);
2346 return $diff_class, $line;
2348 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2349 $line = format_cc_diff_chunk_header
($line, $from, $to);
2350 return $diff_class, $line;
2353 return $diff_class, esc_html
($line, -nbsp
=>1);
2356 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2357 # linked. Pass the hash of the tree/commit to snapshot.
2358 sub format_snapshot_links
{
2360 my $num_fmts = @snapshot_fmts;
2361 if ($num_fmts > 1) {
2362 # A parenthesized list of links bearing format names.
2363 # e.g. "snapshot (_tar.gz_ _zip_)"
2364 return "snapshot (" . join(' ', map
2371 }, $known_snapshot_formats{$_}{'display'})
2372 , @snapshot_fmts) . ")";
2373 } elsif ($num_fmts == 1) {
2374 # A single "snapshot" link whose tooltip bears the format name.
2376 my ($fmt) = @snapshot_fmts;
2382 snapshot_format
=>$fmt
2384 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
2386 } else { # $num_fmts == 0
2391 ## ......................................................................
2392 ## functions returning values to be passed, perhaps after some
2393 ## transformation, to other functions; e.g. returning arguments to href()
2395 # returns hash to be passed to href to generate gitweb URL
2396 # in -title key it returns description of link
2398 my $format = shift || 'Atom';
2399 my %res = (action
=> lc($format));
2401 # feed links are possible only for project views
2402 return unless (defined $project);
2403 # some views should link to OPML, or to generic project feed,
2404 # or don't have specific feed yet (so they should use generic)
2405 return if (!$action || $action =~ /^(?:tags|heads|forks|tag|search)$/x);
2408 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
2409 # from tag links; this also makes possible to detect branch links
2410 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
2411 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
2414 # find log type for feed description (title)
2416 if (defined $file_name) {
2417 $type = "history of $file_name";
2418 $type .= "/" if ($action eq 'tree');
2419 $type .= " on '$branch'" if (defined $branch);
2421 $type = "log of $branch" if (defined $branch);
2424 $res{-title
} = $type;
2425 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
2426 $res{'file_name'} = $file_name;
2431 ## ----------------------------------------------------------------------
2432 ## git utility subroutines, invoking git commands
2434 # returns path to the core git executable and the --git-dir parameter as list
2436 $number_of_git_cmds++;
2437 return $GIT, '--git-dir='.$git_dir;
2440 # quote the given arguments for passing them to the shell
2441 # quote_command("command", "arg 1", "arg with ' and ! characters")
2442 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2443 # Try to avoid using this function wherever possible.
2446 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
2449 # get HEAD ref of given project as hash
2450 sub git_get_head_hash
{
2451 return git_get_full_hash
(shift, 'HEAD');
2454 sub git_get_full_hash
{
2455 return git_get_hash
(@_);
2458 sub git_get_short_hash
{
2459 return git_get_hash
(@_, '--short=7');
2463 my ($project, $hash, @options) = @_;
2464 my $o_git_dir = $git_dir;
2466 $git_dir = "$projectroot/$project";
2467 if (open my $fd, '-|', git_cmd
(), 'rev-parse',
2468 '--verify', '-q', @options, $hash) {
2470 chomp $retval if defined $retval;
2473 if (defined $o_git_dir) {
2474 $git_dir = $o_git_dir;
2479 # get type of given object
2483 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
2485 close $fd or return;
2490 # repository configuration
2491 our $config_file = '';
2494 # store multiple values for single key as anonymous array reference
2495 # single values stored directly in the hash, not as [ <value> ]
2496 sub hash_set_multi
{
2497 my ($hash, $key, $value) = @_;
2499 if (!exists $hash->{$key}) {
2500 $hash->{$key} = $value;
2501 } elsif (!ref $hash->{$key}) {
2502 $hash->{$key} = [ $hash->{$key}, $value ];
2504 push @
{$hash->{$key}}, $value;
2508 # return hash of git project configuration
2509 # optionally limited to some section, e.g. 'gitweb'
2510 sub git_parse_project_config
{
2511 my $section_regexp = shift;
2516 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
2519 while (my $keyval = <$fh>) {
2521 my ($key, $value) = split(/\n/, $keyval, 2);
2523 hash_set_multi
(\
%config, $key, $value)
2524 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2531 # convert config value to boolean: 'true' or 'false'
2532 # no value, number > 0, 'true' and 'yes' values are true
2533 # rest of values are treated as false (never as error)
2534 sub config_to_bool
{
2537 return 1 if !defined $val; # section.key
2539 # strip leading and trailing whitespace
2543 return (($val =~ /^\d+$/ && $val) || # section.key = 1
2544 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2547 # convert config value to simple decimal number
2548 # an optional value suffix of 'k', 'm', or 'g' will cause the value
2549 # to be multiplied by 1024, 1048576, or 1073741824
2553 # strip leading and trailing whitespace
2557 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2559 # unknown unit is treated as 1
2560 return $num * ($unit eq 'g' ?
1073741824 :
2561 $unit eq 'm' ?
1048576 :
2562 $unit eq 'k' ?
1024 : 1);
2567 # convert config value to array reference, if needed
2568 sub config_to_multi
{
2571 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
2574 sub git_get_project_config
{
2575 my ($key, $type) = @_;
2577 return unless defined $git_dir;
2580 return unless ($key);
2581 # only subsection, if exists, is case sensitive,
2582 # and not lowercased by 'git config -z -l'
2583 if (my ($hi, $mi, $lo) = ($key =~ /^([^.]*)\.(.*)\.([^.]*)$/)) {
2584 $key = join(".", lc($hi), $mi, lc($lo));
2588 $key =~ s/^gitweb\.//;
2589 return if ($key =~ m/\W/);
2592 if (defined $type) {
2595 unless ($type eq 'bool' || $type eq 'int');
2599 if (!defined $config_file ||
2600 $config_file ne "$git_dir/config") {
2601 %config = git_parse_project_config
('gitweb');
2602 $config_file = "$git_dir/config";
2605 # check if config variable (key) exists
2606 return unless exists $config{"gitweb.$key"};
2609 if (!defined $type) {
2610 return $config{"gitweb.$key"};
2611 } elsif ($type eq 'bool') {
2612 # backward compatibility: 'git config --bool' returns true/false
2613 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
2614 } elsif ($type eq 'int') {
2615 return config_to_int
($config{"gitweb.$key"});
2617 return $config{"gitweb.$key"};
2620 # get hash of given path at given ref
2621 sub git_get_hash_by_path
{
2623 my $path = shift || return undef;
2628 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
2629 or die_error
(500, "Open git-ls-tree failed");
2631 close $fd or return undef;
2633 if (!defined $line) {
2634 # there is no tree or hash given by $path at $base
2638 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2639 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2640 if (defined $type && $type ne $2) {
2641 # type doesn't match
2647 # get path of entry with given hash at given tree-ish (ref)
2648 # used to get 'from' filename for combined diff (merge commit) for renames
2649 sub git_get_path_by_hash
{
2650 my $base = shift || return;
2651 my $hash = shift || return;
2655 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
2657 while (my $line = <$fd>) {
2660 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2661 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2662 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2671 ## ......................................................................
2672 ## git utility functions, directly accessing git repository
2674 # get the value of config variable either from file named as the variable
2675 # itself in the repository ($GIT_DIR/$name file), or from gitweb.$name
2676 # configuration variable in the repository config file.
2677 sub git_get_file_or_project_config
{
2678 my ($path, $name) = @_;
2680 $git_dir = "$projectroot/$path";
2681 open my $fd, '<', "$git_dir/$name"
2682 or return git_get_project_config
($name);
2685 if (defined $conf) {
2691 sub git_get_project_description
{
2693 return git_get_file_or_project_config
($path, 'description');
2696 sub git_get_project_category
{
2698 return git_get_file_or_project_config
($path, 'category');
2702 # supported formats:
2703 # * $GIT_DIR/ctags/<tagname> file (in 'ctags' subdirectory)
2704 # - if its contents is a number, use it as tag weight,
2705 # - otherwise add a tag with weight 1
2706 # * $GIT_DIR/ctags file, each line is a tag (with weight 1)
2707 # the same value multiple times increases tag weight
2708 # * `gitweb.ctag' multi-valued repo config variable
2709 sub git_get_project_ctags
{
2710 my $project = shift;
2713 $git_dir = "$projectroot/$project";
2714 if (opendir my $dh, "$git_dir/ctags") {
2715 my @files = grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir($dh);
2716 foreach my $tagfile (@files) {
2717 open my $ct, '<', $tagfile
2723 (my $ctag = $tagfile) =~ s
#.*/##;
2724 if ($val =~ /^\d+$/) {
2725 $ctags->{$ctag} = $val;
2727 $ctags->{$ctag} = 1;
2732 } elsif (open my $fh, '<', "$git_dir/ctags") {
2733 while (my $line = <$fh>) {
2735 $ctags->{$line}++ if $line;
2740 my $taglist = config_to_multi
(git_get_project_config
('ctag'));
2741 foreach my $tag (@
$taglist) {
2749 # return hash, where keys are content tags ('ctags'),
2750 # and values are sum of weights of given tag in every project
2751 sub git_gather_all_ctags
{
2752 my $projects = shift;
2755 foreach my $p (@
$projects) {
2756 foreach my $ct (keys %{$p->{'ctags'}}) {
2757 $ctags->{$ct} += $p->{'ctags'}->{$ct};
2764 sub git_populate_project_tagcloud
{
2767 # First, merge different-cased tags; tags vote on casing
2769 foreach (keys %$ctags) {
2770 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2771 if (not $ctags_lc{lc $_}->{topcount
}
2772 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2773 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2774 $ctags_lc{lc $_}->{topname
} = $_;
2779 my $matched = $input_params{'ctag'};
2780 if (eval { require HTML
::TagCloud
; 1; }) {
2781 $cloud = HTML
::TagCloud
->new;
2782 foreach my $ctag (sort keys %ctags_lc) {
2783 # Pad the title with spaces so that the cloud looks
2785 my $title = esc_html
($ctags_lc{$ctag}->{topname
});
2786 $title =~ s/ / /g;
2787 $title =~ s/^/ /g;
2788 $title =~ s/$/ /g;
2789 if (defined $matched && $matched eq $ctag) {
2790 $title = qq(<span
class="match">$title</span
>);
2792 $cloud->add($title, href
(project
=>undef, ctag
=>$ctag),
2793 $ctags_lc{$ctag}->{count
});
2797 foreach my $ctag (keys %ctags_lc) {
2798 my $title = esc_html
($ctags_lc{$ctag}->{topname
}, -nbsp
=>1);
2799 if (defined $matched && $matched eq $ctag) {
2800 $title = qq(<span
class="match">$title</span
>);
2802 $cloud->{$ctag}{count
} = $ctags_lc{$ctag}->{count
};
2803 $cloud->{$ctag}{ctag
} =
2804 $cgi->a({-href
=>href
(project
=>undef, ctag
=>$ctag)}, $title);
2810 sub git_show_project_tagcloud
{
2811 my ($cloud, $count) = @_;
2812 if (ref $cloud eq 'HTML::TagCloud') {
2813 return $cloud->html_and_css($count);
2815 my @tags = sort { $cloud->{$a}->{'count'} <=> $cloud->{$b}->{'count'} } keys %$cloud;
2817 '<div id="htmltagcloud"'.($project ?
'' : ' align="center"').'>' .
2819 $cloud->{$_}->{'ctag'}
2820 } splice(@tags, 0, $count)) .
2825 sub git_get_project_url_list
{
2828 $git_dir = "$projectroot/$path";
2829 open my $fd, '<', "$git_dir/cloneurl"
2830 or return wantarray ?
2831 @
{ config_to_multi
(git_get_project_config
('url')) } :
2832 config_to_multi
(git_get_project_config
('url'));
2833 my @git_project_url_list = map { chomp; $_ } <$fd>;
2836 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2839 sub git_get_projects_list
{
2840 my $filter = shift || '';
2843 $filter =~ s/\.git$//;
2845 if (-d
$projects_list) {
2846 # search in directory
2847 my $dir = $projects_list;
2848 # remove the trailing "/"
2850 my $pfxlen = length("$dir");
2851 my $pfxdepth = ($dir =~ tr!/!!);
2852 # when filtering, search only given subdirectory
2859 follow_fast
=> 1, # follow symbolic links
2860 follow_skip
=> 2, # ignore duplicates
2861 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2864 our $project_maxdepth;
2866 # skip project-list toplevel, if we get it.
2867 return if (m!^[/.]$!);
2868 # only directories can be git repositories
2869 return unless (-d
$_);
2870 # don't traverse too deep (Find is super slow on os x)
2871 # $project_maxdepth excludes depth of $projectroot
2872 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2873 $File::Find
::prune
= 1;
2877 my $path = substr($File::Find
::name
, $pfxlen + 1);
2878 # we check related file in $projectroot
2879 if (check_export_ok
("$projectroot/$path")) {
2880 push @list, { path
=> $path };
2881 $File::Find
::prune
= 1;
2886 } elsif (-f
$projects_list) {
2887 # read from file(url-encoded):
2888 # 'git%2Fgit.git Linus+Torvalds'
2889 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2890 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2891 open my $fd, '<', $projects_list or return;
2893 while (my $line = <$fd>) {
2895 my ($path, $owner) = split ' ', $line;
2896 $path = unescape
($path);
2897 $owner = unescape
($owner);
2898 if (!defined $path) {
2901 # if $filter is rpovided, check if $path begins with $filter
2902 if ($filter && $path !~ m!^\Q$filter\E/!) {
2905 if (check_export_ok
("$projectroot/$path")) {
2908 owner
=> to_utf8
($owner),
2918 # written with help of Tree::Trie module (Perl Artistic License, GPL compatibile)
2919 # as side effects it sets 'forks' field to list of forks for forked projects
2920 sub filter_forks_from_projects_list
{
2921 my $projects = shift;
2923 my %trie; # prefix tree of directories (path components)
2924 # generate trie out of those directories that might contain forks
2925 foreach my $pr (@
$projects) {
2926 my $path = $pr->{'path'};
2927 $path =~ s/\.git$//; # forks of 'repo.git' are in 'repo/' directory
2928 next if ($path =~ m!/$!); # skip non-bare repositories, e.g. 'repo/.git'
2929 next unless ($path); # skip '.git' repository: tests, git-instaweb
2930 next unless (-d
"$projectroot/$path"); # containing directory exists
2931 $pr->{'forks'} = []; # there can be 0 or more forks of project
2934 my @dirs = split('/', $path);
2935 # walk the trie, until either runs out of components or out of trie
2937 while (scalar @dirs &&
2938 exists($ref->{$dirs[0]})) {
2939 $ref = $ref->{shift @dirs};
2941 # create rest of trie structure from rest of components
2942 foreach my $dir (@dirs) {
2943 $ref = $ref->{$dir} = {};
2945 # create end marker, store $pr as a data
2946 $ref->{''} = $pr if (!exists $ref->{''});
2949 # filter out forks, by finding shortest prefix match for paths
2952 foreach my $pr (@
$projects) {
2956 foreach my $dir (split('/', $pr->{'path'})) {
2957 if (exists $ref->{''}) {
2958 # found [shortest] prefix, is a fork - skip it
2959 push @
{$ref->{''}{'forks'}}, $pr;
2962 if (!exists $ref->{$dir}) {
2963 # not in trie, cannot have prefix, not a fork
2964 push @filtered, $pr;
2967 # If the dir is there, we just walk one step down the trie.
2968 $ref = $ref->{$dir};
2970 # we ran out of trie
2971 # (shouldn't happen: it's either no match, or end marker)
2972 push @filtered, $pr;
2978 # note: fill_project_list_info must be run first,
2979 # for 'descr_long' and 'ctags' to be filled
2980 sub search_projects_list
{
2981 my ($projlist, %opts) = @_;
2982 my $tagfilter = $opts{'tagfilter'};
2983 my $search_re = $opts{'search_regexp'};
2986 unless ($tagfilter || $search_re);
2990 foreach my $pr (@
$projlist) {
2993 next unless ref($pr->{'ctags'}) eq 'HASH';
2995 grep { lc($_) eq lc($tagfilter) } keys %{$pr->{'ctags'}};
3000 $pr->{'path'} =~ /$search_re/ ||
3001 $pr->{'descr_long'} =~ /$search_re/;
3004 push @projects, $pr;
3010 our $gitweb_project_owner = undef;
3011 sub git_get_project_list_from_file
{
3013 return if (defined $gitweb_project_owner);
3015 $gitweb_project_owner = {};
3016 # read from file (url-encoded):
3017 # 'git%2Fgit.git Linus+Torvalds'
3018 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
3019 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
3020 if (-f
$projects_list) {
3021 open(my $fd, '<', $projects_list);
3022 while (my $line = <$fd>) {
3024 my ($pr, $ow) = split ' ', $line;
3025 $pr = unescape
($pr);
3026 $ow = unescape
($ow);
3027 $gitweb_project_owner->{$pr} = to_utf8
($ow);
3033 sub git_get_project_owner
{
3034 my $project = shift;
3037 return undef unless $project;
3038 $git_dir = "$projectroot/$project";
3040 if (!defined $gitweb_project_owner) {
3041 git_get_project_list_from_file
();
3044 if (exists $gitweb_project_owner->{$project}) {
3045 $owner = $gitweb_project_owner->{$project};
3047 if (!defined $owner){
3048 $owner = git_get_project_config
('owner');
3050 if (!defined $owner) {
3051 $owner = get_file_owner
("$git_dir");
3057 sub git_get_last_activity
{
3061 $git_dir = "$projectroot/$path";
3062 open($fd, "-|", git_cmd
(), 'for-each-ref',
3063 '--format=%(committer)',
3064 '--sort=-committerdate',
3066 'refs/heads') or return;
3067 my $most_recent = <$fd>;
3068 close $fd or return;
3069 if (defined $most_recent &&
3070 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
3072 my $age = time - $timestamp;
3073 return ($age, age_string
($age));
3075 return (undef, undef);
3078 # Implementation note: when a single remote is wanted, we cannot use 'git
3079 # remote show -n' because that command always work (assuming it's a remote URL
3080 # if it's not defined), and we cannot use 'git remote show' because that would
3081 # try to make a network roundtrip. So the only way to find if that particular
3082 # remote is defined is to walk the list provided by 'git remote -v' and stop if
3083 # and when we find what we want.
3084 sub git_get_remotes_list
{
3088 open my $fd, '-|' , git_cmd
(), 'remote', '-v';
3090 while (my $remote = <$fd>) {
3092 $remote =~ s!\t(.*?)\s+\((\w+)\)$!!;
3093 next if $wanted and not $remote eq $wanted;
3094 my ($url, $key) = ($1, $2);
3096 $remotes{$remote} ||= { 'heads' => () };
3097 $remotes{$remote}{$key} = $url;
3099 close $fd or return;
3100 return wantarray ?
%remotes : \
%remotes;
3103 # Takes a hash of remotes as first parameter and fills it by adding the
3104 # available remote heads for each of the indicated remotes.
3105 sub fill_remote_heads
{
3106 my $remotes = shift;
3107 my @heads = map { "remotes/$_" } keys %$remotes;
3108 my @remoteheads = git_get_heads_list
(undef, @heads);
3109 foreach my $remote (keys %$remotes) {
3110 $remotes->{$remote}{'heads'} = [ grep {
3111 $_->{'name'} =~ s!^$remote/!!
3116 sub git_get_references
{
3117 my $type = shift || "";
3119 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
3120 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
3121 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
3122 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
3125 while (my $line = <$fd>) {
3127 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
3128 if (defined $refs{$1}) {
3129 push @
{$refs{$1}}, $2;
3135 close $fd or return;
3139 sub git_get_rev_name_tags
{
3140 my $hash = shift || return undef;
3142 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
3144 my $name_rev = <$fd>;
3147 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
3150 # catches also '$hash undefined' output
3155 ## ----------------------------------------------------------------------
3156 ## parse to hash functions
3160 my $tz = shift || "-0000";
3163 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
3164 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
3165 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
3166 $date{'hour'} = $hour;
3167 $date{'minute'} = $min;
3168 $date{'mday'} = $mday;
3169 $date{'day'} = $days[$wday];
3170 $date{'month'} = $months[$mon];
3171 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
3172 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
3173 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
3174 $mday, $months[$mon], $hour ,$min;
3175 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
3176 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
3178 my ($tz_sign, $tz_hour, $tz_min) =
3179 ($tz =~ m/^([-+])(\d\d)(\d\d)$/);
3180 $tz_sign = ($tz_sign eq '-' ?
-1 : +1);
3181 my $local = $epoch + $tz_sign*((($tz_hour*60) + $tz_min)*60);
3182 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
3183 $date{'hour_local'} = $hour;
3184 $date{'minute_local'} = $min;
3185 $date{'tz_local'} = $tz;
3186 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
3187 1900+$year, $mon+1, $mday,
3188 $hour, $min, $sec, $tz);
3197 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
3198 $tag{'id'} = $tag_id;
3199 while (my $line = <$fd>) {
3201 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
3202 $tag{'object'} = $1;
3203 } elsif ($line =~ m/^type (.+)$/) {
3205 } elsif ($line =~ m/^tag (.+)$/) {
3207 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
3208 $tag{'author'} = $1;
3209 $tag{'author_epoch'} = $2;
3210 $tag{'author_tz'} = $3;
3211 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3212 $tag{'author_name'} = $1;
3213 $tag{'author_email'} = $2;
3215 $tag{'author_name'} = $tag{'author'};
3217 } elsif ($line =~ m/--BEGIN/) {
3218 push @comment, $line;
3220 } elsif ($line eq "") {
3224 push @comment, <$fd>;
3225 $tag{'comment'} = \
@comment;
3226 close $fd or return;
3227 if (!defined $tag{'name'}) {
3233 sub parse_commit_text
{
3234 my ($commit_text, $withparents) = @_;
3235 my @commit_lines = split '\n', $commit_text;
3238 pop @commit_lines; # Remove '\0'
3240 if (! @commit_lines) {
3244 my $header = shift @commit_lines;
3245 if ($header !~ m/^[0-9a-fA-F]{40}/) {
3248 ($co{'id'}, my @parents) = split ' ', $header;
3249 while (my $line = shift @commit_lines) {
3250 last if $line eq "\n";
3251 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
3253 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
3255 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
3256 $co{'author'} = to_utf8
($1);
3257 $co{'author_epoch'} = $2;
3258 $co{'author_tz'} = $3;
3259 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3260 $co{'author_name'} = $1;
3261 $co{'author_email'} = $2;
3263 $co{'author_name'} = $co{'author'};
3265 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
3266 $co{'committer'} = to_utf8
($1);
3267 $co{'committer_epoch'} = $2;
3268 $co{'committer_tz'} = $3;
3269 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
3270 $co{'committer_name'} = $1;
3271 $co{'committer_email'} = $2;
3273 $co{'committer_name'} = $co{'committer'};
3277 if (!defined $co{'tree'}) {
3280 $co{'parents'} = \
@parents;
3281 $co{'parent'} = $parents[0];
3283 foreach my $title (@commit_lines) {
3286 $co{'title'} = chop_str
($title, 80, 5);
3287 # remove leading stuff of merges to make the interesting part visible
3288 if (length($title) > 50) {
3289 $title =~ s/^Automatic //;
3290 $title =~ s/^merge (of|with) /Merge ... /i;
3291 if (length($title) > 50) {
3292 $title =~ s/(http|rsync):\/\///;
3294 if (length($title) > 50) {
3295 $title =~ s/(master|www|rsync)\.//;
3297 if (length($title) > 50) {
3298 $title =~ s/kernel.org:?//;
3300 if (length($title) > 50) {
3301 $title =~ s/\/pub\/scm//;
3304 $co{'title_short'} = chop_str
($title, 50, 5);
3308 if (! defined $co{'title'} || $co{'title'} eq "") {
3309 $co{'title'} = $co{'title_short'} = '(no commit message)';
3311 # remove added spaces
3312 foreach my $line (@commit_lines) {
3315 $co{'comment'} = \
@commit_lines;
3317 my $age = time - $co{'committer_epoch'};
3319 $co{'age_string'} = age_string
($age);
3320 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
3321 if ($age > 60*60*24*7*2) {
3322 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3323 $co{'age_string_age'} = $co{'age_string'};
3325 $co{'age_string_date'} = $co{'age_string'};
3326 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3332 my ($commit_id) = @_;
3337 open my $fd, "-|", git_cmd
(), "rev-list",
3343 or die_error
(500, "Open git-rev-list failed");
3344 %co = parse_commit_text
(<$fd>, 1);
3351 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
3359 open my $fd, "-|", git_cmd
(), "rev-list",
3362 ("--max-count=" . $maxcount),
3363 ("--skip=" . $skip),
3367 ($filename ?
($filename) : ())
3368 or die_error
(500, "Open git-rev-list failed");
3369 while (my $line = <$fd>) {
3370 my %co = parse_commit_text
($line);
3375 return wantarray ?
@cos : \
@cos;
3378 # parse line of git-diff-tree "raw" output
3379 sub parse_difftree_raw_line
{
3383 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3384 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
3385 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
3386 $res{'from_mode'} = $1;
3387 $res{'to_mode'} = $2;
3388 $res{'from_id'} = $3;
3390 $res{'status'} = $5;
3391 $res{'similarity'} = $6;
3392 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
3393 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
3395 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
3398 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3399 # combined diff (for merge commit)
3400 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
3401 $res{'nparents'} = length($1);
3402 $res{'from_mode'} = [ split(' ', $2) ];
3403 $res{'to_mode'} = pop @
{$res{'from_mode'}};
3404 $res{'from_id'} = [ split(' ', $3) ];
3405 $res{'to_id'} = pop @
{$res{'from_id'}};
3406 $res{'status'} = [ split('', $4) ];
3407 $res{'to_file'} = unquote
($5);
3409 # 'c512b523472485aef4fff9e57b229d9d243c967f'
3410 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
3411 $res{'commit'} = $1;
3414 return wantarray ?
%res : \
%res;
3417 # wrapper: return parsed line of git-diff-tree "raw" output
3418 # (the argument might be raw line, or parsed info)
3419 sub parsed_difftree_line
{
3420 my $line_or_ref = shift;
3422 if (ref($line_or_ref) eq "HASH") {
3423 # pre-parsed (or generated by hand)
3424 return $line_or_ref;
3426 return parse_difftree_raw_line
($line_or_ref);
3430 # parse line of git-ls-tree output
3431 sub parse_ls_tree_line
{
3437 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
3438 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40}) +(-|[0-9]+)\t(.+)$/s;
3447 $res{'name'} = unquote
($5);
3450 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
3451 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
3459 $res{'name'} = unquote
($4);
3463 return wantarray ?
%res : \
%res;
3466 # generates _two_ hashes, references to which are passed as 2 and 3 argument
3467 sub parse_from_to_diffinfo
{
3468 my ($diffinfo, $from, $to, @parents) = @_;
3470 if ($diffinfo->{'nparents'}) {
3472 $from->{'file'} = [];
3473 $from->{'href'} = [];
3474 fill_from_file_info
($diffinfo, @parents)
3475 unless exists $diffinfo->{'from_file'};
3476 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
3477 $from->{'file'}[$i] =
3478 defined $diffinfo->{'from_file'}[$i] ?
3479 $diffinfo->{'from_file'}[$i] :
3480 $diffinfo->{'to_file'};
3481 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3482 $from->{'href'}[$i] = href
(action
=>"blob",
3483 hash_base
=>$parents[$i],
3484 hash
=>$diffinfo->{'from_id'}[$i],
3485 file_name
=>$from->{'file'}[$i]);
3487 $from->{'href'}[$i] = undef;
3491 # ordinary (not combined) diff
3492 $from->{'file'} = $diffinfo->{'from_file'};
3493 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3494 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
3495 hash
=>$diffinfo->{'from_id'},
3496 file_name
=>$from->{'file'});
3498 delete $from->{'href'};
3502 $to->{'file'} = $diffinfo->{'to_file'};
3503 if (!is_deleted
($diffinfo)) { # file exists in result
3504 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
3505 hash
=>$diffinfo->{'to_id'},
3506 file_name
=>$to->{'file'});
3508 delete $to->{'href'};
3512 ## ......................................................................
3513 ## parse to array of hashes functions
3515 sub git_get_heads_list
{
3516 my ($limit, @classes) = @_;
3517 @classes = ('heads') unless @classes;
3518 my @patterns = map { "refs/$_" } @classes;
3521 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3522 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
3523 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
3526 while (my $line = <$fd>) {
3530 my ($refinfo, $committerinfo) = split(/\0/, $line);
3531 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3532 my ($committer, $epoch, $tz) =
3533 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
3534 $ref_item{'fullname'} = $name;
3535 $name =~ s!^refs/(?:head|remote)s/!!;
3537 $ref_item{'name'} = $name;
3538 $ref_item{'id'} = $hash;
3539 $ref_item{'title'} = $title || '(no commit message)';
3540 $ref_item{'epoch'} = $epoch;
3542 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3544 $ref_item{'age'} = "unknown";
3547 push @headslist, \
%ref_item;
3551 return wantarray ?
@headslist : \
@headslist;
3554 sub git_get_tags_list
{
3558 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3559 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
3560 '--format=%(objectname) %(objecttype) %(refname) '.
3561 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3564 while (my $line = <$fd>) {
3568 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3569 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3570 my ($creator, $epoch, $tz) =
3571 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
3572 $ref_item{'fullname'} = $name;
3573 $name =~ s!^refs/tags/!!;
3575 $ref_item{'type'} = $type;
3576 $ref_item{'id'} = $id;
3577 $ref_item{'name'} = $name;
3578 if ($type eq "tag") {
3579 $ref_item{'subject'} = $title;
3580 $ref_item{'reftype'} = $reftype;
3581 $ref_item{'refid'} = $refid;
3583 $ref_item{'reftype'} = $type;
3584 $ref_item{'refid'} = $id;
3587 if ($type eq "tag" || $type eq "commit") {
3588 $ref_item{'epoch'} = $epoch;
3590 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3592 $ref_item{'age'} = "unknown";
3596 push @tagslist, \
%ref_item;
3600 return wantarray ?
@tagslist : \
@tagslist;
3603 ## ----------------------------------------------------------------------
3604 ## filesystem-related functions
3606 sub get_file_owner
{
3609 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3610 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3611 if (!defined $gcos) {
3615 $owner =~ s/[,;].*$//;
3616 return to_utf8
($owner);
3619 # assume that file exists
3621 my $filename = shift;
3623 open my $fd, '<', $filename;
3624 print map { to_utf8
($_) } <$fd>;
3628 ## ......................................................................
3629 ## mimetype related functions
3631 sub mimetype_guess_file
{
3632 my $filename = shift;
3633 my $mimemap = shift;
3634 -r
$mimemap or return undef;
3637 open(my $mh, '<', $mimemap) or return undef;
3639 next if m/^#/; # skip comments
3640 my ($mimetype, @exts) = split(/\s+/);
3641 foreach my $ext (@exts) {
3642 $mimemap{$ext} = $mimetype;
3647 $filename =~ /\.([^.]*)$/;
3648 return $mimemap{$1};
3651 sub mimetype_guess
{
3652 my $filename = shift;
3654 $filename =~ /\./ or return undef;
3656 if ($mimetypes_file) {
3657 my $file = $mimetypes_file;
3658 if ($file !~ m!^/!) { # if it is relative path
3659 # it is relative to project
3660 $file = "$projectroot/$project/$file";
3662 $mime = mimetype_guess_file
($filename, $file);
3664 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
3670 my $filename = shift;
3673 my $mime = mimetype_guess
($filename);
3674 $mime and return $mime;
3678 return $default_blob_plain_mimetype unless $fd;
3681 return 'text/plain';
3682 } elsif (! $filename) {
3683 return 'application/octet-stream';
3684 } elsif ($filename =~ m/\.png$/i) {
3686 } elsif ($filename =~ m/\.gif$/i) {
3688 } elsif ($filename =~ m/\.jpe?g$/i) {
3689 return 'image/jpeg';
3691 return 'application/octet-stream';
3695 sub blob_contenttype
{
3696 my ($fd, $file_name, $type) = @_;
3698 $type ||= blob_mimetype
($fd, $file_name);
3699 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3700 $type .= "; charset=$default_text_plain_charset";
3706 # guess file syntax for syntax highlighting; return undef if no highlighting
3707 # the name of syntax can (in the future) depend on syntax highlighter used
3708 sub guess_file_syntax
{
3709 my ($highlight, $mimetype, $file_name) = @_;
3710 return undef unless ($highlight && defined $file_name);
3711 my $basename = basename
($file_name, '.in');
3712 return $highlight_basename{$basename}
3713 if exists $highlight_basename{$basename};
3715 $basename =~ /\.([^.]*)$/;
3716 my $ext = $1 or return undef;
3717 return $highlight_ext{$ext}
3718 if exists $highlight_ext{$ext};
3723 # run highlighter and return FD of its output,
3724 # or return original FD if no highlighting
3725 sub run_highlighter
{
3726 my ($fd, $highlight, $syntax) = @_;
3727 return $fd unless ($highlight && defined $syntax);
3730 open $fd, quote_command
(git_cmd
(), "cat-file", "blob", $hash)." | ".
3731 quote_command
($highlight_bin).
3732 " --replace-tabs=8 --fragment --syntax $syntax |"
3733 or die_error
(500, "Couldn't open file or run syntax highlighter");
3737 ## ======================================================================
3738 ## functions printing HTML: header, footer, error page
3740 sub get_page_title
{
3741 my $title = to_utf8
($site_name);
3743 return $title unless (defined $project);
3744 $title .= " - " . to_utf8
($project);
3746 return $title unless (defined $action);
3747 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
3749 return $title unless (defined $file_name);
3750 $title .= " - " . esc_path
($file_name);
3751 if ($action eq "tree" && $file_name !~ m
|/$|) {
3758 sub get_content_type_html
{
3759 # require explicit support from the UA if we are to send the page as
3760 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
3761 # we have to do this because MSIE sometimes globs '*/*', pretending to
3762 # support xhtml+xml but choking when it gets what it asked for.
3763 if (defined $cgi->http('HTTP_ACCEPT') &&
3764 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
3765 $cgi->Accept('application/xhtml+xml') != 0) {
3766 return 'application/xhtml+xml';
3772 sub print_feed_meta
{
3773 if (defined $project) {
3774 my %href_params = get_feed_info
();
3775 if (!exists $href_params{'-title'}) {
3776 $href_params{'-title'} = 'log';
3779 foreach my $format (qw(RSS Atom)) {
3780 my $type = lc($format);
3782 '-rel' => 'alternate',
3783 '-title' => esc_attr
("$project - $href_params{'-title'} - $format feed"),
3784 '-type' => "application/$type+xml"
3787 $href_params{'action'} = $type;
3788 $link_attr{'-href'} = href
(%href_params);
3790 "rel=\"$link_attr{'-rel'}\" ".
3791 "title=\"$link_attr{'-title'}\" ".
3792 "href=\"$link_attr{'-href'}\" ".
3793 "type=\"$link_attr{'-type'}\" ".
3796 $href_params{'extra_options'} = '--no-merges';
3797 $link_attr{'-href'} = href
(%href_params);
3798 $link_attr{'-title'} .= ' (no merges)';
3800 "rel=\"$link_attr{'-rel'}\" ".
3801 "title=\"$link_attr{'-title'}\" ".
3802 "href=\"$link_attr{'-href'}\" ".
3803 "type=\"$link_attr{'-type'}\" ".
3808 printf('<link rel="alternate" title="%s projects list" '.
3809 'href="%s" type="text/plain; charset=utf-8" />'."\n",
3810 esc_attr
($site_name), href
(project
=>undef, action
=>"project_index"));
3811 printf('<link rel="alternate" title="%s projects feeds" '.
3812 'href="%s" type="text/x-opml" />'."\n",
3813 esc_attr
($site_name), href
(project
=>undef, action
=>"opml"));
3817 sub print_header_links
{
3820 # print out each stylesheet that exist, providing backwards capability
3821 # for those people who defined $stylesheet in a config file
3822 if (defined $stylesheet) {
3823 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3825 foreach my $stylesheet (@stylesheets) {
3826 next unless $stylesheet;
3827 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3831 if ($status eq '200 OK');
3832 if (defined $favicon) {
3833 print qq(<link rel
="shortcut icon" href
=").esc_url($favicon).qq(" type
="image/png" />\n);
3837 sub print_nav_breadcrumbs
{
3840 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
3841 if (defined $project) {
3842 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
3843 if (defined $action) {
3844 my $action_print = $action ;
3845 if (defined $opts{-action_extra
}) {
3846 $action_print = $cgi->a({-href
=> href
(action
=>$action)},
3849 print " / $action_print";
3851 if (defined $opts{-action_extra
}) {
3852 print " / $opts{-action_extra}";
3858 sub print_search_form
{
3859 if (!defined $searchtext) {
3863 if (defined $hash_base) {
3864 $search_hash = $hash_base;
3865 } elsif (defined $hash) {
3866 $search_hash = $hash;
3868 $search_hash = "HEAD";
3870 my $action = $my_uri;
3871 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3872 if ($use_pathinfo) {
3873 $action .= "/".esc_url
($project);
3875 print $cgi->startform(-method
=> "get", -action
=> $action) .
3876 "<div class=\"search\">\n" .
3878 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3879 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3880 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3881 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3882 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3883 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3885 $cgi->textfield(-name
=> "s", -value
=> $searchtext, -override
=> 1) . "\n" .
3886 "<span title=\"Extended regular expression\">" .
3887 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3888 -checked
=> $search_use_regexp) .
3891 $cgi->end_form() . "\n";
3894 sub git_header_html
{
3895 my $status = shift || "200 OK";
3896 my $expires = shift;
3899 my $title = get_page_title
();
3900 my $content_type = get_content_type_html
();
3901 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
3902 -status
=> $status, -expires
=> $expires)
3903 unless ($opts{'-no_http_header'});
3904 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
3906 <?xml version="1.0" encoding="utf-8"?>
3907 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3908 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
3909 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
3910 <!-- git core binaries version $git_version -->
3912 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
3913 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
3914 <meta name="robots" content="index, nofollow"/>
3915 <title>$title</title>
3917 # the stylesheet, favicon etc urls won't work correctly with path_info
3918 # unless we set the appropriate base URL
3919 if ($ENV{'PATH_INFO'}) {
3920 print "<base href=\"".esc_url
($base_url)."\" />\n";
3922 print_header_links
($status);
3924 if (defined $site_html_head_string) {
3925 print to_utf8
($site_html_head_string);
3931 if (defined $site_header && -f
$site_header) {
3932 insert_file
($site_header);
3935 print "<div class=\"page_header\">\n";
3936 if (defined $logo) {
3937 print $cgi->a({-href
=> esc_url
($logo_url),
3938 -title
=> $logo_label},
3939 $cgi->img({-src
=> esc_url
($logo),
3940 -width
=> 72, -height
=> 27,
3942 -class => "logo"}));
3944 print_nav_breadcrumbs
(%opts);
3947 my $have_search = gitweb_check_feature
('search');
3948 if (defined $project && $have_search) {
3949 print_search_form
();
3953 sub git_footer_html
{
3954 my $feed_class = 'rss_logo';
3956 print "<div class=\"page_footer\">\n";
3957 if (defined $project) {
3958 my $descr = git_get_project_description
($project);
3959 if (defined $descr) {
3960 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3963 my %href_params = get_feed_info
();
3964 if (!%href_params) {
3965 $feed_class .= ' generic';
3967 $href_params{'-title'} ||= 'log';
3969 foreach my $format (qw(RSS Atom)) {
3970 $href_params{'action'} = lc($format);
3971 print $cgi->a({-href
=> href
(%href_params),
3972 -title
=> "$href_params{'-title'} $format feed",
3973 -class => $feed_class}, $format)."\n";
3977 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3978 -class => $feed_class}, "OPML") . " ";
3979 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3980 -class => $feed_class}, "TXT") . "\n";
3982 print "</div>\n"; # class="page_footer"
3984 if (defined $t0 && gitweb_check_feature
('timed')) {
3985 print "<div id=\"generating_info\">\n";
3986 print 'This page took '.
3987 '<span id="generating_time" class="time_span">'.
3988 tv_interval
($t0, [ gettimeofday
() ]).
3991 '<span id="generating_cmd">'.
3992 $number_of_git_cmds.
3993 '</span> git commands '.
3995 print "</div>\n"; # class="page_footer"
3998 if (defined $site_footer && -f
$site_footer) {
3999 insert_file
($site_footer);
4002 print qq!<script type
="text/javascript" src
="!.esc_url($javascript).qq!"></script
>\n!;
4003 if (defined $action &&
4004 $action eq 'blame_incremental') {
4005 print qq!<script type
="text/javascript">\n!.
4006 qq!startBlame
("!. href(action=>"blame_data
", -replay=>1) .qq!",\n!.
4007 qq! "!. href() .qq!");\n!.
4010 my ($jstimezone, $tz_cookie, $datetime_class) =
4011 gitweb_get_feature
('javascript-timezone');
4013 print qq!<script type
="text/javascript">\n!.
4014 qq!window
.onload
= function
() {\n!;
4015 if (gitweb_check_feature
('javascript-actions')) {
4016 print qq! fixLinks
();\n!;
4018 if ($jstimezone && $tz_cookie && $datetime_class) {
4019 print qq! var tz_cookie
= { name
: '$tz_cookie', expires
: 14, path
: '/' };\n!. # in days
4020 qq! onloadTZSetup
('$jstimezone', tz_cookie
, '$datetime_class');\n!;
4030 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
4031 # Example: die_error(404, 'Hash not found')
4032 # By convention, use the following status codes (as defined in RFC 2616):
4033 # 400: Invalid or missing CGI parameters, or
4034 # requested object exists but has wrong type.
4035 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
4036 # this server or project.
4037 # 404: Requested object/revision/project doesn't exist.
4038 # 500: The server isn't configured properly, or
4039 # an internal error occurred (e.g. failed assertions caused by bugs), or
4040 # an unknown error occurred (e.g. the git binary died unexpectedly).
4041 # 503: The server is currently unavailable (because it is overloaded,
4042 # or down for maintenance). Generally, this is a temporary state.
4044 my $status = shift || 500;
4045 my $error = esc_html
(shift) || "Internal Server Error";
4049 my %http_responses = (
4050 400 => '400 Bad Request',
4051 403 => '403 Forbidden',
4052 404 => '404 Not Found',
4053 500 => '500 Internal Server Error',
4054 503 => '503 Service Unavailable',
4056 git_header_html
($http_responses{$status}, undef, %opts);
4058 <div class="page_body">
4063 if (defined $extra) {
4071 unless ($opts{'-error_handler'});
4074 ## ----------------------------------------------------------------------
4075 ## functions printing or outputting HTML: navigation
4077 sub git_print_page_nav
{
4078 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
4079 $extra = '' if !defined $extra; # pager or formats
4081 my @navs = qw(summary shortlog log commit commitdiff tree);
4083 @navs = grep { $_ ne $suppress } @navs;
4086 my %arg = map { $_ => {action
=>$_} } @navs;
4087 if (defined $head) {
4088 for (qw(commit commitdiff)) {
4089 $arg{$_}{'hash'} = $head;
4091 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
4092 for (qw(shortlog log)) {
4093 $arg{$_}{'hash'} = $head;
4098 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
4099 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
4101 my @actions = gitweb_get_feature
('actions');
4104 'n' => $project, # project name
4105 'f' => $git_dir, # project path within filesystem
4106 'h' => $treehead || '', # current hash ('h' parameter)
4107 'b' => $treebase || '', # hash base ('hb' parameter)
4110 my ($label, $link, $pos) = splice(@actions,0,3);
4112 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
4114 $link =~ s/%([%nfhb])/$repl{$1}/g;
4115 $arg{$label}{'_href'} = $link;
4118 print "<div class=\"page_nav\">\n" .
4120 map { $_ eq $current ?
4121 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
4123 print "<br/>\n$extra<br/>\n" .
4127 # returns a submenu for the nagivation of the refs views (tags, heads,
4128 # remotes) with the current view disabled and the remotes view only
4129 # available if the feature is enabled
4130 sub format_ref_views
{
4132 my @ref_views = qw{tags heads
};
4133 push @ref_views, 'remotes' if gitweb_check_feature
('remote_heads');
4134 return join " | ", map {
4135 $_ eq $current ?
$_ :
4136 $cgi->a({-href
=> href
(action
=>$_)}, $_)
4140 sub format_paging_nav
{
4141 my ($action, $page, $has_next_link) = @_;
4147 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)}, "first") .
4149 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
4150 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
4152 $paging_nav .= "first ⋅ prev";
4155 if ($has_next_link) {
4156 $paging_nav .= " ⋅ " .
4157 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
4158 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
4160 $paging_nav .= " ⋅ next";
4166 ## ......................................................................
4167 ## functions printing or outputting HTML: div
4169 sub git_print_header_div
{
4170 my ($action, $title, $hash, $hash_base) = @_;
4173 $args{'action'} = $action;
4174 $args{'hash'} = $hash if $hash;
4175 $args{'hash_base'} = $hash_base if $hash_base;
4177 print "<div class=\"header\">\n" .
4178 $cgi->a({-href
=> href
(%args), -class => "title"},
4179 $title ?
$title : $action) .
4183 sub format_repo_url
{
4184 my ($name, $url) = @_;
4185 return "<tr class=\"metadata_url\"><td>$name</td><td>$url</td></tr>\n";
4188 # Group output by placing it in a DIV element and adding a header.
4189 # Options for start_div() can be provided by passing a hash reference as the
4190 # first parameter to the function.
4191 # Options to git_print_header_div() can be provided by passing an array
4192 # reference. This must follow the options to start_div if they are present.
4193 # The content can be a scalar, which is output as-is, a scalar reference, which
4194 # is output after html escaping, an IO handle passed either as *handle or
4195 # *handle{IO}, or a function reference. In the latter case all following
4196 # parameters will be taken as argument to the content function call.
4197 sub git_print_section
{
4198 my ($div_args, $header_args, $content);
4200 if (ref($arg) eq 'HASH') {
4204 if (ref($arg) eq 'ARRAY') {
4205 $header_args = $arg;
4210 print $cgi->start_div($div_args);
4211 git_print_header_div
(@
$header_args);
4213 if (ref($content) eq 'CODE') {
4215 } elsif (ref($content) eq 'SCALAR') {
4216 print esc_html
($$content);
4217 } elsif (ref($content) eq 'GLOB' or ref($content) eq 'IO::Handle') {
4219 } elsif (!ref($content) && defined($content)) {
4223 print $cgi->end_div;
4226 sub format_timestamp_html
{
4228 my $strtime = $date->{'rfc2822'};
4230 my (undef, undef, $datetime_class) =
4231 gitweb_get_feature
('javascript-timezone');
4232 if ($datetime_class) {
4233 $strtime = qq!<span
class="$datetime_class">$strtime</span
>!;
4236 my $localtime_format = '(%02d:%02d %s)';
4237 if ($date->{'hour_local'} < 6) {
4238 $localtime_format = '(<span class="atnight">%02d:%02d</span> %s)';
4241 sprintf($localtime_format,
4242 $date->{'hour_local'}, $date->{'minute_local'}, $date->{'tz_local'});
4247 # Outputs the author name and date in long form
4248 sub git_print_authorship
{
4251 my $tag = $opts{-tag
} || 'div';
4252 my $author = $co->{'author_name'};
4254 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
4255 print "<$tag class=\"author_date\">" .
4256 format_search_author
($author, "author", esc_html
($author)) .
4257 " [".format_timestamp_html
(\
%ad)."]".
4258 git_get_avatar
($co->{'author_email'}, -pad_before
=> 1) .
4262 # Outputs table rows containing the full author or committer information,
4263 # in the format expected for 'commit' view (& similar).
4264 # Parameters are a commit hash reference, followed by the list of people
4265 # to output information for. If the list is empty it defaults to both
4266 # author and committer.
4267 sub git_print_authorship_rows
{
4269 # too bad we can't use @people = @_ || ('author', 'committer')
4271 @people = ('author', 'committer') unless @people;
4272 foreach my $who (@people) {
4273 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
4274 print "<tr><td>$who</td><td>" .
4275 format_search_author
($co->{"${who}_name"}, $who,
4276 esc_html
($co->{"${who}_name"})) . " " .
4277 format_search_author
($co->{"${who}_email"}, $who,
4278 esc_html
("<" . $co->{"${who}_email"} . ">")) .
4279 "</td><td rowspan=\"2\">" .
4280 git_get_avatar
($co->{"${who}_email"}, -size
=> 'double') .
4284 format_timestamp_html
(\
%wd) .
4290 sub git_print_page_path
{
4296 print "<div class=\"page_path\">";
4297 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
4298 -title
=> 'tree root'}, to_utf8
("[$project]"));
4300 if (defined $name) {
4301 my @dirname = split '/', $name;
4302 my $basename = pop @dirname;
4305 foreach my $dir (@dirname) {
4306 $fullname .= ($fullname ?
'/' : '') . $dir;
4307 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
4309 -title
=> $fullname}, esc_path
($dir));
4312 if (defined $type && $type eq 'blob') {
4313 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
4315 -title
=> $name}, esc_path
($basename));
4316 } elsif (defined $type && $type eq 'tree') {
4317 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
4319 -title
=> $name}, esc_path
($basename));
4322 print esc_path
($basename);
4325 print "<br/></div>\n";
4332 if ($opts{'-remove_title'}) {
4333 # remove title, i.e. first line of log
4336 # remove leading empty lines
4337 while (defined $log->[0] && $log->[0] eq "") {
4344 foreach my $line (@
$log) {
4345 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
4348 if (! $opts{'-remove_signoff'}) {
4349 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
4352 # remove signoff lines
4359 # print only one empty line
4360 # do not print empty line after signoff
4362 next if ($empty || $signoff);
4368 print format_log_line_html
($line) . "<br/>\n";
4371 if ($opts{'-final_empty_line'}) {
4372 # end with single empty line
4373 print "<br/>\n" unless $empty;
4377 # return link target (what link points to)
4378 sub git_get_link_target
{
4383 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4387 $link_target = <$fd>;
4392 return $link_target;
4395 # given link target, and the directory (basedir) the link is in,
4396 # return target of link relative to top directory (top tree);
4397 # return undef if it is not possible (including absolute links).
4398 sub normalize_link_target
{
4399 my ($link_target, $basedir) = @_;
4401 # absolute symlinks (beginning with '/') cannot be normalized
4402 return if (substr($link_target, 0, 1) eq '/');
4404 # normalize link target to path from top (root) tree (dir)
4407 $path = $basedir . '/' . $link_target;
4409 # we are in top (root) tree (dir)
4410 $path = $link_target;
4413 # remove //, /./, and /../
4415 foreach my $part (split('/', $path)) {
4416 # discard '.' and ''
4417 next if (!$part || $part eq '.');
4419 if ($part eq '..') {
4423 # link leads outside repository (outside top dir)
4427 push @path_parts, $part;
4430 $path = join('/', @path_parts);
4435 # print tree entry (row of git_tree), but without encompassing <tr> element
4436 sub git_print_tree_entry
{
4437 my ($t, $basedir, $hash_base, $have_blame) = @_;
4440 $base_key{'hash_base'} = $hash_base if defined $hash_base;
4442 # The format of a table row is: mode list link. Where mode is
4443 # the mode of the entry, list is the name of the entry, an href,
4444 # and link is the action links of the entry.
4446 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
4447 if (exists $t->{'size'}) {
4448 print "<td class=\"size\">$t->{'size'}</td>\n";
4450 if ($t->{'type'} eq "blob") {
4451 print "<td class=\"list\">" .
4452 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4453 file_name
=>"$basedir$t->{'name'}", %base_key),
4454 -class => "list"}, esc_path
($t->{'name'}));
4455 if (S_ISLNK
(oct $t->{'mode'})) {
4456 my $link_target = git_get_link_target
($t->{'hash'});
4458 my $norm_target = normalize_link_target
($link_target, $basedir);
4459 if (defined $norm_target) {
4461 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
4462 file_name
=>$norm_target),
4463 -title
=> $norm_target}, esc_path
($link_target));
4465 print " -> " . esc_path
($link_target);
4470 print "<td class=\"link\">";
4471 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4472 file_name
=>"$basedir$t->{'name'}", %base_key)},
4476 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
4477 file_name
=>"$basedir$t->{'name'}", %base_key)},
4480 if (defined $hash_base) {
4482 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4483 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
4487 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
4488 file_name
=>"$basedir$t->{'name'}")},
4492 } elsif ($t->{'type'} eq "tree") {
4493 print "<td class=\"list\">";
4494 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4495 file_name
=>"$basedir$t->{'name'}",
4497 esc_path
($t->{'name'}));
4499 print "<td class=\"link\">";
4500 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4501 file_name
=>"$basedir$t->{'name'}",
4504 if (defined $hash_base) {
4506 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4507 file_name
=>"$basedir$t->{'name'}")},
4512 # unknown object: we can only present history for it
4513 # (this includes 'commit' object, i.e. submodule support)
4514 print "<td class=\"list\">" .
4515 esc_path
($t->{'name'}) .
4517 print "<td class=\"link\">";
4518 if (defined $hash_base) {
4519 print $cgi->a({-href
=> href
(action
=>"history",
4520 hash_base
=>$hash_base,
4521 file_name
=>"$basedir$t->{'name'}")},
4528 ## ......................................................................
4529 ## functions printing large fragments of HTML
4531 # get pre-image filenames for merge (combined) diff
4532 sub fill_from_file_info
{
4533 my ($diff, @parents) = @_;
4535 $diff->{'from_file'} = [ ];
4536 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4537 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4538 if ($diff->{'status'}[$i] eq 'R' ||
4539 $diff->{'status'}[$i] eq 'C') {
4540 $diff->{'from_file'}[$i] =
4541 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
4548 # is current raw difftree line of file deletion
4550 my $diffinfo = shift;
4552 return $diffinfo->{'to_id'} eq ('0' x
40);
4555 # does patch correspond to [previous] difftree raw line
4556 # $diffinfo - hashref of parsed raw diff format
4557 # $patchinfo - hashref of parsed patch diff format
4558 # (the same keys as in $diffinfo)
4559 sub is_patch_split
{
4560 my ($diffinfo, $patchinfo) = @_;
4562 return defined $diffinfo && defined $patchinfo
4563 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4567 sub git_difftree_body
{
4568 my ($difftree, $hash, @parents) = @_;
4569 my ($parent) = $parents[0];
4570 my $have_blame = gitweb_check_feature
('blame');
4571 print "<div class=\"list_head\">\n";
4572 if ($#{$difftree} > 10) {
4573 print(($#{$difftree} + 1) . " files changed:\n");
4577 print "<table class=\"" .
4578 (@parents > 1 ?
"combined " : "") .
4581 # header only for combined diff in 'commitdiff' view
4582 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
4585 print "<thead><tr>\n" .
4586 "<th></th><th></th>\n"; # filename, patchN link
4587 for (my $i = 0; $i < @parents; $i++) {
4588 my $par = $parents[$i];
4590 $cgi->a({-href
=> href
(action
=>"commitdiff",
4591 hash
=>$hash, hash_parent
=>$par),
4592 -title
=> 'commitdiff to parent number ' .
4593 ($i+1) . ': ' . substr($par,0,7)},
4597 print "</tr></thead>\n<tbody>\n";
4602 foreach my $line (@
{$difftree}) {
4603 my $diff = parsed_difftree_line
($line);
4606 print "<tr class=\"dark\">\n";
4608 print "<tr class=\"light\">\n";
4612 if (exists $diff->{'nparents'}) { # combined diff
4614 fill_from_file_info
($diff, @parents)
4615 unless exists $diff->{'from_file'};
4617 if (!is_deleted
($diff)) {
4618 # file exists in the result (child) commit
4620 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4621 file_name
=>$diff->{'to_file'},
4623 -class => "list"}, esc_path
($diff->{'to_file'})) .
4627 esc_path
($diff->{'to_file'}) .
4631 if ($action eq 'commitdiff') {
4634 print "<td class=\"link\">" .
4635 $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4641 my $has_history = 0;
4642 my $not_deleted = 0;
4643 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4644 my $hash_parent = $parents[$i];
4645 my $from_hash = $diff->{'from_id'}[$i];
4646 my $from_path = $diff->{'from_file'}[$i];
4647 my $status = $diff->{'status'}[$i];
4649 $has_history ||= ($status ne 'A');
4650 $not_deleted ||= ($status ne 'D');
4652 if ($status eq 'A') {
4653 print "<td class=\"link\" align=\"right\"> | </td>\n";
4654 } elsif ($status eq 'D') {
4655 print "<td class=\"link\">" .
4656 $cgi->a({-href
=> href
(action
=>"blob",
4659 file_name
=>$from_path)},
4663 if ($diff->{'to_id'} eq $from_hash) {
4664 print "<td class=\"link nochange\">";
4666 print "<td class=\"link\">";
4668 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4669 hash
=>$diff->{'to_id'},
4670 hash_parent
=>$from_hash,
4672 hash_parent_base
=>$hash_parent,
4673 file_name
=>$diff->{'to_file'},
4674 file_parent
=>$from_path)},
4680 print "<td class=\"link\">";
4682 print $cgi->a({-href
=> href
(action
=>"blob",
4683 hash
=>$diff->{'to_id'},
4684 file_name
=>$diff->{'to_file'},
4687 print " | " if ($has_history);
4690 print $cgi->a({-href
=> href
(action
=>"history",
4691 file_name
=>$diff->{'to_file'},
4698 next; # instead of 'else' clause, to avoid extra indent
4700 # else ordinary diff
4702 my ($to_mode_oct, $to_mode_str, $to_file_type);
4703 my ($from_mode_oct, $from_mode_str, $from_file_type);
4704 if ($diff->{'to_mode'} ne ('0' x
6)) {
4705 $to_mode_oct = oct $diff->{'to_mode'};
4706 if (S_ISREG
($to_mode_oct)) { # only for regular file
4707 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4709 $to_file_type = file_type
($diff->{'to_mode'});
4711 if ($diff->{'from_mode'} ne ('0' x
6)) {
4712 $from_mode_oct = oct $diff->{'from_mode'};
4713 if (S_ISREG
($from_mode_oct)) { # only for regular file
4714 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4716 $from_file_type = file_type
($diff->{'from_mode'});
4719 if ($diff->{'status'} eq "A") { # created
4720 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4721 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4722 $mode_chng .= "]</span>";
4724 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4725 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4726 -class => "list"}, esc_path
($diff->{'file'}));
4728 print "<td>$mode_chng</td>\n";
4729 print "<td class=\"link\">";
4730 if ($action eq 'commitdiff') {
4733 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4737 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4738 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4742 } elsif ($diff->{'status'} eq "D") { # deleted
4743 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4745 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4746 hash_base
=>$parent, file_name
=>$diff->{'file'}),
4747 -class => "list"}, esc_path
($diff->{'file'}));
4749 print "<td>$mode_chng</td>\n";
4750 print "<td class=\"link\">";
4751 if ($action eq 'commitdiff') {
4754 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4758 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4759 hash_base
=>$parent, file_name
=>$diff->{'file'})},
4762 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
4763 file_name
=>$diff->{'file'})},
4766 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
4767 file_name
=>$diff->{'file'})},
4771 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4772 my $mode_chnge = "";
4773 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4774 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4775 if ($from_file_type ne $to_file_type) {
4776 $mode_chnge .= " from $from_file_type to $to_file_type";
4778 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4779 if ($from_mode_str && $to_mode_str) {
4780 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4781 } elsif ($to_mode_str) {
4782 $mode_chnge .= " mode: $to_mode_str";
4785 $mode_chnge .= "]</span>\n";
4788 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4789 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4790 -class => "list"}, esc_path
($diff->{'file'}));
4792 print "<td>$mode_chnge</td>\n";
4793 print "<td class=\"link\">";
4794 if ($action eq 'commitdiff') {
4797 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4800 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4801 # "commit" view and modified file (not onlu mode changed)
4802 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4803 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4804 hash_base
=>$hash, hash_parent_base
=>$parent,
4805 file_name
=>$diff->{'file'})},
4809 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4810 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4813 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4814 file_name
=>$diff->{'file'})},
4817 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4818 file_name
=>$diff->{'file'})},
4822 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4823 my %status_name = ('R' => 'moved', 'C' => 'copied');
4824 my $nstatus = $status_name{$diff->{'status'}};
4826 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4827 # mode also for directories, so we cannot use $to_mode_str
4828 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4831 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
4832 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
4833 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
4834 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4835 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
4836 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
4837 -class => "list"}, esc_path
($diff->{'from_file'})) .
4838 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4839 "<td class=\"link\">";
4840 if ($action eq 'commitdiff') {
4843 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4846 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4847 # "commit" view and modified file (not only pure rename or copy)
4848 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4849 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4850 hash_base
=>$hash, hash_parent_base
=>$parent,
4851 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
4855 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4856 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
4859 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4860 file_name
=>$diff->{'to_file'})},
4863 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4864 file_name
=>$diff->{'to_file'})},
4868 } # we should not encounter Unmerged (U) or Unknown (X) status
4871 print "</tbody>" if $has_header;
4875 sub print_sidebyside_diff_chunk
{
4877 my (@ctx, @rem, @add);
4879 return unless @chunk;
4881 # incomplete last line might be among removed or added lines,
4882 # or both, or among context lines: find which
4883 for (my $i = 1; $i < @chunk; $i++) {
4884 if ($chunk[$i][0] eq 'incomplete') {
4885 $chunk[$i][0] = $chunk[$i-1][0];
4890 push @chunk, ["", ""];
4892 foreach my $line_info (@chunk) {
4893 my ($class, $line) = @
$line_info;
4895 # print chunk headers
4896 if ($class && $class eq 'chunk_header') {
4901 ## print from accumulator when type of class of lines change
4902 # empty contents block on start rem/add block, or end of chunk
4903 if (@ctx && (!$class || $class eq 'rem' || $class eq 'add')) {
4905 '<div class="chunk_block ctx">',
4906 '<div class="old">',
4909 '<div class="new">',
4915 # empty add/rem block on start context block, or end of chunk
4916 if ((@rem || @add) && (!$class || $class eq 'ctx')) {
4920 '<div class="chunk_block rem">',
4921 '<div class="old">',
4928 '<div class="chunk_block add">',
4929 '<div class="new">',
4934 # assume that it is change
4936 '<div class="chunk_block chg">',
4937 '<div class="old">',
4940 '<div class="new">',
4948 ## adding lines to accumulator
4951 # rem, add or change
4952 if ($class eq 'rem') {
4954 } elsif ($class eq 'add') {
4958 if ($class eq 'ctx') {
4964 sub git_patchset_body
{
4965 my ($fd, $diff_style, $difftree, $hash, @hash_parents) = @_;
4966 my ($hash_parent) = $hash_parents[0];
4968 my $is_combined = (@hash_parents > 1);
4970 my $patch_number = 0;
4975 my @chunk; # for side-by-side diff
4977 print "<div class=\"patchset\">\n";
4979 # skip to first patch
4980 while ($patch_line = <$fd>) {
4983 last if ($patch_line =~ m/^diff /);
4987 while ($patch_line) {
4989 # parse "git diff" header line
4990 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
4991 # $1 is from_name, which we do not use
4992 $to_name = unquote
($2);
4993 $to_name =~ s!^b/!!;
4994 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
4995 # $1 is 'cc' or 'combined', which we do not use
4996 $to_name = unquote
($2);
5001 # check if current patch belong to current raw line
5002 # and parse raw git-diff line if needed
5003 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
5004 # this is continuation of a split patch
5005 print "<div class=\"patch cont\">\n";
5007 # advance raw git-diff output if needed
5008 $patch_idx++ if defined $diffinfo;
5010 # read and prepare patch information
5011 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5013 # compact combined diff output can have some patches skipped
5014 # find which patch (using pathname of result) we are at now;
5016 while ($to_name ne $diffinfo->{'to_file'}) {
5017 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5018 format_diff_cc_simplified
($diffinfo, @hash_parents) .
5019 "</div>\n"; # class="patch"
5024 last if $patch_idx > $#$difftree;
5025 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5029 # modifies %from, %to hashes
5030 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
5032 # this is first patch for raw difftree line with $patch_idx index
5033 # we index @$difftree array from 0, but number patches from 1
5034 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
5038 #assert($patch_line =~ m/^diff /) if DEBUG;
5039 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
5041 # print "git diff" header
5042 print format_git_diff_header_line
($patch_line, $diffinfo,
5045 # print extended diff header
5046 print "<div class=\"diff extended_header\">\n";
5048 while ($patch_line = <$fd>) {
5051 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
5053 print format_extended_diff_header_line
($patch_line, $diffinfo,
5056 print "</div>\n"; # class="diff extended_header"
5058 # from-file/to-file diff header
5059 if (! $patch_line) {
5060 print "</div>\n"; # class="patch"
5063 next PATCH
if ($patch_line =~ m/^diff /);
5064 #assert($patch_line =~ m/^---/) if DEBUG;
5066 my $last_patch_line = $patch_line;
5067 $patch_line = <$fd>;
5069 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
5071 print format_diff_from_to_header
($last_patch_line, $patch_line,
5072 $diffinfo, \
%from, \
%to,
5077 while ($patch_line = <$fd>) {
5080 next PATCH
if ($patch_line =~ m/^diff /);
5082 my ($class, $line) = process_diff_line
($patch_line, \
%from, \
%to);
5083 my $diff_classes = "diff";
5084 $diff_classes .= " $class" if ($class);
5085 $line = "<div class=\"$diff_classes\">$line</div>\n";
5087 if ($diff_style eq 'sidebyside' && !$is_combined) {
5088 if ($class eq 'chunk_header') {
5089 print_sidebyside_diff_chunk
(@chunk);
5090 @chunk = ( [ $class, $line ] );
5092 push @chunk, [ $class, $line ];
5095 # default 'inline' style and unknown styles
5102 print_sidebyside_diff_chunk
(@chunk);
5105 print "</div>\n"; # class="patch"
5108 # for compact combined (--cc) format, with chunk and patch simplification
5109 # the patchset might be empty, but there might be unprocessed raw lines
5110 for (++$patch_idx if $patch_number > 0;
5111 $patch_idx < @
$difftree;
5113 # read and prepare patch information
5114 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5116 # generate anchor for "patch" links in difftree / whatchanged part
5117 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5118 format_diff_cc_simplified
($diffinfo, @hash_parents) .
5119 "</div>\n"; # class="patch"
5124 if ($patch_number == 0) {
5125 if (@hash_parents > 1) {
5126 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
5128 print "<div class=\"diff nodifferences\">No differences found</div>\n";
5132 print "</div>\n"; # class="patchset"
5135 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5137 # fills project list info (age, description, owner, category, forks)
5138 # for each project in the list, removing invalid projects from
5140 # NOTE: modifies $projlist, but does not remove entries from it
5141 sub fill_project_list_info
{
5142 my $projlist = shift;
5145 my $show_ctags = gitweb_check_feature
('ctags');
5147 foreach my $pr (@
$projlist) {
5148 my (@activity) = git_get_last_activity
($pr->{'path'});
5149 unless (@activity) {
5152 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
5153 if (!defined $pr->{'descr'}) {
5154 my $descr = git_get_project_description
($pr->{'path'}) || "";
5155 $descr = to_utf8
($descr);
5156 $pr->{'descr_long'} = $descr;
5157 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
5159 if (!defined $pr->{'owner'}) {
5160 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
5163 $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
5165 if ($projects_list_group_categories && !defined $pr->{'category'}) {
5166 my $cat = git_get_project_category
($pr->{'path'}) ||
5167 $project_list_default_category;
5168 $pr->{'category'} = to_utf8
($cat);
5171 push @projects, $pr;
5177 sub sort_projects_list
{
5178 my ($projlist, $order) = @_;
5182 project
=> { key
=> 'path', type
=> 'str' },
5183 descr
=> { key
=> 'descr_long', type
=> 'str' },
5184 owner
=> { key
=> 'owner', type
=> 'str' },
5185 age
=> { key
=> 'age', type
=> 'num' }
5187 my $oi = $order_info{$order};
5188 return @
$projlist unless defined $oi;
5189 if ($oi->{'type'} eq 'str') {
5190 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @
$projlist;
5192 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @
$projlist;
5198 # returns a hash of categories, containing the list of project
5199 # belonging to each category
5200 sub build_projlist_by_category
{
5201 my ($projlist, $from, $to) = @_;
5204 $from = 0 unless defined $from;
5205 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5207 for (my $i = $from; $i <= $to; $i++) {
5208 my $pr = $projlist->[$i];
5209 push @
{$categories{ $pr->{'category'} }}, $pr;
5212 return wantarray ?
%categories : \
%categories;
5215 # print 'sort by' <th> element, generating 'sort by $name' replay link
5216 # if that order is not selected
5218 print format_sort_th
(@_);
5221 sub format_sort_th
{
5222 my ($name, $order, $header) = @_;
5224 $header ||= ucfirst($name);
5226 if ($order eq $name) {
5227 $sort_th .= "<th>$header</th>\n";
5229 $sort_th .= "<th>" .
5230 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
5231 -class => "header"}, $header) .
5238 sub git_project_list_rows
{
5239 my ($projlist, $from, $to, $check_forks) = @_;
5241 $from = 0 unless defined $from;
5242 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5245 for (my $i = $from; $i <= $to; $i++) {
5246 my $pr = $projlist->[$i];
5249 print "<tr class=\"dark\">\n";
5251 print "<tr class=\"light\">\n";
5257 if ($pr->{'forks'}) {
5258 my $nforks = scalar @
{$pr->{'forks'}};
5260 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks"),
5261 -title
=> "$nforks forks"}, "+");
5263 print $cgi->span({-title
=> "$nforks forks"}, "+");
5268 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5269 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
5270 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5271 -class => "list", -title
=> $pr->{'descr_long'}},
5272 esc_html
($pr->{'descr'})) . "</td>\n" .
5273 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
5274 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
5275 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
5276 "<td class=\"link\">" .
5277 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
5278 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
5279 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
5280 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
5281 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
5287 sub git_project_list_body
{
5288 # actually uses global variable $project
5289 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
5290 my @projects = @
$projlist;
5292 my $check_forks = gitweb_check_feature
('forks');
5293 my $show_ctags = gitweb_check_feature
('ctags');
5294 my $tagfilter = $show_ctags ?
$input_params{'ctag'} : undef;
5295 $check_forks = undef
5296 if ($tagfilter || $search_regexp);
5298 # filtering out forks before filling info allows to do less work
5299 @projects = filter_forks_from_projects_list
(\
@projects)
5301 @projects = fill_project_list_info
(\
@projects);
5302 # searching projects require filling to be run before it
5303 @projects = search_projects_list
(\
@projects,
5304 'search_regexp' => $search_regexp,
5305 'tagfilter' => $tagfilter)
5306 if ($tagfilter || $search_regexp);
5308 $order ||= $default_projects_order;
5309 $from = 0 unless defined $from;
5310 $to = $#projects if (!defined $to || $#projects < $to);
5315 "<b>No such projects found</b><br />\n".
5316 "Click ".$cgi->a({-href
=>href
(project
=>undef)},"here")." to view all projects<br />\n".
5317 "</center>\n<br />\n";
5321 @projects = sort_projects_list
(\
@projects, $order);
5324 my $ctags = git_gather_all_ctags
(\
@projects);
5325 my $cloud = git_populate_project_tagcloud
($ctags);
5326 print git_show_project_tagcloud
($cloud, 64);
5329 print "<table class=\"project_list\">\n";
5330 unless ($no_header) {
5333 print "<th></th>\n";
5335 print_sort_th
('project', $order, 'Project');
5336 print_sort_th
('descr', $order, 'Description');
5337 print_sort_th
('owner', $order, 'Owner');
5338 print_sort_th
('age', $order, 'Last Change');
5339 print "<th></th>\n" . # for links
5343 if ($projects_list_group_categories) {
5344 # only display categories with projects in the $from-$to window
5345 @projects = sort {$a->{'category'} cmp $b->{'category'}} @projects[$from..$to];
5346 my %categories = build_projlist_by_category
(\
@projects, $from, $to);
5347 foreach my $cat (sort keys %categories) {
5348 unless ($cat eq "") {
5351 print "<td></td>\n";
5353 print "<td class=\"category\" colspan=\"5\">".esc_html
($cat)."</td>\n";
5357 git_project_list_rows
($categories{$cat}, undef, undef, $check_forks);
5360 git_project_list_rows
(\
@projects, $from, $to, $check_forks);
5363 if (defined $extra) {
5366 print "<td></td>\n";
5368 print "<td colspan=\"5\">$extra</td>\n" .
5375 # uses global variable $project
5376 my ($commitlist, $from, $to, $refs, $extra) = @_;
5378 $from = 0 unless defined $from;
5379 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5381 for (my $i = 0; $i <= $to; $i++) {
5382 my %co = %{$commitlist->[$i]};
5384 my $commit = $co{'id'};
5385 my $ref = format_ref_marker
($refs, $commit);
5386 git_print_header_div
('commit',
5387 "<span class=\"age\">$co{'age_string'}</span>" .
5388 esc_html
($co{'title'}) . $ref,
5390 print "<div class=\"title_text\">\n" .
5391 "<div class=\"log_link\">\n" .
5392 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
5394 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
5396 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
5399 git_print_authorship
(\
%co, -tag
=> 'span');
5400 print "<br/>\n</div>\n";
5402 print "<div class=\"log_body\">\n";
5403 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
5407 print "<div class=\"page_nav\">\n";
5413 sub git_shortlog_body
{
5414 # uses global variable $project
5415 my ($commitlist, $from, $to, $refs, $extra) = @_;
5417 $from = 0 unless defined $from;
5418 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5420 print "<table class=\"shortlog\">\n";
5422 for (my $i = $from; $i <= $to; $i++) {
5423 my %co = %{$commitlist->[$i]};
5424 my $commit = $co{'id'};
5425 my $ref = format_ref_marker
($refs, $commit);
5427 print "<tr class=\"dark\">\n";
5429 print "<tr class=\"light\">\n";
5432 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
5433 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5434 format_author_html
('td', \
%co, 10) . "<td>";
5435 print format_subject_html
($co{'title'}, $co{'title_short'},
5436 href
(action
=>"commit", hash
=>$commit), $ref);
5438 "<td class=\"link\">" .
5439 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
5440 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
5441 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
5442 my $snapshot_links = format_snapshot_links
($commit);
5443 if (defined $snapshot_links) {
5444 print " | " . $snapshot_links;
5449 if (defined $extra) {
5451 "<td colspan=\"4\">$extra</td>\n" .
5457 sub git_history_body
{
5458 # Warning: assumes constant type (blob or tree) during history
5459 my ($commitlist, $from, $to, $refs, $extra,
5460 $file_name, $file_hash, $ftype) = @_;
5462 $from = 0 unless defined $from;
5463 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
5465 print "<table class=\"history\">\n";
5467 for (my $i = $from; $i <= $to; $i++) {
5468 my %co = %{$commitlist->[$i]};
5472 my $commit = $co{'id'};
5474 my $ref = format_ref_marker
($refs, $commit);
5477 print "<tr class=\"dark\">\n";
5479 print "<tr class=\"light\">\n";
5482 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5483 # shortlog: format_author_html('td', \%co, 10)
5484 format_author_html
('td', \
%co, 15, 3) . "<td>";
5485 # originally git_history used chop_str($co{'title'}, 50)
5486 print format_subject_html
($co{'title'}, $co{'title_short'},
5487 href
(action
=>"commit", hash
=>$commit), $ref);
5489 "<td class=\"link\">" .
5490 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
5491 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
5493 if ($ftype eq 'blob') {
5494 my $blob_current = $file_hash;
5495 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
5496 if (defined $blob_current && defined $blob_parent &&
5497 $blob_current ne $blob_parent) {
5499 $cgi->a({-href
=> href
(action
=>"blobdiff",
5500 hash
=>$blob_current, hash_parent
=>$blob_parent,
5501 hash_base
=>$hash_base, hash_parent_base
=>$commit,
5502 file_name
=>$file_name)},
5509 if (defined $extra) {
5511 "<td colspan=\"4\">$extra</td>\n" .
5518 # uses global variable $project
5519 my ($taglist, $from, $to, $extra) = @_;
5520 $from = 0 unless defined $from;
5521 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
5523 print "<table class=\"tags\">\n";
5525 for (my $i = $from; $i <= $to; $i++) {
5526 my $entry = $taglist->[$i];
5528 my $comment = $tag{'subject'};
5530 if (defined $comment) {
5531 $comment_short = chop_str
($comment, 30, 5);
5534 print "<tr class=\"dark\">\n";
5536 print "<tr class=\"light\">\n";
5539 if (defined $tag{'age'}) {
5540 print "<td><i>$tag{'age'}</i></td>\n";
5542 print "<td></td>\n";
5545 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
5546 -class => "list name"}, esc_html
($tag{'name'})) .
5549 if (defined $comment) {
5550 print format_subject_html
($comment, $comment_short,
5551 href
(action
=>"tag", hash
=>$tag{'id'}));
5554 "<td class=\"selflink\">";
5555 if ($tag{'type'} eq "tag") {
5556 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
5561 "<td class=\"link\">" . " | " .
5562 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
5563 if ($tag{'reftype'} eq "commit") {
5564 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
5565 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
5566 } elsif ($tag{'reftype'} eq "blob") {
5567 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
5572 if (defined $extra) {
5574 "<td colspan=\"5\">$extra</td>\n" .
5580 sub git_heads_body
{
5581 # uses global variable $project
5582 my ($headlist, $head_at, $from, $to, $extra) = @_;
5583 $from = 0 unless defined $from;
5584 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
5586 print "<table class=\"heads\">\n";
5588 for (my $i = $from; $i <= $to; $i++) {
5589 my $entry = $headlist->[$i];
5591 my $curr = defined $head_at && $ref{'id'} eq $head_at;
5593 print "<tr class=\"dark\">\n";
5595 print "<tr class=\"light\">\n";
5598 print "<td><i>$ref{'age'}</i></td>\n" .
5599 ($curr ?
"<td class=\"current_head\">" : "<td>") .
5600 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
5601 -class => "list name"},esc_html
($ref{'name'})) .
5603 "<td class=\"link\">" .
5604 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
5605 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
5606 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'fullname'})}, "tree") .
5610 if (defined $extra) {
5612 "<td colspan=\"3\">$extra</td>\n" .
5618 # Display a single remote block
5619 sub git_remote_block
{
5620 my ($remote, $rdata, $limit, $head) = @_;
5622 my $heads = $rdata->{'heads'};
5623 my $fetch = $rdata->{'fetch'};
5624 my $push = $rdata->{'push'};
5626 my $urls_table = "<table class=\"projects_list\">\n" ;
5628 if (defined $fetch) {
5629 if ($fetch eq $push) {
5630 $urls_table .= format_repo_url
("URL", $fetch);
5632 $urls_table .= format_repo_url
("Fetch URL", $fetch);
5633 $urls_table .= format_repo_url
("Push URL", $push) if defined $push;
5635 } elsif (defined $push) {
5636 $urls_table .= format_repo_url
("Push URL", $push);
5638 $urls_table .= format_repo_url
("", "No remote URL");
5641 $urls_table .= "</table>\n";
5644 if (defined $limit && $limit < @
$heads) {
5645 $dots = $cgi->a({-href
=> href
(action
=>"remotes", hash
=>$remote)}, "...");
5649 git_heads_body
($heads, $head, 0, $limit, $dots);
5652 # Display a list of remote names with the respective fetch and push URLs
5653 sub git_remotes_list
{
5654 my ($remotedata, $limit) = @_;
5655 print "<table class=\"heads\">\n";
5657 my @remotes = sort keys %$remotedata;
5659 my $limited = $limit && $limit < @remotes;
5661 $#remotes = $limit - 1 if $limited;
5663 while (my $remote = shift @remotes) {
5664 my $rdata = $remotedata->{$remote};
5665 my $fetch = $rdata->{'fetch'};
5666 my $push = $rdata->{'push'};
5668 print "<tr class=\"dark\">\n";
5670 print "<tr class=\"light\">\n";
5674 $cgi->a({-href
=> href
(action
=>'remotes', hash
=>$remote),
5675 -class=> "list name"},esc_html
($remote)) .
5677 print "<td class=\"link\">" .
5678 (defined $fetch ?
$cgi->a({-href
=> $fetch}, "fetch") : "fetch") .
5680 (defined $push ?
$cgi->a({-href
=> $push}, "push") : "push") .
5688 "<td colspan=\"3\">" .
5689 $cgi->a({-href
=> href
(action
=>"remotes")}, "...") .
5690 "</td>\n" . "</tr>\n";
5696 # Display remote heads grouped by remote, unless there are too many
5697 # remotes, in which case we only display the remote names
5698 sub git_remotes_body
{
5699 my ($remotedata, $limit, $head) = @_;
5700 if ($limit and $limit < keys %$remotedata) {
5701 git_remotes_list
($remotedata, $limit);
5703 fill_remote_heads
($remotedata);
5704 while (my ($remote, $rdata) = each %$remotedata) {
5705 git_print_section
({-class=>"remote", -id
=>$remote},
5706 ["remotes", $remote, $remote], sub {
5707 git_remote_block
($remote, $rdata, $limit, $head);
5713 sub git_search_message
{
5717 if ($searchtype eq 'commit') {
5718 $greptype = "--grep=";
5719 } elsif ($searchtype eq 'author') {
5720 $greptype = "--author=";
5721 } elsif ($searchtype eq 'committer') {
5722 $greptype = "--committer=";
5724 $greptype .= $searchtext;
5725 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5726 $greptype, '--regexp-ignore-case',
5727 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5729 my $paging_nav = '';
5732 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)},
5735 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5736 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5738 $paging_nav .= "first ⋅ prev";
5741 if ($#commitlist >= 100) {
5743 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5744 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5745 $paging_nav .= " ⋅ $next_link";
5747 $paging_nav .= " ⋅ next";
5752 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5753 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5754 if ($page == 0 && !@commitlist) {
5755 print "<p>No match.</p>\n";
5757 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5763 sub git_search_changes
{
5767 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5768 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5769 ($search_use_regexp ?
'--pickaxe-regex' : ())
5770 or die_error
(500, "Open git-log failed");
5774 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5775 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5777 print "<table class=\"pickaxe search\">\n";
5781 while (my $line = <$fd>) {
5785 my %set = parse_difftree_raw_line
($line);
5786 if (defined $set{'commit'}) {
5787 # finish previous commit
5790 "<td class=\"link\">" .
5791 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5794 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5795 hash_base
=>$co{'id'})},
5802 print "<tr class=\"dark\">\n";
5804 print "<tr class=\"light\">\n";
5807 %co = parse_commit
($set{'commit'});
5808 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5809 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5810 "<td><i>$author</i></td>\n" .
5812 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5813 -class => "list subject"},
5814 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5815 } elsif (defined $set{'to_id'}) {
5816 next if ($set{'to_id'} =~ m/^0{40}$/);
5818 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5819 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5821 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5827 # finish last commit (warning: repetition!)
5830 "<td class=\"link\">" .
5831 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5834 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5835 hash_base
=>$co{'id'})},
5846 sub git_search_files
{
5850 open my $fd, "-|", git_cmd
(), 'grep', '-n', '-z',
5851 $search_use_regexp ?
('-E', '-i') : '-F',
5852 $searchtext, $co{'tree'}
5853 or die_error
(500, "Open git-grep failed");
5857 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5858 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5860 print "<table class=\"grep_search\">\n";
5865 while (my $line = <$fd>) {
5867 my ($file, $lno, $ltext, $binary);
5868 last if ($matches++ > 1000);
5869 if ($line =~ /^Binary file (.+) matches$/) {
5873 ($file, $lno, $ltext) = split(/\0/, $line, 3);
5874 $file =~ s/^$co{'tree'}://;
5876 if ($file ne $lastfile) {
5877 $lastfile and print "</td></tr>\n";
5879 print "<tr class=\"dark\">\n";
5881 print "<tr class=\"light\">\n";
5883 $file_href = href
(action
=>"blob", hash_base
=>$co{'id'},
5885 print "<td class=\"list\">".
5886 $cgi->a({-href
=> $file_href, -class => "list"}, esc_path
($file));
5887 print "</td><td>\n";
5891 print "<div class=\"binary\">Binary file</div>\n";
5893 $ltext = untabify
($ltext);
5894 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5895 $ltext = esc_html
($1, -nbsp
=>1);
5896 $ltext .= '<span class="match">';
5897 $ltext .= esc_html
($2, -nbsp
=>1);
5898 $ltext .= '</span>';
5899 $ltext .= esc_html
($3, -nbsp
=>1);
5901 $ltext = esc_html
($ltext, -nbsp
=>1);
5903 print "<div class=\"pre\">" .
5904 $cgi->a({-href
=> $file_href.'#l'.$lno,
5905 -class => "linenr"}, sprintf('%4i', $lno)) .
5906 ' ' . $ltext . "</div>\n";
5910 print "</td></tr>\n";
5911 if ($matches > 1000) {
5912 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5915 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5924 sub git_search_grep_body
{
5925 my ($commitlist, $from, $to, $extra) = @_;
5926 $from = 0 unless defined $from;
5927 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5929 print "<table class=\"commit_search\">\n";
5931 for (my $i = $from; $i <= $to; $i++) {
5932 my %co = %{$commitlist->[$i]};
5936 my $commit = $co{'id'};
5938 print "<tr class=\"dark\">\n";
5940 print "<tr class=\"light\">\n";
5943 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5944 format_author_html
('td', \
%co, 15, 5) .
5946 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5947 -class => "list subject"},
5948 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5949 my $comment = $co{'comment'};
5950 foreach my $line (@
$comment) {
5951 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5952 my ($lead, $match, $trail) = ($1, $2, $3);
5953 $match = chop_str
($match, 70, 5, 'center');
5954 my $contextlen = int((80 - length($match))/2);
5955 $contextlen = 30 if ($contextlen > 30);
5956 $lead = chop_str
($lead, $contextlen, 10, 'left');
5957 $trail = chop_str
($trail, $contextlen, 10, 'right');
5959 $lead = esc_html
($lead);
5960 $match = esc_html
($match);
5961 $trail = esc_html
($trail);
5963 print "$lead<span class=\"match\">$match</span>$trail<br />";
5967 "<td class=\"link\">" .
5968 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5970 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
5972 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5976 if (defined $extra) {
5978 "<td colspan=\"3\">$extra</td>\n" .
5984 ## ======================================================================
5985 ## ======================================================================
5988 sub git_project_list
{
5989 my $order = $input_params{'order'};
5990 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5991 die_error
(400, "Unknown order parameter");
5994 my @list = git_get_projects_list
();
5996 die_error
(404, "No projects found");
6000 if (defined $home_text && -f
$home_text) {
6001 print "<div class=\"index_include\">\n";
6002 insert_file
($home_text);
6005 print $cgi->startform(-method
=> "get") .
6006 "<p class=\"projsearch\">Search:\n" .
6007 $cgi->textfield(-name
=> "s", -value
=> $searchtext, -override
=> 1) . "\n" .
6009 $cgi->end_form() . "\n";
6010 git_project_list_body
(\
@list, $order);
6015 my $order = $input_params{'order'};
6016 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
6017 die_error
(400, "Unknown order parameter");
6020 my @list = git_get_projects_list
($project);
6022 die_error
(404, "No forks found");
6026 git_print_page_nav
('','');
6027 git_print_header_div
('summary', "$project forks");
6028 git_project_list_body
(\
@list, $order);
6032 sub git_project_index
{
6033 my @projects = git_get_projects_list
();
6035 die_error
(404, "No projects found");
6039 -type
=> 'text/plain',
6040 -charset
=> 'utf-8',
6041 -content_disposition
=> 'inline; filename="index.aux"');
6043 foreach my $pr (@projects) {
6044 if (!exists $pr->{'owner'}) {
6045 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
6048 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
6049 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
6050 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
6051 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
6055 print "$path $owner\n";
6060 my $descr = git_get_project_description
($project) || "none";
6061 my %co = parse_commit
("HEAD");
6062 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
6063 my $head = $co{'id'};
6064 my $remote_heads = gitweb_check_feature
('remote_heads');
6066 my $owner = git_get_project_owner
($project);
6068 my $refs = git_get_references
();
6069 # These get_*_list functions return one more to allow us to see if
6070 # there are more ...
6071 my @taglist = git_get_tags_list
(16);
6072 my @headlist = git_get_heads_list
(16);
6073 my %remotedata = $remote_heads ? git_get_remotes_list
() : ();
6075 my $check_forks = gitweb_check_feature
('forks');
6078 # find forks of a project
6079 @forklist = git_get_projects_list
($project);
6080 # filter out forks of forks
6081 @forklist = filter_forks_from_projects_list
(\
@forklist)
6086 git_print_page_nav
('summary','', $head);
6088 print "<div class=\"title\"> </div>\n";
6089 print "<table class=\"projects_list\">\n" .
6090 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
6091 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
6092 if (defined $cd{'rfc2822'}) {
6093 print "<tr id=\"metadata_lchange\"><td>last change</td>" .
6094 "<td>".format_timestamp_html
(\
%cd)."</td></tr>\n";
6097 # use per project git URL list in $projectroot/$project/cloneurl
6098 # or make project git URL from git base URL and project name
6099 my $url_tag = "URL";
6100 my @url_list = git_get_project_url_list
($project);
6101 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
6102 foreach my $git_url (@url_list) {
6103 next unless $git_url;
6104 print format_repo_url
($url_tag, $git_url);
6109 my $show_ctags = gitweb_check_feature
('ctags');
6111 my $ctags = git_get_project_ctags
($project);
6113 # without ability to add tags, don't show if there are none
6114 my $cloud = git_populate_project_tagcloud
($ctags);
6115 print "<tr id=\"metadata_ctags\">" .
6116 "<td>content tags</td>" .
6117 "<td>".git_show_project_tagcloud
($cloud, 48)."</td>" .
6124 # If XSS prevention is on, we don't include README.html.
6125 # TODO: Allow a readme in some safe format.
6126 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
6127 print "<div class=\"title\">readme</div>\n" .
6128 "<div class=\"readme\">\n";
6129 insert_file
("$projectroot/$project/README.html");
6130 print "\n</div>\n"; # class="readme"
6133 # we need to request one more than 16 (0..15) to check if
6135 my @commitlist = $head ? parse_commits
($head, 17) : ();
6137 git_print_header_div
('shortlog');
6138 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
6139 $#commitlist <= 15 ?
undef :
6140 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
6144 git_print_header_div
('tags');
6145 git_tags_body
(\
@taglist, 0, 15,
6146 $#taglist <= 15 ?
undef :
6147 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
6151 git_print_header_div
('heads');
6152 git_heads_body
(\
@headlist, $head, 0, 15,
6153 $#headlist <= 15 ?
undef :
6154 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
6158 git_print_header_div
('remotes');
6159 git_remotes_body
(\
%remotedata, 15, $head);
6163 git_print_header_div
('forks');
6164 git_project_list_body
(\
@forklist, 'age', 0, 15,
6165 $#forklist <= 15 ?
undef :
6166 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
6174 my %tag = parse_tag
($hash);
6177 die_error
(404, "Unknown tag object");
6180 my $head = git_get_head_hash
($project);
6182 git_print_page_nav
('','', $head,undef,$head);
6183 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
6184 print "<div class=\"title_text\">\n" .
6185 "<table class=\"object_header\">\n" .
6187 "<td>object</td>\n" .
6188 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6189 $tag{'object'}) . "</td>\n" .
6190 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6191 $tag{'type'}) . "</td>\n" .
6193 if (defined($tag{'author'})) {
6194 git_print_authorship_rows
(\
%tag, 'author');
6196 print "</table>\n\n" .
6198 print "<div class=\"page_body\">";
6199 my $comment = $tag{'comment'};
6200 foreach my $line (@
$comment) {
6202 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
6208 sub git_blame_common
{
6209 my $format = shift || 'porcelain';
6210 if ($format eq 'porcelain' && $input_params{'javascript'}) {
6211 $format = 'incremental';
6212 $action = 'blame_incremental'; # for page title etc
6216 gitweb_check_feature
('blame')
6217 or die_error
(403, "Blame view not allowed");
6220 die_error
(400, "No file name given") unless $file_name;
6221 $hash_base ||= git_get_head_hash
($project);
6222 die_error
(404, "Couldn't find base commit") unless $hash_base;
6223 my %co = parse_commit
($hash_base)
6224 or die_error
(404, "Commit not found");
6226 if (!defined $hash) {
6227 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
6228 or die_error
(404, "Error looking up file");
6230 $ftype = git_get_type
($hash);
6231 if ($ftype !~ "blob") {
6232 die_error
(400, "Object is not a blob");
6237 if ($format eq 'incremental') {
6238 # get file contents (as base)
6239 open $fd, "-|", git_cmd
(), 'cat-file', 'blob', $hash
6240 or die_error
(500, "Open git-cat-file failed");
6241 } elsif ($format eq 'data') {
6242 # run git-blame --incremental
6243 open $fd, "-|", git_cmd
(), "blame", "--incremental",
6244 $hash_base, "--", $file_name
6245 or die_error
(500, "Open git-blame --incremental failed");
6247 # run git-blame --porcelain
6248 open $fd, "-|", git_cmd
(), "blame", '-p',
6249 $hash_base, '--', $file_name
6250 or die_error
(500, "Open git-blame --porcelain failed");
6253 # incremental blame data returns early
6254 if ($format eq 'data') {
6256 -type
=>"text/plain", -charset
=> "utf-8",
6257 -status
=> "200 OK");
6258 local $| = 1; # output autoflush
6259 while (my $line = <$fd>) {
6260 print to_utf8
($line);
6263 or print "ERROR $!\n";
6266 if (defined $t0 && gitweb_check_feature
('timed')) {
6268 tv_interval
($t0, [ gettimeofday
() ]).
6269 ' '.$number_of_git_cmds;
6279 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
6282 if ($format eq 'incremental') {
6284 $cgi->a({-href
=> href
(action
=>"blame", javascript
=>0, -replay
=>1)},
6285 "blame") . " (non-incremental)";
6288 $cgi->a({-href
=> href
(action
=>"blame_incremental", -replay
=>1)},
6289 "blame") . " (incremental)";
6293 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6296 $cgi->a({-href
=> href
(action
=>$action, file_name
=>$file_name)},
6298 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6299 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6300 git_print_page_path
($file_name, $ftype, $hash_base);
6303 if ($format eq 'incremental') {
6304 print "<noscript>\n<div class=\"error\"><center><b>\n".
6305 "This page requires JavaScript to run.\n Use ".
6306 $cgi->a({-href
=> href
(action
=>'blame',javascript
=>0,-replay
=>1)},
6309 "</b></center></div>\n</noscript>\n";
6311 print qq!<div id
="progress_bar" style
="width: 100%; background-color: yellow"></div
>\n!;
6314 print qq!<div
class="page_body">\n!;
6315 print qq!<div id
="progress_info">... / ...</div
>\n!
6316 if ($format eq 'incremental');
6317 print qq!<table id
="blame_table" class="blame" width
="100%">\n!.
6318 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
6320 qq!<tr
><th
>Commit
</th><th>Line</th
><th
>Data
</th></tr
>\n!.
6324 my @rev_color = qw(light dark);
6325 my $num_colors = scalar(@rev_color);
6326 my $current_color = 0;
6328 if ($format eq 'incremental') {
6329 my $color_class = $rev_color[$current_color];
6334 while (my $line = <$fd>) {
6338 print qq!<tr id
="l$linenr" class="$color_class">!.
6339 qq!<td
class="sha1"><a href
=""> </a></td
>!.
6340 qq!<td
class="linenr">!.
6341 qq!<a
class="linenr" href
="">$linenr</a></td
>!;
6342 print qq!<td
class="pre">! . esc_html
($line) . "</td>\n";
6346 } else { # porcelain, i.e. ordinary blame
6347 my %metainfo = (); # saves information about commits
6351 while (my $line = <$fd>) {
6353 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
6354 # no <lines in group> for subsequent lines in group of lines
6355 my ($full_rev, $orig_lineno, $lineno, $group_size) =
6356 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
6357 if (!exists $metainfo{$full_rev}) {
6358 $metainfo{$full_rev} = { 'nprevious' => 0 };
6360 my $meta = $metainfo{$full_rev};
6362 while ($data = <$fd>) {
6364 last if ($data =~ s/^\t//); # contents of line
6365 if ($data =~ /^(\S+)(?: (.*))?$/) {
6366 $meta->{$1} = $2 unless exists $meta->{$1};
6368 if ($data =~ /^previous /) {
6369 $meta->{'nprevious'}++;
6372 my $short_rev = substr($full_rev, 0, 8);
6373 my $author = $meta->{'author'};
6375 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
6376 my $date = $date{'iso-tz'};
6378 $current_color = ($current_color + 1) % $num_colors;
6380 my $tr_class = $rev_color[$current_color];
6381 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
6382 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
6383 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
6384 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
6386 print "<td class=\"sha1\"";
6387 print " title=\"". esc_html
($author) . ", $date\"";
6388 print " rowspan=\"$group_size\"" if ($group_size > 1);
6390 print $cgi->a({-href
=> href
(action
=>"commit",
6392 file_name
=>$file_name)},
6393 esc_html
($short_rev));
6394 if ($group_size >= 2) {
6395 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
6396 if (@author_initials) {
6398 esc_html
(join('', @author_initials));
6404 # 'previous' <sha1 of parent commit> <filename at commit>
6405 if (exists $meta->{'previous'} &&
6406 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
6407 $meta->{'parent'} = $1;
6408 $meta->{'file_parent'} = unquote
($2);
6411 exists($meta->{'parent'}) ?
6412 $meta->{'parent'} : $full_rev;
6413 my $linenr_filename =
6414 exists($meta->{'file_parent'}) ?
6415 $meta->{'file_parent'} : unquote
($meta->{'filename'});
6416 my $blamed = href
(action
=> 'blame',
6417 file_name
=> $linenr_filename,
6418 hash_base
=> $linenr_commit);
6419 print "<td class=\"linenr\">";
6420 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
6421 -class => "linenr" },
6424 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
6432 "</table>\n"; # class="blame"
6433 print "</div>\n"; # class="blame_body"
6435 or print "Reading blob failed\n";
6444 sub git_blame_incremental
{
6445 git_blame_common
('incremental');
6448 sub git_blame_data
{
6449 git_blame_common
('data');
6453 my $head = git_get_head_hash
($project);
6455 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('tags'));
6456 git_print_header_div
('summary', $project);
6458 my @tagslist = git_get_tags_list
();
6460 git_tags_body
(\
@tagslist);
6466 my $head = git_get_head_hash
($project);
6468 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('heads'));
6469 git_print_header_div
('summary', $project);
6471 my @headslist = git_get_heads_list
();
6473 git_heads_body
(\
@headslist, $head);
6478 # used both for single remote view and for list of all the remotes
6480 gitweb_check_feature
('remote_heads')
6481 or die_error
(403, "Remote heads view is disabled");
6483 my $head = git_get_head_hash
($project);
6484 my $remote = $input_params{'hash'};
6486 my $remotedata = git_get_remotes_list
($remote);
6487 die_error
(500, "Unable to get remote information") unless defined $remotedata;
6489 unless (%$remotedata) {
6490 die_error
(404, defined $remote ?
6491 "Remote $remote not found" :
6492 "No remotes found");
6495 git_header_html
(undef, undef, -action_extra
=> $remote);
6496 git_print_page_nav
('', '', $head, undef, $head,
6497 format_ref_views
($remote ?
'' : 'remotes'));
6499 fill_remote_heads
($remotedata);
6500 if (defined $remote) {
6501 git_print_header_div
('remotes', "$remote remote for $project");
6502 git_remote_block
($remote, $remotedata->{$remote}, undef, $head);
6504 git_print_header_div
('summary', "$project remotes");
6505 git_remotes_body
($remotedata, undef, $head);
6511 sub git_blob_plain
{
6515 if (!defined $hash) {
6516 if (defined $file_name) {
6517 my $base = $hash_base || git_get_head_hash
($project);
6518 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6519 or die_error
(404, "Cannot find file");
6521 die_error
(400, "No file name defined");
6523 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6524 # blobs defined by non-textual hash id's can be cached
6528 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6529 or die_error
(500, "Open git-cat-file blob '$hash' failed");
6531 # content-type (can include charset)
6532 $type = blob_contenttype
($fd, $file_name, $type);
6534 # "save as" filename, even when no $file_name is given
6535 my $save_as = "$hash";
6536 if (defined $file_name) {
6537 $save_as = $file_name;
6538 } elsif ($type =~ m/^text\//) {
6542 # With XSS prevention on, blobs of all types except a few known safe
6543 # ones are served with "Content-Disposition: attachment" to make sure
6544 # they don't run in our security domain. For certain image types,
6545 # blob view writes an <img> tag referring to blob_plain view, and we
6546 # want to be sure not to break that by serving the image as an
6547 # attachment (though Firefox 3 doesn't seem to care).
6548 my $sandbox = $prevent_xss &&
6549 $type !~ m!^(?:text/[a-z]+|image/(?:gif|png|jpeg))(?:[ ;]|$)!;
6551 # serve text/* as text/plain
6553 ($type =~ m!^text/[a-z]+\b(.*)$! ||
6554 ($type =~ m!^[a-z]+/[a-z]\+xml\b(.*)$! && -T
$fd))) {
6556 $rest = defined $rest ?
$rest : '';
6557 $type = "text/plain$rest";
6562 -expires
=> $expires,
6563 -content_disposition
=>
6564 ($sandbox ?
'attachment' : 'inline')
6565 . '; filename="' . $save_as . '"');
6567 binmode STDOUT
, ':raw';
6569 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6576 if (!defined $hash) {
6577 if (defined $file_name) {
6578 my $base = $hash_base || git_get_head_hash
($project);
6579 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6580 or die_error
(404, "Cannot find file");
6582 die_error
(400, "No file name defined");
6584 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6585 # blobs defined by non-textual hash id's can be cached
6589 my $have_blame = gitweb_check_feature
('blame');
6590 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6591 or die_error
(500, "Couldn't cat $file_name, $hash");
6592 my $mimetype = blob_mimetype
($fd, $file_name);
6593 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
6594 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
6596 return git_blob_plain
($mimetype);
6598 # we can have blame only for text/* mimetype
6599 $have_blame &&= ($mimetype =~ m!^text/!);
6601 my $highlight = gitweb_check_feature
('highlight');
6602 my $syntax = guess_file_syntax
($highlight, $mimetype, $file_name);
6603 $fd = run_highlighter
($fd, $highlight, $syntax)
6606 git_header_html
(undef, $expires);
6607 my $formats_nav = '';
6608 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6609 if (defined $file_name) {
6612 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
6617 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6620 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6623 $cgi->a({-href
=> href
(action
=>"blob",
6624 hash_base
=>"HEAD", file_name
=>$file_name)},
6628 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6631 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6632 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6634 print "<div class=\"page_nav\">\n" .
6635 "<br/><br/></div>\n" .
6636 "<div class=\"title\">".esc_html
($hash)."</div>\n";
6638 git_print_page_path
($file_name, "blob", $hash_base);
6639 print "<div class=\"page_body\">\n";
6640 if ($mimetype =~ m!^image/!) {
6641 print qq!<img type
="!.esc_attr($mimetype).qq!"!;
6643 print qq! alt
="!.esc_attr($file_name).qq!" title
="!.esc_attr($file_name).qq!"!;
6646 href(action=>"blob_plain
", hash=>$hash,
6647 hash_base=>$hash_base, file_name=>$file_name) .
6651 while (my $line = <$fd>) {
6654 $line = untabify
($line);
6655 printf qq!<div
class="pre"><a id
="l%i" href
="%s#l%i" class="linenr">%4i</a> %s</div
>\n!,
6656 $nr, esc_attr
(href
(-replay
=> 1)), $nr, $nr,
6657 $syntax ? sanitize
($line) : esc_html
($line, -nbsp
=>1);
6661 or print "Reading blob failed.\n";
6667 if (!defined $hash_base) {
6668 $hash_base = "HEAD";
6670 if (!defined $hash) {
6671 if (defined $file_name) {
6672 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
6677 die_error
(404, "No such tree") unless defined($hash);
6679 my $show_sizes = gitweb_check_feature
('show-sizes');
6680 my $have_blame = gitweb_check_feature
('blame');
6685 open my $fd, "-|", git_cmd
(), "ls-tree", '-z',
6686 ($show_sizes ?
'-l' : ()), @extra_options, $hash
6687 or die_error
(500, "Open git-ls-tree failed");
6688 @entries = map { chomp; $_ } <$fd>;
6690 or die_error
(404, "Reading tree failed");
6693 my $refs = git_get_references
();
6694 my $ref = format_ref_marker
($refs, $hash_base);
6697 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6699 if (defined $file_name) {
6701 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6703 $cgi->a({-href
=> href
(action
=>"tree",
6704 hash_base
=>"HEAD", file_name
=>$file_name)},
6707 my $snapshot_links = format_snapshot_links
($hash);
6708 if (defined $snapshot_links) {
6709 # FIXME: Should be available when we have no hash base as well.
6710 push @views_nav, $snapshot_links;
6712 git_print_page_nav
('tree','', $hash_base, undef, undef,
6713 join(' | ', @views_nav));
6714 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
6717 print "<div class=\"page_nav\">\n";
6718 print "<br/><br/></div>\n";
6719 print "<div class=\"title\">".esc_html
($hash)."</div>\n";
6721 if (defined $file_name) {
6722 $basedir = $file_name;
6723 if ($basedir ne '' && substr($basedir, -1) ne '/') {
6726 git_print_page_path
($file_name, 'tree', $hash_base);
6728 print "<div class=\"page_body\">\n";
6729 print "<table class=\"tree\">\n";
6731 # '..' (top directory) link if possible
6732 if (defined $hash_base &&
6733 defined $file_name && $file_name =~ m![^/]+$!) {
6735 print "<tr class=\"dark\">\n";
6737 print "<tr class=\"light\">\n";
6741 my $up = $file_name;
6742 $up =~ s!/?[^/]+$!!;
6743 undef $up unless $up;
6744 # based on git_print_tree_entry
6745 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
6746 print '<td class="size"> </td>'."\n" if $show_sizes;
6747 print '<td class="list">';
6748 print $cgi->a({-href
=> href
(action
=>"tree",
6749 hash_base
=>$hash_base,
6753 print "<td class=\"link\"></td>\n";
6757 foreach my $line (@entries) {
6758 my %t = parse_ls_tree_line
($line, -z
=> 1, -l
=> $show_sizes);
6761 print "<tr class=\"dark\">\n";
6763 print "<tr class=\"light\">\n";
6767 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
6771 print "</table>\n" .
6777 my ($project, $hash) = @_;
6779 # path/to/project.git -> project
6780 # path/to/project/.git -> project
6781 my $name = to_utf8
($project);
6782 $name =~ s
,([^/])/*\
.git
$,$1,;
6783 $name = basename
($name);
6785 $name =~ s/[[:cntrl:]]/?/g;
6788 if ($hash =~ /^[0-9a-fA-F]+$/) {
6789 # shorten SHA-1 hash
6790 my $full_hash = git_get_full_hash
($project, $hash);
6791 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
6792 $ver = git_get_short_hash
($project, $hash);
6794 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
6795 # tags don't need shortened SHA-1 hash
6798 # branches and other need shortened SHA-1 hash
6799 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
6802 $ver .= '-' . git_get_short_hash
($project, $hash);
6804 # in case of hierarchical branch names
6807 # name = project-version_string
6808 $name = "$name-$ver";
6810 return wantarray ?
($name, $name) : $name;
6814 my $format = $input_params{'snapshot_format'};
6815 if (!@snapshot_fmts) {
6816 die_error
(403, "Snapshots not allowed");
6818 # default to first supported snapshot format
6819 $format ||= $snapshot_fmts[0];
6820 if ($format !~ m/^[a-z0-9]+$/) {
6821 die_error
(400, "Invalid snapshot format parameter");
6822 } elsif (!exists($known_snapshot_formats{$format})) {
6823 die_error
(400, "Unknown snapshot format");
6824 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
6825 die_error
(403, "Snapshot format not allowed");
6826 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
6827 die_error
(403, "Unsupported snapshot format");
6830 my $type = git_get_type
("$hash^{}");
6832 die_error
(404, 'Object does not exist');
6833 } elsif ($type eq 'blob') {
6834 die_error
(400, 'Object is not a tree-ish');
6837 my ($name, $prefix) = snapshot_name
($project, $hash);
6838 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
6839 my $cmd = quote_command
(
6840 git_cmd
(), 'archive',
6841 "--format=$known_snapshot_formats{$format}{'format'}",
6842 "--prefix=$prefix/", $hash);
6843 if (exists $known_snapshot_formats{$format}{'compressor'}) {
6844 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
6847 $filename =~ s/(["\\])/\\$1/g;
6849 -type
=> $known_snapshot_formats{$format}{'type'},
6850 -content_disposition
=> 'inline; filename="' . $filename . '"',
6851 -status
=> '200 OK');
6853 open my $fd, "-|", $cmd
6854 or die_error
(500, "Execute git-archive failed");
6855 binmode STDOUT
, ':raw';
6857 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6861 sub git_log_generic
{
6862 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
6864 my $head = git_get_head_hash
($project);
6865 if (!defined $base) {
6868 if (!defined $page) {
6871 my $refs = git_get_references
();
6873 my $commit_hash = $base;
6874 if (defined $parent) {
6875 $commit_hash = "$parent..$base";
6878 parse_commits
($commit_hash, 101, (100 * $page),
6879 defined $file_name ?
($file_name, "--full-history") : ());
6882 if (!defined $file_hash && defined $file_name) {
6883 # some commits could have deleted file in question,
6884 # and not have it in tree, but one of them has to have it
6885 for (my $i = 0; $i < @commitlist; $i++) {
6886 $file_hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
6887 last if defined $file_hash;
6890 if (defined $file_hash) {
6891 $ftype = git_get_type
($file_hash);
6893 if (defined $file_name && !defined $ftype) {
6894 die_error
(500, "Unknown type of object");
6897 if (defined $file_name) {
6898 %co = parse_commit
($base)
6899 or die_error
(404, "Unknown commit object");
6903 my $paging_nav = format_paging_nav
($fmt_name, $page, $#commitlist >= 100);
6905 if ($#commitlist >= 100) {
6907 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6908 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
6910 my $patch_max = gitweb_get_feature
('patches');
6911 if ($patch_max && !defined $file_name) {
6912 if ($patch_max < 0 || @commitlist <= $patch_max) {
6913 $paging_nav .= " ⋅ " .
6914 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
6920 git_print_page_nav
($fmt_name,'', $hash,$hash,$hash, $paging_nav);
6921 if (defined $file_name) {
6922 git_print_header_div
('commit', esc_html
($co{'title'}), $base);
6924 git_print_header_div
('summary', $project)
6926 git_print_page_path
($file_name, $ftype, $hash_base)
6927 if (defined $file_name);
6929 $body_subr->(\
@commitlist, 0, 99, $refs, $next_link,
6930 $file_name, $file_hash, $ftype);
6936 git_log_generic
('log', \
&git_log_body
,
6937 $hash, $hash_parent);
6941 $hash ||= $hash_base || "HEAD";
6942 my %co = parse_commit
($hash)
6943 or die_error
(404, "Unknown commit object");
6945 my $parent = $co{'parent'};
6946 my $parents = $co{'parents'}; # listref
6948 # we need to prepare $formats_nav before any parameter munging
6950 if (!defined $parent) {
6952 $formats_nav .= '(initial)';
6953 } elsif (@
$parents == 1) {
6954 # single parent commit
6957 $cgi->a({-href
=> href
(action
=>"commit",
6959 esc_html
(substr($parent, 0, 7))) .
6966 $cgi->a({-href
=> href
(action
=>"commit",
6968 esc_html
(substr($_, 0, 7)));
6972 if (gitweb_check_feature
('patches') && @
$parents <= 1) {
6973 $formats_nav .= " | " .
6974 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6978 if (!defined $parent) {
6982 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
6984 (@
$parents <= 1 ?
$parent : '-c'),
6986 or die_error
(500, "Open git-diff-tree failed");
6987 @difftree = map { chomp; $_ } <$fd>;
6988 close $fd or die_error
(404, "Reading git-diff-tree failed");
6990 # non-textual hash id's can be cached
6992 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6995 my $refs = git_get_references
();
6996 my $ref = format_ref_marker
($refs, $co{'id'});
6998 git_header_html
(undef, $expires);
6999 git_print_page_nav
('commit', '',
7000 $hash, $co{'tree'}, $hash,
7003 if (defined $co{'parent'}) {
7004 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
7006 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
7008 print "<div class=\"title_text\">\n" .
7009 "<table class=\"object_header\">\n";
7010 git_print_authorship_rows
(\
%co);
7011 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
7014 "<td class=\"sha1\">" .
7015 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
7016 class => "list"}, $co{'tree'}) .
7018 "<td class=\"link\">" .
7019 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
7021 my $snapshot_links = format_snapshot_links
($hash);
7022 if (defined $snapshot_links) {
7023 print " | " . $snapshot_links;
7028 foreach my $par (@
$parents) {
7031 "<td class=\"sha1\">" .
7032 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
7033 class => "list"}, $par) .
7035 "<td class=\"link\">" .
7036 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
7038 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
7045 print "<div class=\"page_body\">\n";
7046 git_print_log
($co{'comment'});
7049 git_difftree_body
(\
@difftree, $hash, @
$parents);
7055 # object is defined by:
7056 # - hash or hash_base alone
7057 # - hash_base and file_name
7060 # - hash or hash_base alone
7061 if ($hash || ($hash_base && !defined $file_name)) {
7062 my $object_id = $hash || $hash_base;
7064 open my $fd, "-|", quote_command
(
7065 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
7066 or die_error
(404, "Object does not exist");
7070 or die_error
(404, "Object does not exist");
7072 # - hash_base and file_name
7073 } elsif ($hash_base && defined $file_name) {
7074 $file_name =~ s
,/+$,,;
7076 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
7077 or die_error
(404, "Base object does not exist");
7079 # here errors should not hapen
7080 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
7081 or die_error
(500, "Open git-ls-tree failed");
7085 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
7086 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
7087 die_error
(404, "File or directory for given base does not exist");
7092 die_error
(400, "Not enough information to find object");
7095 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
7096 hash
=>$hash, hash_base
=>$hash_base,
7097 file_name
=>$file_name),
7098 -status
=> '302 Found');
7102 my $format = shift || 'html';
7103 my $diff_style = $input_params{'diff_style'} || 'inline';
7110 # preparing $fd and %diffinfo for git_patchset_body
7112 if (defined $hash_base && defined $hash_parent_base) {
7113 if (defined $file_name) {
7115 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7116 $hash_parent_base, $hash_base,
7117 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7118 or die_error
(500, "Open git-diff-tree failed");
7119 @difftree = map { chomp; $_ } <$fd>;
7121 or die_error
(404, "Reading git-diff-tree failed");
7123 or die_error
(404, "Blob diff not found");
7125 } elsif (defined $hash &&
7126 $hash =~ /[0-9a-fA-F]{40}/) {
7127 # try to find filename from $hash
7129 # read filtered raw output
7130 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7131 $hash_parent_base, $hash_base, "--"
7132 or die_error
(500, "Open git-diff-tree failed");
7134 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
7136 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
7137 map { chomp; $_ } <$fd>;
7139 or die_error
(404, "Reading git-diff-tree failed");
7141 or die_error
(404, "Blob diff not found");
7144 die_error
(400, "Missing one of the blob diff parameters");
7147 if (@difftree > 1) {
7148 die_error
(400, "Ambiguous blob diff specification");
7151 %diffinfo = parse_difftree_raw_line
($difftree[0]);
7152 $file_parent ||= $diffinfo{'from_file'} || $file_name;
7153 $file_name ||= $diffinfo{'to_file'};
7155 $hash_parent ||= $diffinfo{'from_id'};
7156 $hash ||= $diffinfo{'to_id'};
7158 # non-textual hash id's can be cached
7159 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
7160 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
7165 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7166 '-p', ($format eq 'html' ?
"--full-index" : ()),
7167 $hash_parent_base, $hash_base,
7168 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7169 or die_error
(500, "Open git-diff-tree failed");
7172 # old/legacy style URI -- not generated anymore since 1.4.3.
7174 die_error
('404 Not Found', "Missing one of the blob diff parameters")
7178 if ($format eq 'html') {
7180 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
7182 $formats_nav .= diff_style_nav
($diff_style);
7183 git_header_html
(undef, $expires);
7184 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
7185 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
7186 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
7188 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
7189 print "<div class=\"title\">".esc_html
("$hash vs $hash_parent")."</div>\n";
7191 if (defined $file_name) {
7192 git_print_page_path
($file_name, "blob", $hash_base);
7194 print "<div class=\"page_path\"></div>\n";
7197 } elsif ($format eq 'plain') {
7199 -type
=> 'text/plain',
7200 -charset
=> 'utf-8',
7201 -expires
=> $expires,
7202 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
7204 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7207 die_error
(400, "Unknown blobdiff format");
7211 if ($format eq 'html') {
7212 print "<div class=\"page_body\">\n";
7214 git_patchset_body
($fd, $diff_style,
7215 [ \
%diffinfo ], $hash_base, $hash_parent_base);
7218 print "</div>\n"; # class="page_body"
7222 while (my $line = <$fd>) {
7223 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
7224 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
7228 last if $line =~ m!^\+\+\+!;
7236 sub git_blobdiff_plain
{
7237 git_blobdiff
('plain');
7240 # assumes that it is added as later part of already existing navigation,
7241 # so it returns "| foo | bar" rather than just "foo | bar"
7242 sub diff_style_nav
{
7243 my ($diff_style, $is_combined) = @_;
7244 $diff_style ||= 'inline';
7246 return "" if ($is_combined);
7248 my @styles = (inline
=> 'inline', 'sidebyside' => 'side by side');
7249 my %styles = @styles;
7251 @styles[ map { $_ * 2 } 0..$#styles/2 ];
7256 $_ eq $diff_style ?
$styles{$_} :
7257 $cgi->a({-href
=> href
(-replay
=>1, diff_style
=> $_)}, $styles{$_})
7261 sub git_commitdiff
{
7263 my $format = $params{-format
} || 'html';
7264 my $diff_style = $input_params{'diff_style'} || 'inline';
7266 my ($patch_max) = gitweb_get_feature
('patches');
7267 if ($format eq 'patch') {
7268 die_error
(403, "Patch view not allowed") unless $patch_max;
7271 $hash ||= $hash_base || "HEAD";
7272 my %co = parse_commit
($hash)
7273 or die_error
(404, "Unknown commit object");
7275 # choose format for commitdiff for merge
7276 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
7277 $hash_parent = '--cc';
7279 # we need to prepare $formats_nav before almost any parameter munging
7281 if ($format eq 'html') {
7283 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
7285 if ($patch_max && @
{$co{'parents'}} <= 1) {
7286 $formats_nav .= " | " .
7287 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
7290 $formats_nav .= diff_style_nav
($diff_style, @
{$co{'parents'}} > 1);
7292 if (defined $hash_parent &&
7293 $hash_parent ne '-c' && $hash_parent ne '--cc') {
7294 # commitdiff with two commits given
7295 my $hash_parent_short = $hash_parent;
7296 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
7297 $hash_parent_short = substr($hash_parent, 0, 7);
7301 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
7302 if ($co{'parents'}[$i] eq $hash_parent) {
7303 $formats_nav .= ' parent ' . ($i+1);
7307 $formats_nav .= ': ' .
7308 $cgi->a({-href
=> href
(-replay
=>1,
7309 hash
=>$hash_parent, hash_base
=>undef)},
7310 esc_html
($hash_parent_short)) .
7312 } elsif (!$co{'parent'}) {
7314 $formats_nav .= ' (initial)';
7315 } elsif (scalar @
{$co{'parents'}} == 1) {
7316 # single parent commit
7319 $cgi->a({-href
=> href
(-replay
=>1,
7320 hash
=>$co{'parent'}, hash_base
=>undef)},
7321 esc_html
(substr($co{'parent'}, 0, 7))) .
7325 if ($hash_parent eq '--cc') {
7326 $formats_nav .= ' | ' .
7327 $cgi->a({-href
=> href
(-replay
=>1,
7328 hash
=>$hash, hash_parent
=>'-c')},
7330 } else { # $hash_parent eq '-c'
7331 $formats_nav .= ' | ' .
7332 $cgi->a({-href
=> href
(-replay
=>1,
7333 hash
=>$hash, hash_parent
=>'--cc')},
7339 $cgi->a({-href
=> href
(-replay
=>1,
7340 hash
=>$_, hash_base
=>undef)},
7341 esc_html
(substr($_, 0, 7)));
7342 } @
{$co{'parents'}} ) .
7347 my $hash_parent_param = $hash_parent;
7348 if (!defined $hash_parent_param) {
7349 # --cc for multiple parents, --root for parentless
7350 $hash_parent_param =
7351 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
7357 if ($format eq 'html') {
7358 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7359 "--no-commit-id", "--patch-with-raw", "--full-index",
7360 $hash_parent_param, $hash, "--"
7361 or die_error
(500, "Open git-diff-tree failed");
7363 while (my $line = <$fd>) {
7365 # empty line ends raw part of diff-tree output
7367 push @difftree, scalar parse_difftree_raw_line
($line);
7370 } elsif ($format eq 'plain') {
7371 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7372 '-p', $hash_parent_param, $hash, "--"
7373 or die_error
(500, "Open git-diff-tree failed");
7374 } elsif ($format eq 'patch') {
7375 # For commit ranges, we limit the output to the number of
7376 # patches specified in the 'patches' feature.
7377 # For single commits, we limit the output to a single patch,
7378 # diverging from the git-format-patch default.
7379 my @commit_spec = ();
7381 if ($patch_max > 0) {
7382 push @commit_spec, "-$patch_max";
7384 push @commit_spec, '-n', "$hash_parent..$hash";
7386 if ($params{-single
}) {
7387 push @commit_spec, '-1';
7389 if ($patch_max > 0) {
7390 push @commit_spec, "-$patch_max";
7392 push @commit_spec, "-n";
7394 push @commit_spec, '--root', $hash;
7396 open $fd, "-|", git_cmd
(), "format-patch", @diff_opts,
7397 '--encoding=utf8', '--stdout', @commit_spec
7398 or die_error
(500, "Open git-format-patch failed");
7400 die_error
(400, "Unknown commitdiff format");
7403 # non-textual hash id's can be cached
7405 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
7409 # write commit message
7410 if ($format eq 'html') {
7411 my $refs = git_get_references
();
7412 my $ref = format_ref_marker
($refs, $co{'id'});
7414 git_header_html
(undef, $expires);
7415 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
7416 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
7417 print "<div class=\"title_text\">\n" .
7418 "<table class=\"object_header\">\n";
7419 git_print_authorship_rows
(\
%co);
7422 print "<div class=\"page_body\">\n";
7423 if (@
{$co{'comment'}} > 1) {
7424 print "<div class=\"log\">\n";
7425 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
7426 print "</div>\n"; # class="log"
7429 } elsif ($format eq 'plain') {
7430 my $refs = git_get_references
("tags");
7431 my $tagname = git_get_rev_name_tags
($hash);
7432 my $filename = basename
($project) . "-$hash.patch";
7435 -type
=> 'text/plain',
7436 -charset
=> 'utf-8',
7437 -expires
=> $expires,
7438 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7439 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7440 print "From: " . to_utf8
($co{'author'}) . "\n";
7441 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
7442 print "Subject: " . to_utf8
($co{'title'}) . "\n";
7444 print "X-Git-Tag: $tagname\n" if $tagname;
7445 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7447 foreach my $line (@
{$co{'comment'}}) {
7448 print to_utf8
($line) . "\n";
7451 } elsif ($format eq 'patch') {
7452 my $filename = basename
($project) . "-$hash.patch";
7455 -type
=> 'text/plain',
7456 -charset
=> 'utf-8',
7457 -expires
=> $expires,
7458 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7462 if ($format eq 'html') {
7463 my $use_parents = !defined $hash_parent ||
7464 $hash_parent eq '-c' || $hash_parent eq '--cc';
7465 git_difftree_body
(\
@difftree, $hash,
7466 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7469 git_patchset_body
($fd, $diff_style,
7471 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7473 print "</div>\n"; # class="page_body"
7476 } elsif ($format eq 'plain') {
7480 or print "Reading git-diff-tree failed\n";
7481 } elsif ($format eq 'patch') {
7485 or print "Reading git-format-patch failed\n";
7489 sub git_commitdiff_plain
{
7490 git_commitdiff
(-format
=> 'plain');
7493 # format-patch-style patches
7495 git_commitdiff
(-format
=> 'patch', -single
=> 1);
7499 git_commitdiff
(-format
=> 'patch');
7503 git_log_generic
('history', \
&git_history_body
,
7504 $hash_base, $hash_parent_base,
7509 $searchtype ||= 'commit';
7511 # check if appropriate features are enabled
7512 gitweb_check_feature
('search')
7513 or die_error
(403, "Search is disabled");
7514 if ($searchtype eq 'pickaxe') {
7515 # pickaxe may take all resources of your box and run for several minutes
7516 # with every query - so decide by yourself how public you make this feature
7517 gitweb_check_feature
('pickaxe')
7518 or die_error
(403, "Pickaxe search is disabled");
7520 if ($searchtype eq 'grep') {
7521 # grep search might be potentially CPU-intensive, too
7522 gitweb_check_feature
('grep')
7523 or die_error
(403, "Grep search is disabled");
7526 if (!defined $searchtext) {
7527 die_error
(400, "Text field is empty");
7529 if (!defined $hash) {
7530 $hash = git_get_head_hash
($project);
7532 my %co = parse_commit
($hash);
7534 die_error
(404, "Unknown commit object");
7536 if (!defined $page) {
7540 if ($searchtype eq 'commit' ||
7541 $searchtype eq 'author' ||
7542 $searchtype eq 'committer') {
7543 git_search_message
(%co);
7544 } elsif ($searchtype eq 'pickaxe') {
7545 git_search_changes
(%co);
7546 } elsif ($searchtype eq 'grep') {
7547 git_search_files
(%co);
7549 die_error
(400, "Unknown search type");
7553 sub git_search_help
{
7555 git_print_page_nav
('','', $hash,$hash,$hash);
7557 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
7558 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
7559 the pattern entered is recognized as the POSIX extended
7560 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
7563 <dt><b>commit</b></dt>
7564 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
7566 my $have_grep = gitweb_check_feature
('grep');
7569 <dt><b>grep</b></dt>
7570 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
7571 a different one) are searched for the given pattern. On large trees, this search can take
7572 a while and put some strain on the server, so please use it with some consideration. Note that
7573 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
7574 case-sensitive.</dd>
7578 <dt><b>author</b></dt>
7579 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
7580 <dt><b>committer</b></dt>
7581 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
7583 my $have_pickaxe = gitweb_check_feature
('pickaxe');
7584 if ($have_pickaxe) {
7586 <dt><b>pickaxe</b></dt>
7587 <dd>All commits that caused the string to appear or disappear from any file (changes that
7588 added, removed or "modified" the string) will be listed. This search can take a while and
7589 takes a lot of strain on the server, so please use it wisely. Note that since you may be
7590 interested even in changes just changing the case as well, this search is case sensitive.</dd>
7598 git_log_generic
('shortlog', \
&git_shortlog_body
,
7599 $hash, $hash_parent);
7602 ## ......................................................................
7603 ## feeds (RSS, Atom; OPML)
7606 my $format = shift || 'atom';
7607 my $have_blame = gitweb_check_feature
('blame');
7609 # Atom: http://www.atomenabled.org/developers/syndication/
7610 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
7611 if ($format ne 'rss' && $format ne 'atom') {
7612 die_error
(400, "Unknown web feed format");
7615 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
7616 my $head = $hash || 'HEAD';
7617 my @commitlist = parse_commits
($head, 150, 0, $file_name);
7621 my $content_type = "application/$format+xml";
7622 if (defined $cgi->http('HTTP_ACCEPT') &&
7623 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
7624 # browser (feed reader) prefers text/xml
7625 $content_type = 'text/xml';
7627 if (defined($commitlist[0])) {
7628 %latest_commit = %{$commitlist[0]};
7629 my $latest_epoch = $latest_commit{'committer_epoch'};
7630 %latest_date = parse_date
($latest_epoch, $latest_commit{'comitter_tz'});
7631 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
7632 if (defined $if_modified) {
7634 if (eval { require HTTP
::Date
; 1; }) {
7635 $since = HTTP
::Date
::str2time
($if_modified);
7636 } elsif (eval { require Time
::ParseDate
; 1; }) {
7637 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
7639 if (defined $since && $latest_epoch <= $since) {
7641 -type
=> $content_type,
7642 -charset
=> 'utf-8',
7643 -last_modified
=> $latest_date{'rfc2822'},
7644 -status
=> '304 Not Modified');
7649 -type
=> $content_type,
7650 -charset
=> 'utf-8',
7651 -last_modified
=> $latest_date{'rfc2822'});
7654 -type
=> $content_type,
7655 -charset
=> 'utf-8');
7658 # Optimization: skip generating the body if client asks only
7659 # for Last-Modified date.
7660 return if ($cgi->request_method() eq 'HEAD');
7663 my $title = "$site_name - $project/$action";
7664 my $feed_type = 'log';
7665 if (defined $hash) {
7666 $title .= " - '$hash'";
7667 $feed_type = 'branch log';
7668 if (defined $file_name) {
7669 $title .= " :: $file_name";
7670 $feed_type = 'history';
7672 } elsif (defined $file_name) {
7673 $title .= " - $file_name";
7674 $feed_type = 'history';
7676 $title .= " $feed_type";
7677 my $descr = git_get_project_description
($project);
7678 if (defined $descr) {
7679 $descr = esc_html
($descr);
7681 $descr = "$project " .
7682 ($format eq 'rss' ?
'RSS' : 'Atom') .
7685 my $owner = git_get_project_owner
($project);
7686 $owner = esc_html
($owner);
7690 if (defined $file_name) {
7691 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
7692 } elsif (defined $hash) {
7693 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
7695 $alt_url = href
(-full
=>1, action
=>"summary");
7697 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
7698 if ($format eq 'rss') {
7700 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
7703 print "<title>$title</title>\n" .
7704 "<link>$alt_url</link>\n" .
7705 "<description>$descr</description>\n" .
7706 "<language>en</language>\n" .
7707 # project owner is responsible for 'editorial' content
7708 "<managingEditor>$owner</managingEditor>\n";
7709 if (defined $logo || defined $favicon) {
7710 # prefer the logo to the favicon, since RSS
7711 # doesn't allow both
7712 my $img = esc_url
($logo || $favicon);
7714 "<url>$img</url>\n" .
7715 "<title>$title</title>\n" .
7716 "<link>$alt_url</link>\n" .
7720 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
7721 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
7723 print "<generator>gitweb v.$version/$git_version</generator>\n";
7724 } elsif ($format eq 'atom') {
7726 <feed xmlns="http://www.w3.org/2005/Atom">
7728 print "<title>$title</title>\n" .
7729 "<subtitle>$descr</subtitle>\n" .
7730 '<link rel="alternate" type="text/html" href="' .
7731 $alt_url . '" />' . "\n" .
7732 '<link rel="self" type="' . $content_type . '" href="' .
7733 $cgi->self_url() . '" />' . "\n" .
7734 "<id>" . href
(-full
=>1) . "</id>\n" .
7735 # use project owner for feed author
7736 "<author><name>$owner</name></author>\n";
7737 if (defined $favicon) {
7738 print "<icon>" . esc_url
($favicon) . "</icon>\n";
7740 if (defined $logo) {
7741 # not twice as wide as tall: 72 x 27 pixels
7742 print "<logo>" . esc_url
($logo) . "</logo>\n";
7744 if (! %latest_date) {
7745 # dummy date to keep the feed valid until commits trickle in:
7746 print "<updated>1970-01-01T00:00:00Z</updated>\n";
7748 print "<updated>$latest_date{'iso-8601'}</updated>\n";
7750 print "<generator version='$version/$git_version'>gitweb</generator>\n";
7754 for (my $i = 0; $i <= $#commitlist; $i++) {
7755 my %co = %{$commitlist[$i]};
7756 my $commit = $co{'id'};
7757 # we read 150, we always show 30 and the ones more recent than 48 hours
7758 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
7761 my %cd = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7763 # get list of changed files
7764 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7765 $co{'parent'} || "--root",
7766 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
7768 my @difftree = map { chomp; $_ } <$fd>;
7772 # print element (entry, item)
7773 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
7774 if ($format eq 'rss') {
7776 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
7777 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
7778 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
7779 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
7780 "<link>$co_url</link>\n" .
7781 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
7782 "<content:encoded>" .
7784 } elsif ($format eq 'atom') {
7786 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
7787 "<updated>$cd{'iso-8601'}</updated>\n" .
7789 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
7790 if ($co{'author_email'}) {
7791 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
7793 print "</author>\n" .
7794 # use committer for contributor
7796 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
7797 if ($co{'committer_email'}) {
7798 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
7800 print "</contributor>\n" .
7801 "<published>$cd{'iso-8601'}</published>\n" .
7802 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
7803 "<id>$co_url</id>\n" .
7804 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
7805 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
7807 my $comment = $co{'comment'};
7809 foreach my $line (@
$comment) {
7810 $line = esc_html
($line);
7813 print "</pre><ul>\n";
7814 foreach my $difftree_line (@difftree) {
7815 my %difftree = parse_difftree_raw_line
($difftree_line);
7816 next if !$difftree{'from_id'};
7818 my $file = $difftree{'file'} || $difftree{'to_file'};
7822 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
7823 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
7824 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
7825 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
7826 -title
=> "diff"}, 'D');
7828 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
7829 file_name
=>$file, hash_base
=>$commit),
7830 -title
=> "blame"}, 'B');
7832 # if this is not a feed of a file history
7833 if (!defined $file_name || $file_name ne $file) {
7834 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
7835 file_name
=>$file, hash
=>$commit),
7836 -title
=> "history"}, 'H');
7838 $file = esc_path
($file);
7842 if ($format eq 'rss') {
7843 print "</ul>]]>\n" .
7844 "</content:encoded>\n" .
7846 } elsif ($format eq 'atom') {
7847 print "</ul>\n</div>\n" .
7854 if ($format eq 'rss') {
7855 print "</channel>\n</rss>\n";
7856 } elsif ($format eq 'atom') {
7870 my @list = git_get_projects_list
();
7872 die_error
(404, "No projects found");
7876 -type
=> 'text/xml',
7877 -charset
=> 'utf-8',
7878 -content_disposition
=> 'inline; filename="opml.xml"');
7880 my $title = esc_html
($site_name);
7882 <?xml version="1.0" encoding="utf-8"?>
7883 <opml version="1.0">
7885 <title>$title OPML Export</title>
7888 <outline text="git RSS feeds">
7891 foreach my $pr (@list) {
7893 my $head = git_get_head_hash
($proj{'path'});
7894 if (!defined $head) {
7897 $git_dir = "$projectroot/$proj{'path'}";
7898 my %co = parse_commit
($head);
7903 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
7904 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
7905 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
7906 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";