3 # gitweb - simple web interface to track changes in git repositories
5 # (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
6 # (C) 2005, Christian Gierke
8 # This program is licensed under the GPLv2
13 use CGI
qw(:standard :escapeHTML -nosticky);
14 use CGI
::Util
qw(unescape);
15 use CGI
::Carp
qw(fatalsToBrowser set_message);
19 use File
::Basename
qw(basename);
20 use Time
::HiRes
qw(gettimeofday tv_interval);
21 binmode STDOUT
, ':utf8';
23 our $t0 = [ gettimeofday
() ];
24 our $number_of_git_cmds = 0;
27 CGI
->compile() if $ENV{'MOD_PERL'};
30 our $version = "++GIT_VERSION++";
32 our ($my_url, $my_uri, $base_url, $path_info, $home_link);
36 our $my_url = $cgi->url();
37 our $my_uri = $cgi->url(-absolute
=> 1);
39 # Base URL for relative URLs in gitweb ($logo, $favicon, ...),
40 # needed and used only for URLs with nonempty PATH_INFO
41 our $base_url = $my_url;
43 # When the script is used as DirectoryIndex, the URL does not contain the name
44 # of the script file itself, and $cgi->url() fails to strip PATH_INFO, so we
45 # have to do it ourselves. We make $path_info global because it's also used
48 # Another issue with the script being the DirectoryIndex is that the resulting
49 # $my_url data is not the full script URL: this is good, because we want
50 # generated links to keep implying the script name if it wasn't explicitly
51 # indicated in the URL we're handling, but it means that $my_url cannot be used
53 # Therefore, if we needed to strip PATH_INFO, then we know that we have
54 # to build the base URL ourselves:
55 our $path_info = $ENV{"PATH_INFO"};
57 if ($my_url =~ s
,\Q
$path_info\E
$,, &&
58 $my_uri =~ s
,\Q
$path_info\E
$,, &&
59 defined $ENV{'SCRIPT_NAME'}) {
60 $base_url = $cgi->url(-base
=> 1) . $ENV{'SCRIPT_NAME'};
64 # target of the home link on top of all pages
65 our $home_link = $my_uri || "/";
68 # core git executable to use
69 # this can just be "git" if your webserver has a sensible PATH
70 our $GIT = "++GIT_BINDIR++/git";
72 # absolute fs-path which will be prepended to the project path
73 #our $projectroot = "/pub/scm";
74 our $projectroot = "++GITWEB_PROJECTROOT++";
76 # fs traversing limit for getting project list
77 # the number is relative to the projectroot
78 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
80 # string of the home link on top of all pages
81 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
83 # name of your site or organization to appear in page titles
84 # replace this with something more descriptive for clearer bookmarks
85 our $site_name = "++GITWEB_SITENAME++"
86 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
88 # html snippet to include in the <head> section of each page
89 our $site_html_head_string = "++GITWEB_SITE_HTML_HEAD_STRING++";
90 # filename of html text to include at top of each page
91 our $site_header = "++GITWEB_SITE_HEADER++";
92 # html text to include at home page
93 our $home_text = "++GITWEB_HOMETEXT++";
94 # filename of html text to include at bottom of each page
95 our $site_footer = "++GITWEB_SITE_FOOTER++";
98 our @stylesheets = ("++GITWEB_CSS++");
99 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
100 our $stylesheet = undef;
101 # URI of GIT logo (72x27 size)
102 our $logo = "++GITWEB_LOGO++";
103 # URI of GIT favicon, assumed to be image/png type
104 our $favicon = "++GITWEB_FAVICON++";
105 # URI of gitweb.js (JavaScript code for gitweb)
106 our $javascript = "++GITWEB_JS++";
108 # URI and label (title) of GIT logo link
109 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
110 #our $logo_label = "git documentation";
111 our $logo_url = "http://git-scm.com/";
112 our $logo_label = "git homepage";
114 # source of projects list
115 our $projects_list = "++GITWEB_LIST++";
117 # the width (in characters) of the projects list "Description" column
118 our $projects_list_description_width = 25;
120 # group projects by category on the projects list
121 # (enabled if this variable evaluates to true)
122 our $projects_list_group_categories = 0;
124 # default category if none specified
125 # (leave the empty string for no category)
126 our $project_list_default_category = "";
128 # default order of projects list
129 # valid values are none, project, descr, owner, and age
130 our $default_projects_order = "project";
132 # show repository only if this file exists
133 # (only effective if this variable evaluates to true)
134 our $export_ok = "++GITWEB_EXPORT_OK++";
136 # show repository only if this subroutine returns true
137 # when given the path to the project, for example:
138 # sub { return -e "$_[0]/git-daemon-export-ok"; }
139 our $export_auth_hook = undef;
141 # only allow viewing of repositories also shown on the overview page
142 our $strict_export = "++GITWEB_STRICT_EXPORT++";
144 # list of git base URLs used for URL to where fetch project from,
145 # i.e. full URL is "$git_base_url/$project"
146 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
148 # default blob_plain mimetype and default charset for text/plain blob
149 our $default_blob_plain_mimetype = 'text/plain';
150 our $default_text_plain_charset = undef;
152 # file to use for guessing MIME types before trying /etc/mime.types
153 # (relative to the current git repository)
154 our $mimetypes_file = undef;
156 # assume this charset if line contains non-UTF-8 characters;
157 # it should be valid encoding (see Encoding::Supported(3pm) for list),
158 # for which encoding all byte sequences are valid, for example
159 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
160 # could be even 'utf-8' for the old behavior)
161 our $fallback_encoding = 'latin1';
163 # rename detection options for git-diff and git-diff-tree
164 # - default is '-M', with the cost proportional to
165 # (number of removed files) * (number of new files).
166 # - more costly is '-C' (which implies '-M'), with the cost proportional to
167 # (number of changed files + number of removed files) * (number of new files)
168 # - even more costly is '-C', '--find-copies-harder' with cost
169 # (number of files in the original tree) * (number of new files)
170 # - one might want to include '-B' option, e.g. '-B', '-M'
171 our @diff_opts = ('-M'); # taken from git_commit
173 # Disables features that would allow repository owners to inject script into
175 our $prevent_xss = 0;
177 # Path to the highlight executable to use (must be the one from
178 # http://www.andre-simon.de due to assumptions about parameters and output).
179 # Useful if highlight is not installed on your webserver's PATH.
180 # [Default: highlight]
181 our $highlight_bin = "++HIGHLIGHT_BIN++";
183 # information about snapshot formats that gitweb is capable of serving
184 our %known_snapshot_formats = (
186 # 'display' => display name,
187 # 'type' => mime type,
188 # 'suffix' => filename suffix,
189 # 'format' => --format for git-archive,
190 # 'compressor' => [compressor command and arguments]
191 # (array reference, optional)
192 # 'disabled' => boolean (optional)}
195 'display' => 'tar.gz',
196 'type' => 'application/x-gzip',
197 'suffix' => '.tar.gz',
199 'compressor' => ['gzip', '-n']},
202 'display' => 'tar.bz2',
203 'type' => 'application/x-bzip2',
204 'suffix' => '.tar.bz2',
206 'compressor' => ['bzip2']},
209 'display' => 'tar.xz',
210 'type' => 'application/x-xz',
211 'suffix' => '.tar.xz',
213 'compressor' => ['xz'],
218 'type' => 'application/x-zip',
223 # Aliases so we understand old gitweb.snapshot values in repository
225 our %known_snapshot_format_aliases = (
230 # backward compatibility: legacy gitweb config support
231 'x-gzip' => undef, 'gz' => undef,
232 'x-bzip2' => undef, 'bz2' => undef,
233 'x-zip' => undef, '' => undef,
236 # Pixel sizes for icons and avatars. If the default font sizes or lineheights
237 # are changed, it may be appropriate to change these values too via
244 # Used to set the maximum load that we will still respond to gitweb queries.
245 # If server load exceed this value then return "503 server busy" error.
246 # If gitweb cannot determined server load, it is taken to be 0.
247 # Leave it undefined (or set to 'undef') to turn off load checking.
250 # configuration for 'highlight' (http://www.andre-simon.de/)
252 our %highlight_basename = (
255 'SConstruct' => 'py', # SCons equivalent of Makefile
256 'Makefile' => 'make',
259 our %highlight_ext = (
260 # main extensions, defining name of syntax;
261 # see files in /usr/share/highlight/langDefs/ directory
263 qw(py c cpp rb java css php sh pl js tex bib xml awk bat ini spec tcl sql make),
264 # alternate extensions, see /etc/highlight/filetypes.conf
266 map { $_ => 'sh' } qw(bash zsh ksh),
267 map { $_ => 'cpp' } qw(cxx c++ cc),
268 map { $_ => 'php' } qw(php3 php4 php5 phps),
269 map { $_ => 'pl' } qw(perl pm), # perhaps also 'cgi'
270 map { $_ => 'make'} qw(mak mk),
271 map { $_ => 'xml' } qw(xhtml html htm),
274 # You define site-wide feature defaults here; override them with
275 # $GITWEB_CONFIG as necessary.
278 # 'sub' => feature-sub (subroutine),
279 # 'override' => allow-override (boolean),
280 # 'default' => [ default options...] (array reference)}
282 # if feature is overridable (it means that allow-override has true value),
283 # then feature-sub will be called with default options as parameters;
284 # return value of feature-sub indicates if to enable specified feature
286 # if there is no 'sub' key (no feature-sub), then feature cannot be
289 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
290 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
293 # Enable the 'blame' blob view, showing the last commit that modified
294 # each line in the file. This can be very CPU-intensive.
296 # To enable system wide have in $GITWEB_CONFIG
297 # $feature{'blame'}{'default'} = [1];
298 # To have project specific config enable override in $GITWEB_CONFIG
299 # $feature{'blame'}{'override'} = 1;
300 # and in project config gitweb.blame = 0|1;
302 'sub' => sub { feature_bool
('blame', @_) },
306 # Enable the 'snapshot' link, providing a compressed archive of any
307 # tree. This can potentially generate high traffic if you have large
310 # Value is a list of formats defined in %known_snapshot_formats that
312 # To disable system wide have in $GITWEB_CONFIG
313 # $feature{'snapshot'}{'default'} = [];
314 # To have project specific config enable override in $GITWEB_CONFIG
315 # $feature{'snapshot'}{'override'} = 1;
316 # and in project config, a comma-separated list of formats or "none"
317 # to disable. Example: gitweb.snapshot = tbz2,zip;
319 'sub' => \
&feature_snapshot
,
321 'default' => ['tgz']},
323 # Enable text search, which will list the commits which match author,
324 # committer or commit text to a given string. Enabled by default.
325 # Project specific override is not supported.
327 # Note that this controls all search features, which means that if
328 # it is disabled, then 'grep' and 'pickaxe' search would also be
334 # Enable grep search, which will list the files in currently selected
335 # tree containing the given string. Enabled by default. This can be
336 # potentially CPU-intensive, of course.
337 # Note that you need to have 'search' feature enabled too.
339 # To enable system wide have in $GITWEB_CONFIG
340 # $feature{'grep'}{'default'} = [1];
341 # To have project specific config enable override in $GITWEB_CONFIG
342 # $feature{'grep'}{'override'} = 1;
343 # and in project config gitweb.grep = 0|1;
345 'sub' => sub { feature_bool
('grep', @_) },
349 # Enable the pickaxe search, which will list the commits that modified
350 # a given string in a file. This can be practical and quite faster
351 # alternative to 'blame', but still potentially CPU-intensive.
352 # Note that you need to have 'search' feature enabled too.
354 # To enable system wide have in $GITWEB_CONFIG
355 # $feature{'pickaxe'}{'default'} = [1];
356 # To have project specific config enable override in $GITWEB_CONFIG
357 # $feature{'pickaxe'}{'override'} = 1;
358 # and in project config gitweb.pickaxe = 0|1;
360 'sub' => sub { feature_bool
('pickaxe', @_) },
364 # Enable showing size of blobs in a 'tree' view, in a separate
365 # column, similar to what 'ls -l' does. This cost a bit of IO.
367 # To disable system wide have in $GITWEB_CONFIG
368 # $feature{'show-sizes'}{'default'} = [0];
369 # To have project specific config enable override in $GITWEB_CONFIG
370 # $feature{'show-sizes'}{'override'} = 1;
371 # and in project config gitweb.showsizes = 0|1;
373 'sub' => sub { feature_bool
('showsizes', @_) },
377 # Make gitweb use an alternative format of the URLs which can be
378 # more readable and natural-looking: project name is embedded
379 # directly in the path and the query string contains other
380 # auxiliary information. All gitweb installations recognize
381 # URL in either format; this configures in which formats gitweb
384 # To enable system wide have in $GITWEB_CONFIG
385 # $feature{'pathinfo'}{'default'} = [1];
386 # Project specific override is not supported.
388 # Note that you will need to change the default location of CSS,
389 # favicon, logo and possibly other files to an absolute URL. Also,
390 # if gitweb.cgi serves as your indexfile, you will need to force
391 # $my_uri to contain the script name in your $GITWEB_CONFIG.
396 # Make gitweb consider projects in project root subdirectories
397 # to be forks of existing projects. Given project $projname.git,
398 # projects matching $projname/*.git will not be shown in the main
399 # projects list, instead a '+' mark will be added to $projname
400 # there and a 'forks' view will be enabled for the project, listing
401 # all the forks. If project list is taken from a file, forks have
402 # to be listed after the main project.
404 # To enable system wide have in $GITWEB_CONFIG
405 # $feature{'forks'}{'default'} = [1];
406 # Project specific override is not supported.
411 # Insert custom links to the action bar of all project pages.
412 # This enables you mainly to link to third-party scripts integrating
413 # into gitweb; e.g. git-browser for graphical history representation
414 # or custom web-based repository administration interface.
416 # The 'default' value consists of a list of triplets in the form
417 # (label, link, position) where position is the label after which
418 # to insert the link and link is a format string where %n expands
419 # to the project name, %f to the project path within the filesystem,
420 # %h to the current hash (h gitweb parameter) and %b to the current
421 # hash base (hb gitweb parameter); %% expands to %.
423 # To enable system wide have in $GITWEB_CONFIG e.g.
424 # $feature{'actions'}{'default'} = [('graphiclog',
425 # '/git-browser/by-commit.html?r=%n', 'summary')];
426 # Project specific override is not supported.
431 # Allow gitweb scan project content tags of project repository,
432 # and display the popular Web 2.0-ish "tag cloud" near the projects
433 # list. Note that this is something COMPLETELY different from the
436 # gitweb by itself can show existing tags, but it does not handle
437 # tagging itself; you need to do it externally, outside gitweb.
438 # The format is described in git_get_project_ctags() subroutine.
439 # You may want to install the HTML::TagCloud Perl module to get
440 # a pretty tag cloud instead of just a list of tags.
442 # To enable system wide have in $GITWEB_CONFIG
443 # $feature{'ctags'}{'default'} = [1];
444 # Project specific override is not supported.
446 # In the future whether ctags editing is enabled might depend
447 # on the value, but using 1 should always mean no editing of ctags.
452 # The maximum number of patches in a patchset generated in patch
453 # view. Set this to 0 or undef to disable patch view, or to a
454 # negative number to remove any limit.
456 # To disable system wide have in $GITWEB_CONFIG
457 # $feature{'patches'}{'default'} = [0];
458 # To have project specific config enable override in $GITWEB_CONFIG
459 # $feature{'patches'}{'override'} = 1;
460 # and in project config gitweb.patches = 0|n;
461 # where n is the maximum number of patches allowed in a patchset.
463 'sub' => \
&feature_patches
,
467 # Avatar support. When this feature is enabled, views such as
468 # shortlog or commit will display an avatar associated with
469 # the email of the committer(s) and/or author(s).
471 # Currently available providers are gravatar and picon.
472 # If an unknown provider is specified, the feature is disabled.
474 # Gravatar depends on Digest::MD5.
475 # Picon currently relies on the indiana.edu database.
477 # To enable system wide have in $GITWEB_CONFIG
478 # $feature{'avatar'}{'default'} = ['<provider>'];
479 # where <provider> is either gravatar or picon.
480 # To have project specific config enable override in $GITWEB_CONFIG
481 # $feature{'avatar'}{'override'} = 1;
482 # and in project config gitweb.avatar = <provider>;
484 'sub' => \
&feature_avatar
,
488 # Enable displaying how much time and how many git commands
489 # it took to generate and display page. Disabled by default.
490 # Project specific override is not supported.
495 # Enable turning some links into links to actions which require
496 # JavaScript to run (like 'blame_incremental'). Not enabled by
497 # default. Project specific override is currently not supported.
498 'javascript-actions' => {
502 # Enable and configure ability to change common timezone for dates
503 # in gitweb output via JavaScript. Enabled by default.
504 # Project specific override is not supported.
505 'javascript-timezone' => {
508 'local', # default timezone: 'utc', 'local', or '(-|+)HHMM' format,
509 # or undef to turn off this feature
510 'gitweb_tz', # name of cookie where to store selected timezone
511 'datetime', # CSS class used to mark up dates for manipulation
514 # Syntax highlighting support. This is based on Daniel Svensson's
515 # and Sham Chukoury's work in gitweb-xmms2.git.
516 # It requires the 'highlight' program present in $PATH,
517 # and therefore is disabled by default.
519 # To enable system wide have in $GITWEB_CONFIG
520 # $feature{'highlight'}{'default'} = [1];
523 'sub' => sub { feature_bool
('highlight', @_) },
527 # Enable displaying of remote heads in the heads list
529 # To enable system wide have in $GITWEB_CONFIG
530 # $feature{'remote_heads'}{'default'} = [1];
531 # To have project specific config enable override in $GITWEB_CONFIG
532 # $feature{'remote_heads'}{'override'} = 1;
533 # and in project config gitweb.remote_heads = 0|1;
535 'sub' => sub { feature_bool
('remote_heads', @_) },
540 sub gitweb_get_feature
{
542 return unless exists $feature{$name};
543 my ($sub, $override, @defaults) = (
544 $feature{$name}{'sub'},
545 $feature{$name}{'override'},
546 @
{$feature{$name}{'default'}});
547 # project specific override is possible only if we have project
548 our $git_dir; # global variable, declared later
549 if (!$override || !defined $git_dir) {
553 warn "feature $name is not overridable";
556 return $sub->(@defaults);
559 # A wrapper to check if a given feature is enabled.
560 # With this, you can say
562 # my $bool_feat = gitweb_check_feature('bool_feat');
563 # gitweb_check_feature('bool_feat') or somecode;
567 # my ($bool_feat) = gitweb_get_feature('bool_feat');
568 # (gitweb_get_feature('bool_feat'))[0] or somecode;
570 sub gitweb_check_feature
{
571 return (gitweb_get_feature
(@_))[0];
577 my ($val) = git_get_project_config
($key, '--bool');
581 } elsif ($val eq 'true') {
583 } elsif ($val eq 'false') {
588 sub feature_snapshot
{
591 my ($val) = git_get_project_config
('snapshot');
594 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
600 sub feature_patches
{
601 my @val = (git_get_project_config
('patches', '--int'));
611 my @val = (git_get_project_config
('avatar'));
613 return @val ?
@val : @_;
616 # checking HEAD file with -e is fragile if the repository was
617 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
619 sub check_head_link
{
621 my $headfile = "$dir/HEAD";
622 return ((-e
$headfile) ||
623 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
626 sub check_export_ok
{
628 return (check_head_link
($dir) &&
629 (!$export_ok || -e
"$dir/$export_ok") &&
630 (!$export_auth_hook || $export_auth_hook->($dir)));
633 # process alternate names for backward compatibility
634 # filter out unsupported (unknown) snapshot formats
635 sub filter_snapshot_fmts
{
639 exists $known_snapshot_format_aliases{$_} ?
640 $known_snapshot_format_aliases{$_} : $_} @fmts;
642 exists $known_snapshot_formats{$_} &&
643 !$known_snapshot_formats{$_}{'disabled'}} @fmts;
646 # If it is set to code reference, it is code that it is to be run once per
647 # request, allowing updating configurations that change with each request,
648 # while running other code in config file only once.
650 # Otherwise, if it is false then gitweb would process config file only once;
651 # if it is true then gitweb config would be run for each request.
652 our $per_request_config = 1;
654 # read and parse gitweb config file given by its parameter.
655 # returns true on success, false on recoverable error, allowing
656 # to chain this subroutine, using first file that exists.
657 # dies on errors during parsing config file, as it is unrecoverable.
658 sub read_config_file
{
659 my $filename = shift;
660 return unless defined $filename;
661 # die if there are errors parsing config file
670 our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM, $GITWEB_CONFIG_COMMON);
671 sub evaluate_gitweb_config
{
672 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
673 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
674 our $GITWEB_CONFIG_COMMON = $ENV{'GITWEB_CONFIG_COMMON'} || "++GITWEB_CONFIG_COMMON++";
676 # Protect agains duplications of file names, to not read config twice.
677 # Only one of $GITWEB_CONFIG and $GITWEB_CONFIG_SYSTEM is used, so
678 # there possibility of duplication of filename there doesn't matter.
679 $GITWEB_CONFIG = "" if ($GITWEB_CONFIG eq $GITWEB_CONFIG_COMMON);
680 $GITWEB_CONFIG_SYSTEM = "" if ($GITWEB_CONFIG_SYSTEM eq $GITWEB_CONFIG_COMMON);
682 # Common system-wide settings for convenience.
683 # Those settings can be ovverriden by GITWEB_CONFIG or GITWEB_CONFIG_SYSTEM.
684 read_config_file
($GITWEB_CONFIG_COMMON);
686 # Use first config file that exists. This means use the per-instance
687 # GITWEB_CONFIG if exists, otherwise use GITWEB_SYSTEM_CONFIG.
688 read_config_file
($GITWEB_CONFIG) and return;
689 read_config_file
($GITWEB_CONFIG_SYSTEM);
692 # Get loadavg of system, to compare against $maxload.
693 # Currently it requires '/proc/loadavg' present to get loadavg;
694 # if it is not present it returns 0, which means no load checking.
696 if( -e
'/proc/loadavg' ){
697 open my $fd, '<', '/proc/loadavg'
699 my @load = split(/\s+/, scalar <$fd>);
702 # The first three columns measure CPU and IO utilization of the last one,
703 # five, and 10 minute periods. The fourth column shows the number of
704 # currently running processes and the total number of processes in the m/n
705 # format. The last column displays the last process ID used.
706 return $load[0] || 0;
708 # additional checks for load average should go here for things that don't export
714 # version of the core git binary
716 sub evaluate_git_version
{
717 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
718 $number_of_git_cmds++;
722 if (defined $maxload && get_loadavg
() > $maxload) {
723 die_error
(503, "The load average on the server is too high");
727 # ======================================================================
728 # input validation and dispatch
730 # input parameters can be collected from a variety of sources (presently, CGI
731 # and PATH_INFO), so we define an %input_params hash that collects them all
732 # together during validation: this allows subsequent uses (e.g. href()) to be
733 # agnostic of the parameter origin
735 our %input_params = ();
737 # input parameters are stored with the long parameter name as key. This will
738 # also be used in the href subroutine to convert parameters to their CGI
739 # equivalent, and since the href() usage is the most frequent one, we store
740 # the name -> CGI key mapping here, instead of the reverse.
742 # XXX: Warning: If you touch this, check the search form for updating,
745 our @cgi_param_mapping = (
753 hash_parent_base
=> "hpb",
758 snapshot_format
=> "sf",
759 extra_options
=> "opt",
760 search_use_regexp
=> "sr",
763 # this must be last entry (for manipulation from JavaScript)
766 our %cgi_param_mapping = @cgi_param_mapping;
768 # we will also need to know the possible actions, for validation
770 "blame" => \
&git_blame
,
771 "blame_incremental" => \
&git_blame_incremental
,
772 "blame_data" => \
&git_blame_data
,
773 "blobdiff" => \
&git_blobdiff
,
774 "blobdiff_plain" => \
&git_blobdiff_plain
,
775 "blob" => \
&git_blob
,
776 "blob_plain" => \
&git_blob_plain
,
777 "commitdiff" => \
&git_commitdiff
,
778 "commitdiff_plain" => \
&git_commitdiff_plain
,
779 "commit" => \
&git_commit
,
780 "forks" => \
&git_forks
,
781 "heads" => \
&git_heads
,
782 "history" => \
&git_history
,
784 "patch" => \
&git_patch
,
785 "patches" => \
&git_patches
,
786 "remotes" => \
&git_remotes
,
788 "atom" => \
&git_atom
,
789 "search" => \
&git_search
,
790 "search_help" => \
&git_search_help
,
791 "shortlog" => \
&git_shortlog
,
792 "summary" => \
&git_summary
,
794 "tags" => \
&git_tags
,
795 "tree" => \
&git_tree
,
796 "snapshot" => \
&git_snapshot
,
797 "object" => \
&git_object
,
798 # those below don't need $project
799 "opml" => \
&git_opml
,
800 "project_list" => \
&git_project_list
,
801 "project_index" => \
&git_project_index
,
804 # finally, we have the hash of allowed extra_options for the commands that
806 our %allowed_options = (
807 "--no-merges" => [ qw(rss atom log shortlog history) ],
810 # fill %input_params with the CGI parameters. All values except for 'opt'
811 # should be single values, but opt can be an array. We should probably
812 # build an array of parameters that can be multi-valued, but since for the time
813 # being it's only this one, we just single it out
814 sub evaluate_query_params
{
817 while (my ($name, $symbol) = each %cgi_param_mapping) {
818 if ($symbol eq 'opt') {
819 $input_params{$name} = [ $cgi->param($symbol) ];
821 $input_params{$name} = $cgi->param($symbol);
826 # now read PATH_INFO and update the parameter list for missing parameters
827 sub evaluate_path_info
{
828 return if defined $input_params{'project'};
829 return if !$path_info;
830 $path_info =~ s
,^/+,,;
831 return if !$path_info;
833 # find which part of PATH_INFO is project
834 my $project = $path_info;
836 while ($project && !check_head_link
("$projectroot/$project")) {
837 $project =~ s
,/*[^/]*$,,;
839 return unless $project;
840 $input_params{'project'} = $project;
842 # do not change any parameters if an action is given using the query string
843 return if $input_params{'action'};
844 $path_info =~ s
,^\Q
$project\E
/*,,;
846 # next, check if we have an action
847 my $action = $path_info;
849 if (exists $actions{$action}) {
850 $path_info =~ s
,^$action/*,,;
851 $input_params{'action'} = $action;
854 # list of actions that want hash_base instead of hash, but can have no
855 # pathname (f) parameter
861 # we want to catch, among others
862 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
863 my ($parentrefname, $parentpathname, $refname, $pathname) =
864 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?([^:]+?)?(?::(.+))?$/);
866 # first, analyze the 'current' part
867 if (defined $pathname) {
868 # we got "branch:filename" or "branch:dir/"
869 # we could use git_get_type(branch:pathname), but:
870 # - it needs $git_dir
871 # - it does a git() call
872 # - the convention of terminating directories with a slash
873 # makes it superfluous
874 # - embedding the action in the PATH_INFO would make it even
876 $pathname =~ s
,^/+,,;
877 if (!$pathname || substr($pathname, -1) eq "/") {
878 $input_params{'action'} ||= "tree";
881 # the default action depends on whether we had parent info
883 if ($parentrefname) {
884 $input_params{'action'} ||= "blobdiff_plain";
886 $input_params{'action'} ||= "blob_plain";
889 $input_params{'hash_base'} ||= $refname;
890 $input_params{'file_name'} ||= $pathname;
891 } elsif (defined $refname) {
892 # we got "branch". In this case we have to choose if we have to
893 # set hash or hash_base.
895 # Most of the actions without a pathname only want hash to be
896 # set, except for the ones specified in @wants_base that want
897 # hash_base instead. It should also be noted that hand-crafted
898 # links having 'history' as an action and no pathname or hash
899 # set will fail, but that happens regardless of PATH_INFO.
900 if (defined $parentrefname) {
901 # if there is parent let the default be 'shortlog' action
902 # (for http://git.example.com/repo.git/A..B links); if there
903 # is no parent, dispatch will detect type of object and set
904 # action appropriately if required (if action is not set)
905 $input_params{'action'} ||= "shortlog";
907 if ($input_params{'action'} &&
908 grep { $_ eq $input_params{'action'} } @wants_base) {
909 $input_params{'hash_base'} ||= $refname;
911 $input_params{'hash'} ||= $refname;
915 # next, handle the 'parent' part, if present
916 if (defined $parentrefname) {
917 # a missing pathspec defaults to the 'current' filename, allowing e.g.
918 # someproject/blobdiff/oldrev..newrev:/filename
919 if ($parentpathname) {
920 $parentpathname =~ s
,^/+,,;
921 $parentpathname =~ s
,/$,,;
922 $input_params{'file_parent'} ||= $parentpathname;
924 $input_params{'file_parent'} ||= $input_params{'file_name'};
926 # we assume that hash_parent_base is wanted if a path was specified,
927 # or if the action wants hash_base instead of hash
928 if (defined $input_params{'file_parent'} ||
929 grep { $_ eq $input_params{'action'} } @wants_base) {
930 $input_params{'hash_parent_base'} ||= $parentrefname;
932 $input_params{'hash_parent'} ||= $parentrefname;
936 # for the snapshot action, we allow URLs in the form
937 # $project/snapshot/$hash.ext
938 # where .ext determines the snapshot and gets removed from the
939 # passed $refname to provide the $hash.
941 # To be able to tell that $refname includes the format extension, we
942 # require the following two conditions to be satisfied:
943 # - the hash input parameter MUST have been set from the $refname part
944 # of the URL (i.e. they must be equal)
945 # - the snapshot format MUST NOT have been defined already (e.g. from
947 # It's also useless to try any matching unless $refname has a dot,
948 # so we check for that too
949 if (defined $input_params{'action'} &&
950 $input_params{'action'} eq 'snapshot' &&
951 defined $refname && index($refname, '.') != -1 &&
952 $refname eq $input_params{'hash'} &&
953 !defined $input_params{'snapshot_format'}) {
954 # We loop over the known snapshot formats, checking for
955 # extensions. Allowed extensions are both the defined suffix
956 # (which includes the initial dot already) and the snapshot
957 # format key itself, with a prepended dot
958 while (my ($fmt, $opt) = each %known_snapshot_formats) {
960 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
964 # a valid suffix was found, so set the snapshot format
965 # and reset the hash parameter
966 $input_params{'snapshot_format'} = $fmt;
967 $input_params{'hash'} = $hash;
968 # we also set the format suffix to the one requested
969 # in the URL: this way a request for e.g. .tgz returns
970 # a .tgz instead of a .tar.gz
971 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
977 our ($action, $project, $file_name, $file_parent, $hash, $hash_parent, $hash_base,
978 $hash_parent_base, @extra_options, $page, $searchtype, $search_use_regexp,
979 $searchtext, $search_regexp);
980 sub evaluate_and_validate_params
{
981 our $action = $input_params{'action'};
982 if (defined $action) {
983 if (!validate_action
($action)) {
984 die_error
(400, "Invalid action parameter");
988 # parameters which are pathnames
989 our $project = $input_params{'project'};
990 if (defined $project) {
991 if (!validate_project
($project)) {
993 die_error
(404, "No such project");
997 our $file_name = $input_params{'file_name'};
998 if (defined $file_name) {
999 if (!validate_pathname
($file_name)) {
1000 die_error
(400, "Invalid file parameter");
1004 our $file_parent = $input_params{'file_parent'};
1005 if (defined $file_parent) {
1006 if (!validate_pathname
($file_parent)) {
1007 die_error
(400, "Invalid file parent parameter");
1011 # parameters which are refnames
1012 our $hash = $input_params{'hash'};
1013 if (defined $hash) {
1014 if (!validate_refname
($hash)) {
1015 die_error
(400, "Invalid hash parameter");
1019 our $hash_parent = $input_params{'hash_parent'};
1020 if (defined $hash_parent) {
1021 if (!validate_refname
($hash_parent)) {
1022 die_error
(400, "Invalid hash parent parameter");
1026 our $hash_base = $input_params{'hash_base'};
1027 if (defined $hash_base) {
1028 if (!validate_refname
($hash_base)) {
1029 die_error
(400, "Invalid hash base parameter");
1033 our @extra_options = @
{$input_params{'extra_options'}};
1034 # @extra_options is always defined, since it can only be (currently) set from
1035 # CGI, and $cgi->param() returns the empty array in array context if the param
1037 foreach my $opt (@extra_options) {
1038 if (not exists $allowed_options{$opt}) {
1039 die_error
(400, "Invalid option parameter");
1041 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
1042 die_error
(400, "Invalid option parameter for this action");
1046 our $hash_parent_base = $input_params{'hash_parent_base'};
1047 if (defined $hash_parent_base) {
1048 if (!validate_refname
($hash_parent_base)) {
1049 die_error
(400, "Invalid hash parent base parameter");
1054 our $page = $input_params{'page'};
1055 if (defined $page) {
1056 if ($page =~ m/[^0-9]/) {
1057 die_error
(400, "Invalid page parameter");
1061 our $searchtype = $input_params{'searchtype'};
1062 if (defined $searchtype) {
1063 if ($searchtype =~ m/[^a-z]/) {
1064 die_error
(400, "Invalid searchtype parameter");
1068 our $search_use_regexp = $input_params{'search_use_regexp'};
1070 our $searchtext = $input_params{'searchtext'};
1072 if (defined $searchtext) {
1073 if (length($searchtext) < 2) {
1074 die_error
(403, "At least two characters are required for search parameter");
1076 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
1080 # path to the current git repository
1082 sub evaluate_git_dir
{
1083 our $git_dir = "$projectroot/$project" if $project;
1086 our (@snapshot_fmts, $git_avatar);
1087 sub configure_gitweb_features
{
1088 # list of supported snapshot formats
1089 our @snapshot_fmts = gitweb_get_feature
('snapshot');
1090 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1092 # check that the avatar feature is set to a known provider name,
1093 # and for each provider check if the dependencies are satisfied.
1094 # if the provider name is invalid or the dependencies are not met,
1095 # reset $git_avatar to the empty string.
1096 our ($git_avatar) = gitweb_get_feature
('avatar');
1097 if ($git_avatar eq 'gravatar') {
1098 $git_avatar = '' unless (eval { require Digest
::MD5
; 1; });
1099 } elsif ($git_avatar eq 'picon') {
1106 # custom error handler: 'die <message>' is Internal Server Error
1107 sub handle_errors_html
{
1108 my $msg = shift; # it is already HTML escaped
1110 # to avoid infinite loop where error occurs in die_error,
1111 # change handler to default handler, disabling handle_errors_html
1112 set_message
("Error occured when inside die_error:\n$msg");
1114 # you cannot jump out of die_error when called as error handler;
1115 # the subroutine set via CGI::Carp::set_message is called _after_
1116 # HTTP headers are already written, so it cannot write them itself
1117 die_error
(undef, undef, $msg, -error_handler
=> 1, -no_http_header
=> 1);
1119 set_message
(\
&handle_errors_html
);
1123 if (!defined $action) {
1124 if (defined $hash) {
1125 $action = git_get_type
($hash);
1126 $action or die_error
(404, "Object does not exist");
1127 } elsif (defined $hash_base && defined $file_name) {
1128 $action = git_get_type
("$hash_base:$file_name");
1129 $action or die_error
(404, "File or directory does not exist");
1130 } elsif (defined $project) {
1131 $action = 'summary';
1133 $action = 'project_list';
1136 if (!defined($actions{$action})) {
1137 die_error
(400, "Unknown action");
1139 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1141 die_error
(400, "Project needed");
1143 $actions{$action}->();
1147 our $t0 = [ gettimeofday
() ]
1149 our $number_of_git_cmds = 0;
1152 our $first_request = 1;
1157 if ($first_request) {
1158 evaluate_gitweb_config
();
1159 evaluate_git_version
();
1161 if ($per_request_config) {
1162 if (ref($per_request_config) eq 'CODE') {
1163 $per_request_config->();
1164 } elsif (!$first_request) {
1165 evaluate_gitweb_config
();
1170 # $projectroot and $projects_list might be set in gitweb config file
1171 $projects_list ||= $projectroot;
1173 evaluate_query_params
();
1174 evaluate_path_info
();
1175 evaluate_and_validate_params
();
1178 configure_gitweb_features
();
1183 our $is_last_request = sub { 1 };
1184 our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1187 sub configure_as_fcgi
{
1189 our $CGI = 'CGI::Fast';
1191 my $request_number = 0;
1192 # let each child service 100 requests
1193 our $is_last_request = sub { ++$request_number > 100 };
1196 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__
;
1198 if $script_name =~ /\.fcgi$/;
1200 return unless (@ARGV);
1202 require Getopt
::Long
;
1203 Getopt
::Long
::GetOptions
(
1204 'fastcgi|fcgi|f' => \
&configure_as_fcgi
,
1205 'nproc|n=i' => sub {
1206 my ($arg, $val) = @_;
1207 return unless eval { require FCGI
::ProcManager
; 1; };
1208 my $proc_manager = FCGI
::ProcManager
->new({
1209 n_processes
=> $val,
1211 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1212 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1213 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1222 $pre_listen_hook->()
1223 if $pre_listen_hook;
1226 while ($cgi = $CGI->new()) {
1227 $pre_dispatch_hook->()
1228 if $pre_dispatch_hook;
1232 $post_dispatch_hook->()
1233 if $post_dispatch_hook;
1236 last REQUEST
if ($is_last_request->());
1245 if (defined caller) {
1246 # wrapped in a subroutine processing requests,
1247 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1250 # pure CGI script, serving single request
1254 ## ======================================================================
1257 # possible values of extra options
1258 # -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1259 # -replay => 1 - start from a current view (replay with modifications)
1260 # -path_info => 0|1 - don't use/use path_info URL (if possible)
1261 # -anchor => ANCHOR - add #ANCHOR to end of URL, implies -replay if used alone
1264 # default is to use -absolute url() i.e. $my_uri
1265 my $href = $params{-full
} ?
$my_url : $my_uri;
1267 # implicit -replay, must be first of implicit params
1268 $params{-replay
} = 1 if (keys %params == 1 && $params{-anchor
});
1270 $params{'project'} = $project unless exists $params{'project'};
1272 if ($params{-replay
}) {
1273 while (my ($name, $symbol) = each %cgi_param_mapping) {
1274 if (!exists $params{$name}) {
1275 $params{$name} = $input_params{$name};
1280 my $use_pathinfo = gitweb_check_feature
('pathinfo');
1281 if (defined $params{'project'} &&
1282 (exists $params{-path_info
} ?
$params{-path_info
} : $use_pathinfo)) {
1283 # try to put as many parameters as possible in PATH_INFO:
1286 # - hash_parent or hash_parent_base:/file_parent
1287 # - hash or hash_base:/filename
1288 # - the snapshot_format as an appropriate suffix
1290 # When the script is the root DirectoryIndex for the domain,
1291 # $href here would be something like http://gitweb.example.com/
1292 # Thus, we strip any trailing / from $href, to spare us double
1293 # slashes in the final URL
1296 # Then add the project name, if present
1297 $href .= "/".esc_path_info
($params{'project'});
1298 delete $params{'project'};
1300 # since we destructively absorb parameters, we keep this
1301 # boolean that remembers if we're handling a snapshot
1302 my $is_snapshot = $params{'action'} eq 'snapshot';
1304 # Summary just uses the project path URL, any other action is
1306 if (defined $params{'action'}) {
1307 $href .= "/".esc_path_info
($params{'action'})
1308 unless $params{'action'} eq 'summary';
1309 delete $params{'action'};
1312 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1313 # stripping nonexistent or useless pieces
1314 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1315 || $params{'hash_parent'} || $params{'hash'});
1316 if (defined $params{'hash_base'}) {
1317 if (defined $params{'hash_parent_base'}) {
1318 $href .= esc_path_info
($params{'hash_parent_base'});
1319 # skip the file_parent if it's the same as the file_name
1320 if (defined $params{'file_parent'}) {
1321 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1322 delete $params{'file_parent'};
1323 } elsif ($params{'file_parent'} !~ /\.\./) {
1324 $href .= ":/".esc_path_info
($params{'file_parent'});
1325 delete $params{'file_parent'};
1329 delete $params{'hash_parent'};
1330 delete $params{'hash_parent_base'};
1331 } elsif (defined $params{'hash_parent'}) {
1332 $href .= esc_path_info
($params{'hash_parent'}). "..";
1333 delete $params{'hash_parent'};
1336 $href .= esc_path_info
($params{'hash_base'});
1337 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
1338 $href .= ":/".esc_path_info
($params{'file_name'});
1339 delete $params{'file_name'};
1341 delete $params{'hash'};
1342 delete $params{'hash_base'};
1343 } elsif (defined $params{'hash'}) {
1344 $href .= esc_path_info
($params{'hash'});
1345 delete $params{'hash'};
1348 # If the action was a snapshot, we can absorb the
1349 # snapshot_format parameter too
1351 my $fmt = $params{'snapshot_format'};
1352 # snapshot_format should always be defined when href()
1353 # is called, but just in case some code forgets, we
1354 # fall back to the default
1355 $fmt ||= $snapshot_fmts[0];
1356 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1357 delete $params{'snapshot_format'};
1361 # now encode the parameters explicitly
1363 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1364 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
1365 if (defined $params{$name}) {
1366 if (ref($params{$name}) eq "ARRAY") {
1367 foreach my $par (@
{$params{$name}}) {
1368 push @result, $symbol . "=" . esc_param
($par);
1371 push @result, $symbol . "=" . esc_param
($params{$name});
1375 $href .= "?" . join(';', @result) if scalar @result;
1377 # final transformation: trailing spaces must be escaped (URI-encoded)
1378 $href =~ s/(\s+)$/CGI::escape($1)/e;
1380 if ($params{-anchor
}) {
1381 $href .= "#".esc_param
($params{-anchor
});
1388 ## ======================================================================
1389 ## validation, quoting/unquoting and escaping
1391 sub validate_action
{
1392 my $input = shift || return undef;
1393 return undef unless exists $actions{$input};
1397 sub validate_project
{
1398 my $input = shift || return undef;
1399 if (!validate_pathname
($input) ||
1400 !(-d
"$projectroot/$input") ||
1401 !check_export_ok
("$projectroot/$input") ||
1402 ($strict_export && !project_in_list
($input))) {
1409 sub validate_pathname
{
1410 my $input = shift || return undef;
1412 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1413 # at the beginning, at the end, and between slashes.
1414 # also this catches doubled slashes
1415 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1418 # no null characters
1419 if ($input =~ m!\0!) {
1425 sub validate_refname
{
1426 my $input = shift || return undef;
1428 # textual hashes are O.K.
1429 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1432 # it must be correct pathname
1433 $input = validate_pathname
($input)
1435 # restrictions on ref name according to git-check-ref-format
1436 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1442 # decode sequences of octets in utf8 into Perl's internal form,
1443 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1444 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1447 return undef unless defined $str;
1449 if (utf8
::is_utf8
($str) || utf8
::decode
($str)) {
1452 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
1456 # quote unsafe chars, but keep the slash, even when it's not
1457 # correct, but quoted slashes look too horrible in bookmarks
1460 return undef unless defined $str;
1461 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI
::escape
($1)/eg
;
1466 # the quoting rules for path_info fragment are slightly different
1469 return undef unless defined $str;
1471 # path_info doesn't treat '+' as space (specially), but '?' must be escaped
1472 $str =~ s/([^A-Za-z0-9\-_.~();\/;:@&= +]+)/CGI
::escape
($1)/eg
;
1477 # quote unsafe chars in whole URL, so some characters cannot be quoted
1480 return undef unless defined $str;
1481 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI
::escape
($1)/eg
;
1486 # quote unsafe characters in HTML attributes
1489 # for XHTML conformance escaping '"' to '"' is not enough
1490 return esc_html
(@_);
1493 # replace invalid utf8 character with SUBSTITUTION sequence
1498 return undef unless defined $str;
1500 $str = to_utf8
($str);
1501 $str = $cgi->escapeHTML($str);
1502 if ($opts{'-nbsp'}) {
1503 $str =~ s/ / /g;
1505 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1509 # quote control characters and escape filename to HTML
1514 return undef unless defined $str;
1516 $str = to_utf8
($str);
1517 $str = $cgi->escapeHTML($str);
1518 if ($opts{'-nbsp'}) {
1519 $str =~ s/ / /g;
1521 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1525 # Sanitize for use in XHTML + application/xml+xhtm (valid XML 1.0)
1529 return undef unless defined $str;
1531 $str = to_utf8
($str);
1532 $str =~ s
|([[:cntrl
:]])|($1 =~ /[\t\n\r]/ ?
$1 : quot_cec
($1))|eg
;
1536 # Make control characters "printable", using character escape codes (CEC)
1540 my %es = ( # character escape codes, aka escape sequences
1541 "\t" => '\t', # tab (HT)
1542 "\n" => '\n', # line feed (LF)
1543 "\r" => '\r', # carrige return (CR)
1544 "\f" => '\f', # form feed (FF)
1545 "\b" => '\b', # backspace (BS)
1546 "\a" => '\a', # alarm (bell) (BEL)
1547 "\e" => '\e', # escape (ESC)
1548 "\013" => '\v', # vertical tab (VT)
1549 "\000" => '\0', # nul character (NUL)
1551 my $chr = ( (exists $es{$cntrl})
1553 : sprintf('\%2x', ord($cntrl)) );
1554 if ($opts{-nohtml
}) {
1557 return "<span class=\"cntrl\">$chr</span>";
1561 # Alternatively use unicode control pictures codepoints,
1562 # Unicode "printable representation" (PR)
1567 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1568 if ($opts{-nohtml
}) {
1571 return "<span class=\"cntrl\">$chr</span>";
1575 # git may return quoted and escaped filenames
1581 my %es = ( # character escape codes, aka escape sequences
1582 't' => "\t", # tab (HT, TAB)
1583 'n' => "\n", # newline (NL)
1584 'r' => "\r", # return (CR)
1585 'f' => "\f", # form feed (FF)
1586 'b' => "\b", # backspace (BS)
1587 'a' => "\a", # alarm (bell) (BEL)
1588 'e' => "\e", # escape (ESC)
1589 'v' => "\013", # vertical tab (VT)
1592 if ($seq =~ m/^[0-7]{1,3}$/) {
1593 # octal char sequence
1594 return chr(oct($seq));
1595 } elsif (exists $es{$seq}) {
1596 # C escape sequence, aka character escape code
1599 # quoted ordinary character
1603 if ($str =~ m/^"(.*)"$/) {
1606 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1611 # escape tabs (convert tabs to spaces)
1615 while ((my $pos = index($line, "\t")) != -1) {
1616 if (my $count = (8 - ($pos % 8))) {
1617 my $spaces = ' ' x
$count;
1618 $line =~ s/\t/$spaces/;
1625 sub project_in_list
{
1626 my $project = shift;
1627 my @list = git_get_projects_list
();
1628 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1631 ## ----------------------------------------------------------------------
1632 ## HTML aware string manipulation
1634 # Try to chop given string on a word boundary between position
1635 # $len and $len+$add_len. If there is no word boundary there,
1636 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1637 # (marking chopped part) would be longer than given string.
1641 my $add_len = shift || 10;
1642 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1644 # Make sure perl knows it is utf8 encoded so we don't
1645 # cut in the middle of a utf8 multibyte char.
1646 $str = to_utf8
($str);
1648 # allow only $len chars, but don't cut a word if it would fit in $add_len
1649 # if it doesn't fit, cut it if it's still longer than the dots we would add
1650 # remove chopped character entities entirely
1652 # when chopping in the middle, distribute $len into left and right part
1653 # return early if chopping wouldn't make string shorter
1654 if ($where eq 'center') {
1655 return $str if ($len + 5 >= length($str)); # filler is length 5
1658 return $str if ($len + 4 >= length($str)); # filler is length 4
1661 # regexps: ending and beginning with word part up to $add_len
1662 my $endre = qr/.{$len}\w{0,$add_len}/;
1663 my $begre = qr/\w{0,$add_len}.{$len}/;
1665 if ($where eq 'left') {
1666 $str =~ m/^(.*?)($begre)$/;
1667 my ($lead, $body) = ($1, $2);
1668 if (length($lead) > 4) {
1671 return "$lead$body";
1673 } elsif ($where eq 'center') {
1674 $str =~ m/^($endre)(.*)$/;
1675 my ($left, $str) = ($1, $2);
1676 $str =~ m/^(.*?)($begre)$/;
1677 my ($mid, $right) = ($1, $2);
1678 if (length($mid) > 5) {
1681 return "$left$mid$right";
1684 $str =~ m/^($endre)(.*)$/;
1687 if (length($tail) > 4) {
1690 return "$body$tail";
1694 # takes the same arguments as chop_str, but also wraps a <span> around the
1695 # result with a title attribute if it does get chopped. Additionally, the
1696 # string is HTML-escaped.
1697 sub chop_and_escape_str
{
1700 my $chopped = chop_str
(@_);
1701 $str = to_utf8
($str);
1702 if ($chopped eq $str) {
1703 return esc_html
($chopped);
1705 $str =~ s/[[:cntrl:]]/?/g;
1706 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1710 ## ----------------------------------------------------------------------
1711 ## functions returning short strings
1713 # CSS class for given age value (in seconds)
1717 if (!defined $age) {
1719 } elsif ($age < 60*60*2) {
1721 } elsif ($age < 60*60*24*2) {
1728 # convert age in seconds to "nn units ago" string
1733 if ($age > 60*60*24*365*2) {
1734 $age_str = (int $age/60/60/24/365);
1735 $age_str .= " years ago";
1736 } elsif ($age > 60*60*24*(365/12)*2) {
1737 $age_str = int $age/60/60/24/(365/12);
1738 $age_str .= " months ago";
1739 } elsif ($age > 60*60*24*7*2) {
1740 $age_str = int $age/60/60/24/7;
1741 $age_str .= " weeks ago";
1742 } elsif ($age > 60*60*24*2) {
1743 $age_str = int $age/60/60/24;
1744 $age_str .= " days ago";
1745 } elsif ($age > 60*60*2) {
1746 $age_str = int $age/60/60;
1747 $age_str .= " hours ago";
1748 } elsif ($age > 60*2) {
1749 $age_str = int $age/60;
1750 $age_str .= " min ago";
1751 } elsif ($age > 2) {
1752 $age_str = int $age;
1753 $age_str .= " sec ago";
1755 $age_str .= " right now";
1761 S_IFINVALID
=> 0030000,
1762 S_IFGITLINK
=> 0160000,
1765 # submodule/subproject, a commit object reference
1769 return (($mode & S_IFMT
) == S_IFGITLINK
)
1772 # convert file mode in octal to symbolic file mode string
1774 my $mode = oct shift;
1776 if (S_ISGITLINK
($mode)) {
1777 return 'm---------';
1778 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1779 return 'drwxr-xr-x';
1780 } elsif (S_ISLNK
($mode)) {
1781 return 'lrwxrwxrwx';
1782 } elsif (S_ISREG
($mode)) {
1783 # git cares only about the executable bit
1784 if ($mode & S_IXUSR
) {
1785 return '-rwxr-xr-x';
1787 return '-rw-r--r--';
1790 return '----------';
1794 # convert file mode in octal to file type string
1798 if ($mode !~ m/^[0-7]+$/) {
1804 if (S_ISGITLINK
($mode)) {
1806 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1808 } elsif (S_ISLNK
($mode)) {
1810 } elsif (S_ISREG
($mode)) {
1817 # convert file mode in octal to file type description string
1818 sub file_type_long
{
1821 if ($mode !~ m/^[0-7]+$/) {
1827 if (S_ISGITLINK
($mode)) {
1829 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1831 } elsif (S_ISLNK
($mode)) {
1833 } elsif (S_ISREG
($mode)) {
1834 if ($mode & S_IXUSR
) {
1835 return "executable";
1845 ## ----------------------------------------------------------------------
1846 ## functions returning short HTML fragments, or transforming HTML fragments
1847 ## which don't belong to other sections
1849 # format line of commit message.
1850 sub format_log_line_html
{
1853 $line = esc_html
($line, -nbsp
=>1);
1854 $line =~ s
{\b([0-9a
-fA
-F
]{8,40})\b}{
1855 $cgi->a({-href
=> href
(action
=>"object", hash
=>$1),
1856 -class => "text"}, $1);
1862 # format marker of refs pointing to given object
1864 # the destination action is chosen based on object type and current context:
1865 # - for annotated tags, we choose the tag view unless it's the current view
1866 # already, in which case we go to shortlog view
1867 # - for other refs, we keep the current view if we're in history, shortlog or
1868 # log view, and select shortlog otherwise
1869 sub format_ref_marker
{
1870 my ($refs, $id) = @_;
1873 if (defined $refs->{$id}) {
1874 foreach my $ref (@
{$refs->{$id}}) {
1875 # this code exploits the fact that non-lightweight tags are the
1876 # only indirect objects, and that they are the only objects for which
1877 # we want to use tag instead of shortlog as action
1878 my ($type, $name) = qw();
1879 my $indirect = ($ref =~ s/\^\{\}$//);
1880 # e.g. tags/v2.6.11 or heads/next
1881 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1890 $class .= " indirect" if $indirect;
1892 my $dest_action = "shortlog";
1895 $dest_action = "tag" unless $action eq "tag";
1896 } elsif ($action =~ /^(history|(short)?log)$/) {
1897 $dest_action = $action;
1901 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1904 my $link = $cgi->a({
1906 action
=>$dest_action,
1910 $markers .= " <span class=\"".esc_attr
($class)."\" title=\"".esc_attr
($ref)."\">" .
1916 return ' <span class="refs">'. $markers . '</span>';
1922 # format, perhaps shortened and with markers, title line
1923 sub format_subject_html
{
1924 my ($long, $short, $href, $extra) = @_;
1925 $extra = '' unless defined($extra);
1927 if (length($short) < length($long)) {
1928 $long =~ s/[[:cntrl:]]/?/g;
1929 return $cgi->a({-href
=> $href, -class => "list subject",
1930 -title
=> to_utf8
($long)},
1931 esc_html
($short)) . $extra;
1933 return $cgi->a({-href
=> $href, -class => "list subject"},
1934 esc_html
($long)) . $extra;
1938 # Rather than recomputing the url for an email multiple times, we cache it
1939 # after the first hit. This gives a visible benefit in views where the avatar
1940 # for the same email is used repeatedly (e.g. shortlog).
1941 # The cache is shared by all avatar engines (currently gravatar only), which
1942 # are free to use it as preferred. Since only one avatar engine is used for any
1943 # given page, there's no risk for cache conflicts.
1944 our %avatar_cache = ();
1946 # Compute the picon url for a given email, by using the picon search service over at
1947 # http://www.cs.indiana.edu/picons/search.html
1949 my $email = lc shift;
1950 if (!$avatar_cache{$email}) {
1951 my ($user, $domain) = split('@', $email);
1952 $avatar_cache{$email} =
1953 "http://www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
1955 "users+domains+unknown/up/single";
1957 return $avatar_cache{$email};
1960 # Compute the gravatar url for a given email, if it's not in the cache already.
1961 # Gravatar stores only the part of the URL before the size, since that's the
1962 # one computationally more expensive. This also allows reuse of the cache for
1963 # different sizes (for this particular engine).
1965 my $email = lc shift;
1967 $avatar_cache{$email} ||=
1968 "http://www.gravatar.com/avatar/" .
1969 Digest
::MD5
::md5_hex
($email) . "?s=";
1970 return $avatar_cache{$email} . $size;
1973 # Insert an avatar for the given $email at the given $size if the feature
1975 sub git_get_avatar
{
1976 my ($email, %opts) = @_;
1977 my $pre_white = ($opts{-pad_before
} ?
" " : "");
1978 my $post_white = ($opts{-pad_after
} ?
" " : "");
1979 $opts{-size
} ||= 'default';
1980 my $size = $avatar_size{$opts{-size
}} || $avatar_size{'default'};
1982 if ($git_avatar eq 'gravatar') {
1983 $url = gravatar_url
($email, $size);
1984 } elsif ($git_avatar eq 'picon') {
1985 $url = picon_url
($email);
1987 # Other providers can be added by extending the if chain, defining $url
1988 # as needed. If no variant puts something in $url, we assume avatars
1989 # are completely disabled/unavailable.
1992 "<img width=\"$size\" " .
1993 "class=\"avatar\" " .
1994 "src=\"".esc_url
($url)."\" " .
2002 sub format_search_author
{
2003 my ($author, $searchtype, $displaytext) = @_;
2004 my $have_search = gitweb_check_feature
('search');
2008 if ($searchtype eq 'author') {
2009 $performed = "authored";
2010 } elsif ($searchtype eq 'committer') {
2011 $performed = "committed";
2014 return $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
2015 searchtext
=>$author,
2016 searchtype
=>$searchtype), class=>"list",
2017 title
=>"Search for commits $performed by $author"},
2021 return $displaytext;
2025 # format the author name of the given commit with the given tag
2026 # the author name is chopped and escaped according to the other
2027 # optional parameters (see chop_str).
2028 sub format_author_html
{
2031 my $author = chop_and_escape_str
($co->{'author_name'}, @_);
2032 return "<$tag class=\"author\">" .
2033 format_search_author
($co->{'author_name'}, "author",
2034 git_get_avatar
($co->{'author_email'}, -pad_after
=> 1) .
2039 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
2040 sub format_git_diff_header_line
{
2042 my $diffinfo = shift;
2043 my ($from, $to) = @_;
2045 if ($diffinfo->{'nparents'}) {
2047 $line =~ s!^(diff (.*?) )"?.*$!$1!;
2048 if ($to->{'href'}) {
2049 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2050 esc_path
($to->{'file'}));
2051 } else { # file was deleted (no href)
2052 $line .= esc_path
($to->{'file'});
2056 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
2057 if ($from->{'href'}) {
2058 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
2059 'a/' . esc_path
($from->{'file'}));
2060 } else { # file was added (no href)
2061 $line .= 'a/' . esc_path
($from->{'file'});
2064 if ($to->{'href'}) {
2065 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2066 'b/' . esc_path
($to->{'file'}));
2067 } else { # file was deleted
2068 $line .= 'b/' . esc_path
($to->{'file'});
2072 return "<div class=\"diff header\">$line</div>\n";
2075 # format extended diff header line, before patch itself
2076 sub format_extended_diff_header_line
{
2078 my $diffinfo = shift;
2079 my ($from, $to) = @_;
2082 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
2083 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2084 esc_path
($from->{'file'}));
2086 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
2087 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2088 esc_path
($to->{'file'}));
2090 # match single <mode>
2091 if ($line =~ m/\s(\d{6})$/) {
2092 $line .= '<span class="info"> (' .
2093 file_type_long
($1) .
2097 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
2098 # can match only for combined diff
2100 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2101 if ($from->{'href'}[$i]) {
2102 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
2104 substr($diffinfo->{'from_id'}[$i],0,7));
2109 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
2112 if ($to->{'href'}) {
2113 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2114 substr($diffinfo->{'to_id'},0,7));
2119 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
2120 # can match only for ordinary diff
2121 my ($from_link, $to_link);
2122 if ($from->{'href'}) {
2123 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
2124 substr($diffinfo->{'from_id'},0,7));
2126 $from_link = '0' x
7;
2128 if ($to->{'href'}) {
2129 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2130 substr($diffinfo->{'to_id'},0,7));
2134 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2135 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2138 return $line . "<br/>\n";
2141 # format from-file/to-file diff header
2142 sub format_diff_from_to_header
{
2143 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
2148 #assert($line =~ m/^---/) if DEBUG;
2149 # no extra formatting for "^--- /dev/null"
2150 if (! $diffinfo->{'nparents'}) {
2151 # ordinary (single parent) diff
2152 if ($line =~ m!^--- "?a/!) {
2153 if ($from->{'href'}) {
2155 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2156 esc_path
($from->{'file'}));
2159 esc_path
($from->{'file'});
2162 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2165 # combined diff (merge commit)
2166 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2167 if ($from->{'href'}[$i]) {
2169 $cgi->a({-href
=>href
(action
=>"blobdiff",
2170 hash_parent
=>$diffinfo->{'from_id'}[$i],
2171 hash_parent_base
=>$parents[$i],
2172 file_parent
=>$from->{'file'}[$i],
2173 hash
=>$diffinfo->{'to_id'},
2175 file_name
=>$to->{'file'}),
2177 -title
=>"diff" . ($i+1)},
2180 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
2181 esc_path
($from->{'file'}[$i]));
2183 $line = '--- /dev/null';
2185 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2190 #assert($line =~ m/^\+\+\+/) if DEBUG;
2191 # no extra formatting for "^+++ /dev/null"
2192 if ($line =~ m!^\+\+\+ "?b/!) {
2193 if ($to->{'href'}) {
2195 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2196 esc_path
($to->{'file'}));
2199 esc_path
($to->{'file'});
2202 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
2207 # create note for patch simplified by combined diff
2208 sub format_diff_cc_simplified
{
2209 my ($diffinfo, @parents) = @_;
2212 $result .= "<div class=\"diff header\">" .
2214 if (!is_deleted
($diffinfo)) {
2215 $result .= $cgi->a({-href
=> href
(action
=>"blob",
2217 hash
=>$diffinfo->{'to_id'},
2218 file_name
=>$diffinfo->{'to_file'}),
2220 esc_path
($diffinfo->{'to_file'}));
2222 $result .= esc_path
($diffinfo->{'to_file'});
2224 $result .= "</div>\n" . # class="diff header"
2225 "<div class=\"diff nodifferences\">" .
2227 "</div>\n"; # class="diff nodifferences"
2232 sub diff_line_class
{
2233 my ($line, $from, $to) = @_;
2238 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2239 $num_sign = scalar @
{$from->{'href'}};
2242 my @diff_line_classifier = (
2243 { regexp
=> qr/^\@\@{$num_sign} /, class => "chunk_header"},
2244 { regexp
=> qr/^\\/, class => "incomplete" },
2245 { regexp
=> qr/^ {$num_sign}/, class => "ctx" },
2246 # classifier for context must come before classifier add/rem,
2247 # or we would have to use more complicated regexp, for example
2248 # qr/(?= {0,$m}\+)[+ ]{$num_sign}/, where $m = $num_sign - 1;
2249 { regexp
=> qr/^[+ ]{$num_sign}/, class => "add" },
2250 { regexp
=> qr/^[- ]{$num_sign}/, class => "rem" },
2252 for my $clsfy (@diff_line_classifier) {
2253 return $clsfy->{'class'}
2254 if ($line =~ $clsfy->{'regexp'});
2261 # assumes that $from and $to are defined and correctly filled,
2262 # and that $line holds a line of chunk header for unified diff
2263 sub format_unidiff_chunk_header
{
2264 my ($line, $from, $to) = @_;
2266 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2267 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2269 $from_lines = 0 unless defined $from_lines;
2270 $to_lines = 0 unless defined $to_lines;
2272 if ($from->{'href'}) {
2273 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
2274 -class=>"list"}, $from_text);
2276 if ($to->{'href'}) {
2277 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2278 -class=>"list"}, $to_text);
2280 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2281 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2285 # assumes that $from and $to are defined and correctly filled,
2286 # and that $line holds a line of chunk header for combined diff
2287 sub format_cc_diff_chunk_header
{
2288 my ($line, $from, $to) = @_;
2290 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2291 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2293 @from_text = split(' ', $ranges);
2294 for (my $i = 0; $i < @from_text; ++$i) {
2295 ($from_start[$i], $from_nlines[$i]) =
2296 (split(',', substr($from_text[$i], 1)), 0);
2299 $to_text = pop @from_text;
2300 $to_start = pop @from_start;
2301 $to_nlines = pop @from_nlines;
2303 $line = "<span class=\"chunk_info\">$prefix ";
2304 for (my $i = 0; $i < @from_text; ++$i) {
2305 if ($from->{'href'}[$i]) {
2306 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
2307 -class=>"list"}, $from_text[$i]);
2309 $line .= $from_text[$i];
2313 if ($to->{'href'}) {
2314 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2315 -class=>"list"}, $to_text);
2319 $line .= " $prefix</span>" .
2320 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2324 # process patch (diff) line (not to be used for diff headers),
2325 # returning class and HTML-formatted (but not wrapped) line
2326 sub process_diff_line
{
2328 my ($from, $to) = @_;
2330 my $diff_class = diff_line_class
($line, $from, $to);
2333 $line = untabify
($line);
2335 if ($from && $to && $line =~ m/^\@{2} /) {
2336 $line = format_unidiff_chunk_header
($line, $from, $to);
2337 return $diff_class, $line;
2339 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2340 $line = format_cc_diff_chunk_header
($line, $from, $to);
2341 return $diff_class, $line;
2344 return $diff_class, esc_html
($line, -nbsp
=>1);
2347 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2348 # linked. Pass the hash of the tree/commit to snapshot.
2349 sub format_snapshot_links
{
2351 my $num_fmts = @snapshot_fmts;
2352 if ($num_fmts > 1) {
2353 # A parenthesized list of links bearing format names.
2354 # e.g. "snapshot (_tar.gz_ _zip_)"
2355 return "snapshot (" . join(' ', map
2362 }, $known_snapshot_formats{$_}{'display'})
2363 , @snapshot_fmts) . ")";
2364 } elsif ($num_fmts == 1) {
2365 # A single "snapshot" link whose tooltip bears the format name.
2367 my ($fmt) = @snapshot_fmts;
2373 snapshot_format
=>$fmt
2375 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
2377 } else { # $num_fmts == 0
2382 ## ......................................................................
2383 ## functions returning values to be passed, perhaps after some
2384 ## transformation, to other functions; e.g. returning arguments to href()
2386 # returns hash to be passed to href to generate gitweb URL
2387 # in -title key it returns description of link
2389 my $format = shift || 'Atom';
2390 my %res = (action
=> lc($format));
2392 # feed links are possible only for project views
2393 return unless (defined $project);
2394 # some views should link to OPML, or to generic project feed,
2395 # or don't have specific feed yet (so they should use generic)
2396 return if (!$action || $action =~ /^(?:tags|heads|forks|tag|search)$/x);
2399 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
2400 # from tag links; this also makes possible to detect branch links
2401 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
2402 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
2405 # find log type for feed description (title)
2407 if (defined $file_name) {
2408 $type = "history of $file_name";
2409 $type .= "/" if ($action eq 'tree');
2410 $type .= " on '$branch'" if (defined $branch);
2412 $type = "log of $branch" if (defined $branch);
2415 $res{-title
} = $type;
2416 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
2417 $res{'file_name'} = $file_name;
2422 ## ----------------------------------------------------------------------
2423 ## git utility subroutines, invoking git commands
2425 # returns path to the core git executable and the --git-dir parameter as list
2427 $number_of_git_cmds++;
2428 return $GIT, '--git-dir='.$git_dir;
2431 # quote the given arguments for passing them to the shell
2432 # quote_command("command", "arg 1", "arg with ' and ! characters")
2433 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2434 # Try to avoid using this function wherever possible.
2437 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
2440 # get HEAD ref of given project as hash
2441 sub git_get_head_hash
{
2442 return git_get_full_hash
(shift, 'HEAD');
2445 sub git_get_full_hash
{
2446 return git_get_hash
(@_);
2449 sub git_get_short_hash
{
2450 return git_get_hash
(@_, '--short=7');
2454 my ($project, $hash, @options) = @_;
2455 my $o_git_dir = $git_dir;
2457 $git_dir = "$projectroot/$project";
2458 if (open my $fd, '-|', git_cmd
(), 'rev-parse',
2459 '--verify', '-q', @options, $hash) {
2461 chomp $retval if defined $retval;
2464 if (defined $o_git_dir) {
2465 $git_dir = $o_git_dir;
2470 # get type of given object
2474 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
2476 close $fd or return;
2481 # repository configuration
2482 our $config_file = '';
2485 # store multiple values for single key as anonymous array reference
2486 # single values stored directly in the hash, not as [ <value> ]
2487 sub hash_set_multi
{
2488 my ($hash, $key, $value) = @_;
2490 if (!exists $hash->{$key}) {
2491 $hash->{$key} = $value;
2492 } elsif (!ref $hash->{$key}) {
2493 $hash->{$key} = [ $hash->{$key}, $value ];
2495 push @
{$hash->{$key}}, $value;
2499 # return hash of git project configuration
2500 # optionally limited to some section, e.g. 'gitweb'
2501 sub git_parse_project_config
{
2502 my $section_regexp = shift;
2507 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
2510 while (my $keyval = <$fh>) {
2512 my ($key, $value) = split(/\n/, $keyval, 2);
2514 hash_set_multi
(\
%config, $key, $value)
2515 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2522 # convert config value to boolean: 'true' or 'false'
2523 # no value, number > 0, 'true' and 'yes' values are true
2524 # rest of values are treated as false (never as error)
2525 sub config_to_bool
{
2528 return 1 if !defined $val; # section.key
2530 # strip leading and trailing whitespace
2534 return (($val =~ /^\d+$/ && $val) || # section.key = 1
2535 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2538 # convert config value to simple decimal number
2539 # an optional value suffix of 'k', 'm', or 'g' will cause the value
2540 # to be multiplied by 1024, 1048576, or 1073741824
2544 # strip leading and trailing whitespace
2548 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2550 # unknown unit is treated as 1
2551 return $num * ($unit eq 'g' ?
1073741824 :
2552 $unit eq 'm' ?
1048576 :
2553 $unit eq 'k' ?
1024 : 1);
2558 # convert config value to array reference, if needed
2559 sub config_to_multi
{
2562 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
2565 sub git_get_project_config
{
2566 my ($key, $type) = @_;
2568 return unless defined $git_dir;
2571 return unless ($key);
2572 # only subsection, if exists, is case sensitive,
2573 # and not lowercased by 'git config -z -l'
2574 if (my ($hi, $mi, $lo) = ($key =~ /^([^.]*)\.(.*)\.([^.]*)$/)) {
2575 $key = join(".", lc($hi), $mi, lc($lo));
2579 $key =~ s/^gitweb\.//;
2580 return if ($key =~ m/\W/);
2583 if (defined $type) {
2586 unless ($type eq 'bool' || $type eq 'int');
2590 if (!defined $config_file ||
2591 $config_file ne "$git_dir/config") {
2592 %config = git_parse_project_config
('gitweb');
2593 $config_file = "$git_dir/config";
2596 # check if config variable (key) exists
2597 return unless exists $config{"gitweb.$key"};
2600 if (!defined $type) {
2601 return $config{"gitweb.$key"};
2602 } elsif ($type eq 'bool') {
2603 # backward compatibility: 'git config --bool' returns true/false
2604 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
2605 } elsif ($type eq 'int') {
2606 return config_to_int
($config{"gitweb.$key"});
2608 return $config{"gitweb.$key"};
2611 # get hash of given path at given ref
2612 sub git_get_hash_by_path
{
2614 my $path = shift || return undef;
2619 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
2620 or die_error
(500, "Open git-ls-tree failed");
2622 close $fd or return undef;
2624 if (!defined $line) {
2625 # there is no tree or hash given by $path at $base
2629 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2630 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2631 if (defined $type && $type ne $2) {
2632 # type doesn't match
2638 # get path of entry with given hash at given tree-ish (ref)
2639 # used to get 'from' filename for combined diff (merge commit) for renames
2640 sub git_get_path_by_hash
{
2641 my $base = shift || return;
2642 my $hash = shift || return;
2646 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
2648 while (my $line = <$fd>) {
2651 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2652 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2653 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2662 ## ......................................................................
2663 ## git utility functions, directly accessing git repository
2665 # get the value of config variable either from file named as the variable
2666 # itself in the repository ($GIT_DIR/$name file), or from gitweb.$name
2667 # configuration variable in the repository config file.
2668 sub git_get_file_or_project_config
{
2669 my ($path, $name) = @_;
2671 $git_dir = "$projectroot/$path";
2672 open my $fd, '<', "$git_dir/$name"
2673 or return git_get_project_config
($name);
2676 if (defined $conf) {
2682 sub git_get_project_description
{
2684 return git_get_file_or_project_config
($path, 'description');
2687 sub git_get_project_category
{
2689 return git_get_file_or_project_config
($path, 'category');
2693 # supported formats:
2694 # * $GIT_DIR/ctags/<tagname> file (in 'ctags' subdirectory)
2695 # - if its contents is a number, use it as tag weight,
2696 # - otherwise add a tag with weight 1
2697 # * $GIT_DIR/ctags file, each line is a tag (with weight 1)
2698 # the same value multiple times increases tag weight
2699 # * `gitweb.ctag' multi-valued repo config variable
2700 sub git_get_project_ctags
{
2701 my $project = shift;
2704 $git_dir = "$projectroot/$project";
2705 if (opendir my $dh, "$git_dir/ctags") {
2706 my @files = grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir($dh);
2707 foreach my $tagfile (@files) {
2708 open my $ct, '<', $tagfile
2714 (my $ctag = $tagfile) =~ s
#.*/##;
2715 if ($val =~ /^\d+$/) {
2716 $ctags->{$ctag} = $val;
2718 $ctags->{$ctag} = 1;
2723 } elsif (open my $fh, '<', "$git_dir/ctags") {
2724 while (my $line = <$fh>) {
2726 $ctags->{$line}++ if $line;
2731 my $taglist = config_to_multi
(git_get_project_config
('ctag'));
2732 foreach my $tag (@
$taglist) {
2740 # return hash, where keys are content tags ('ctags'),
2741 # and values are sum of weights of given tag in every project
2742 sub git_gather_all_ctags
{
2743 my $projects = shift;
2746 foreach my $p (@
$projects) {
2747 foreach my $ct (keys %{$p->{'ctags'}}) {
2748 $ctags->{$ct} += $p->{'ctags'}->{$ct};
2755 sub git_populate_project_tagcloud
{
2758 # First, merge different-cased tags; tags vote on casing
2760 foreach (keys %$ctags) {
2761 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2762 if (not $ctags_lc{lc $_}->{topcount
}
2763 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2764 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2765 $ctags_lc{lc $_}->{topname
} = $_;
2770 my $matched = $cgi->param('by_tag');
2771 if (eval { require HTML
::TagCloud
; 1; }) {
2772 $cloud = HTML
::TagCloud
->new;
2773 foreach my $ctag (sort keys %ctags_lc) {
2774 # Pad the title with spaces so that the cloud looks
2776 my $title = esc_html
($ctags_lc{$ctag}->{topname
});
2777 $title =~ s/ / /g;
2778 $title =~ s/^/ /g;
2779 $title =~ s/$/ /g;
2780 if (defined $matched && $matched eq $ctag) {
2781 $title = qq(<span
class="match">$title</span
>);
2783 $cloud->add($title, href
(project
=>undef, ctag
=>$ctag),
2784 $ctags_lc{$ctag}->{count
});
2788 foreach my $ctag (keys %ctags_lc) {
2789 my $title = esc_html
($ctags_lc{$ctag}->{topname
}, -nbsp
=>1);
2790 if (defined $matched && $matched eq $ctag) {
2791 $title = qq(<span
class="match">$title</span
>);
2793 $cloud->{$ctag}{count
} = $ctags_lc{$ctag}->{count
};
2794 $cloud->{$ctag}{ctag
} =
2795 $cgi->a({-href
=>href
(project
=>undef, ctag
=>$ctag)}, $title);
2801 sub git_show_project_tagcloud
{
2802 my ($cloud, $count) = @_;
2803 if (ref $cloud eq 'HTML::TagCloud') {
2804 return $cloud->html_and_css($count);
2806 my @tags = sort { $cloud->{$a}->{'count'} <=> $cloud->{$b}->{'count'} } keys %$cloud;
2808 '<div id="htmltagcloud"'.($project ?
'' : ' align="center"').'>' .
2810 $cloud->{$_}->{'ctag'}
2811 } splice(@tags, 0, $count)) .
2816 sub git_get_project_url_list
{
2819 $git_dir = "$projectroot/$path";
2820 open my $fd, '<', "$git_dir/cloneurl"
2821 or return wantarray ?
2822 @
{ config_to_multi
(git_get_project_config
('url')) } :
2823 config_to_multi
(git_get_project_config
('url'));
2824 my @git_project_url_list = map { chomp; $_ } <$fd>;
2827 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2830 sub git_get_projects_list
{
2831 my $filter = shift || '';
2834 $filter =~ s/\.git$//;
2836 if (-d
$projects_list) {
2837 # search in directory
2838 my $dir = $projects_list;
2839 # remove the trailing "/"
2841 my $pfxlen = length("$dir");
2842 my $pfxdepth = ($dir =~ tr!/!!);
2843 # when filtering, search only given subdirectory
2850 follow_fast
=> 1, # follow symbolic links
2851 follow_skip
=> 2, # ignore duplicates
2852 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2855 our $project_maxdepth;
2857 # skip project-list toplevel, if we get it.
2858 return if (m!^[/.]$!);
2859 # only directories can be git repositories
2860 return unless (-d
$_);
2861 # don't traverse too deep (Find is super slow on os x)
2862 # $project_maxdepth excludes depth of $projectroot
2863 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2864 $File::Find
::prune
= 1;
2868 my $path = substr($File::Find
::name
, $pfxlen + 1);
2869 # we check related file in $projectroot
2870 if (check_export_ok
("$projectroot/$path")) {
2871 push @list, { path
=> $path };
2872 $File::Find
::prune
= 1;
2877 } elsif (-f
$projects_list) {
2878 # read from file(url-encoded):
2879 # 'git%2Fgit.git Linus+Torvalds'
2880 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2881 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2882 open my $fd, '<', $projects_list or return;
2884 while (my $line = <$fd>) {
2886 my ($path, $owner) = split ' ', $line;
2887 $path = unescape
($path);
2888 $owner = unescape
($owner);
2889 if (!defined $path) {
2892 # if $filter is rpovided, check if $path begins with $filter
2893 if ($filter && $path !~ m!^\Q$filter\E/!) {
2896 if (check_export_ok
("$projectroot/$path")) {
2899 owner
=> to_utf8
($owner),
2909 # written with help of Tree::Trie module (Perl Artistic License, GPL compatibile)
2910 # as side effects it sets 'forks' field to list of forks for forked projects
2911 sub filter_forks_from_projects_list
{
2912 my $projects = shift;
2914 my %trie; # prefix tree of directories (path components)
2915 # generate trie out of those directories that might contain forks
2916 foreach my $pr (@
$projects) {
2917 my $path = $pr->{'path'};
2918 $path =~ s/\.git$//; # forks of 'repo.git' are in 'repo/' directory
2919 next if ($path =~ m!/$!); # skip non-bare repositories, e.g. 'repo/.git'
2920 next unless ($path); # skip '.git' repository: tests, git-instaweb
2921 next unless (-d
"$projectroot/$path"); # containing directory exists
2922 $pr->{'forks'} = []; # there can be 0 or more forks of project
2925 my @dirs = split('/', $path);
2926 # walk the trie, until either runs out of components or out of trie
2928 while (scalar @dirs &&
2929 exists($ref->{$dirs[0]})) {
2930 $ref = $ref->{shift @dirs};
2932 # create rest of trie structure from rest of components
2933 foreach my $dir (@dirs) {
2934 $ref = $ref->{$dir} = {};
2936 # create end marker, store $pr as a data
2937 $ref->{''} = $pr if (!exists $ref->{''});
2940 # filter out forks, by finding shortest prefix match for paths
2943 foreach my $pr (@
$projects) {
2947 foreach my $dir (split('/', $pr->{'path'})) {
2948 if (exists $ref->{''}) {
2949 # found [shortest] prefix, is a fork - skip it
2950 push @
{$ref->{''}{'forks'}}, $pr;
2953 if (!exists $ref->{$dir}) {
2954 # not in trie, cannot have prefix, not a fork
2955 push @filtered, $pr;
2958 # If the dir is there, we just walk one step down the trie.
2959 $ref = $ref->{$dir};
2961 # we ran out of trie
2962 # (shouldn't happen: it's either no match, or end marker)
2963 push @filtered, $pr;
2969 # note: fill_project_list_info must be run first,
2970 # for 'descr_long' and 'ctags' to be filled
2971 sub search_projects_list
{
2972 my ($projlist, %opts) = @_;
2973 my $tagfilter = $opts{'tagfilter'};
2974 my $searchtext = $opts{'searchtext'};
2977 unless ($tagfilter || $searchtext);
2981 foreach my $pr (@
$projlist) {
2984 next unless ref($pr->{'ctags'}) eq 'HASH';
2986 grep { lc($_) eq lc($tagfilter) } keys %{$pr->{'ctags'}};
2991 $pr->{'path'} =~ /$searchtext/ ||
2992 $pr->{'descr_long'} =~ /$searchtext/;
2995 push @projects, $pr;
3001 our $gitweb_project_owner = undef;
3002 sub git_get_project_list_from_file
{
3004 return if (defined $gitweb_project_owner);
3006 $gitweb_project_owner = {};
3007 # read from file (url-encoded):
3008 # 'git%2Fgit.git Linus+Torvalds'
3009 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
3010 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
3011 if (-f
$projects_list) {
3012 open(my $fd, '<', $projects_list);
3013 while (my $line = <$fd>) {
3015 my ($pr, $ow) = split ' ', $line;
3016 $pr = unescape
($pr);
3017 $ow = unescape
($ow);
3018 $gitweb_project_owner->{$pr} = to_utf8
($ow);
3024 sub git_get_project_owner
{
3025 my $project = shift;
3028 return undef unless $project;
3029 $git_dir = "$projectroot/$project";
3031 if (!defined $gitweb_project_owner) {
3032 git_get_project_list_from_file
();
3035 if (exists $gitweb_project_owner->{$project}) {
3036 $owner = $gitweb_project_owner->{$project};
3038 if (!defined $owner){
3039 $owner = git_get_project_config
('owner');
3041 if (!defined $owner) {
3042 $owner = get_file_owner
("$git_dir");
3048 sub git_get_last_activity
{
3052 $git_dir = "$projectroot/$path";
3053 open($fd, "-|", git_cmd
(), 'for-each-ref',
3054 '--format=%(committer)',
3055 '--sort=-committerdate',
3057 'refs/heads') or return;
3058 my $most_recent = <$fd>;
3059 close $fd or return;
3060 if (defined $most_recent &&
3061 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
3063 my $age = time - $timestamp;
3064 return ($age, age_string
($age));
3066 return (undef, undef);
3069 # Implementation note: when a single remote is wanted, we cannot use 'git
3070 # remote show -n' because that command always work (assuming it's a remote URL
3071 # if it's not defined), and we cannot use 'git remote show' because that would
3072 # try to make a network roundtrip. So the only way to find if that particular
3073 # remote is defined is to walk the list provided by 'git remote -v' and stop if
3074 # and when we find what we want.
3075 sub git_get_remotes_list
{
3079 open my $fd, '-|' , git_cmd
(), 'remote', '-v';
3081 while (my $remote = <$fd>) {
3083 $remote =~ s!\t(.*?)\s+\((\w+)\)$!!;
3084 next if $wanted and not $remote eq $wanted;
3085 my ($url, $key) = ($1, $2);
3087 $remotes{$remote} ||= { 'heads' => () };
3088 $remotes{$remote}{$key} = $url;
3090 close $fd or return;
3091 return wantarray ?
%remotes : \
%remotes;
3094 # Takes a hash of remotes as first parameter and fills it by adding the
3095 # available remote heads for each of the indicated remotes.
3096 sub fill_remote_heads
{
3097 my $remotes = shift;
3098 my @heads = map { "remotes/$_" } keys %$remotes;
3099 my @remoteheads = git_get_heads_list
(undef, @heads);
3100 foreach my $remote (keys %$remotes) {
3101 $remotes->{$remote}{'heads'} = [ grep {
3102 $_->{'name'} =~ s!^$remote/!!
3107 sub git_get_references
{
3108 my $type = shift || "";
3110 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
3111 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
3112 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
3113 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
3116 while (my $line = <$fd>) {
3118 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
3119 if (defined $refs{$1}) {
3120 push @
{$refs{$1}}, $2;
3126 close $fd or return;
3130 sub git_get_rev_name_tags
{
3131 my $hash = shift || return undef;
3133 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
3135 my $name_rev = <$fd>;
3138 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
3141 # catches also '$hash undefined' output
3146 ## ----------------------------------------------------------------------
3147 ## parse to hash functions
3151 my $tz = shift || "-0000";
3154 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
3155 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
3156 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
3157 $date{'hour'} = $hour;
3158 $date{'minute'} = $min;
3159 $date{'mday'} = $mday;
3160 $date{'day'} = $days[$wday];
3161 $date{'month'} = $months[$mon];
3162 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
3163 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
3164 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
3165 $mday, $months[$mon], $hour ,$min;
3166 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
3167 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
3169 my ($tz_sign, $tz_hour, $tz_min) =
3170 ($tz =~ m/^([-+])(\d\d)(\d\d)$/);
3171 $tz_sign = ($tz_sign eq '-' ?
-1 : +1);
3172 my $local = $epoch + $tz_sign*((($tz_hour*60) + $tz_min)*60);
3173 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
3174 $date{'hour_local'} = $hour;
3175 $date{'minute_local'} = $min;
3176 $date{'tz_local'} = $tz;
3177 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
3178 1900+$year, $mon+1, $mday,
3179 $hour, $min, $sec, $tz);
3188 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
3189 $tag{'id'} = $tag_id;
3190 while (my $line = <$fd>) {
3192 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
3193 $tag{'object'} = $1;
3194 } elsif ($line =~ m/^type (.+)$/) {
3196 } elsif ($line =~ m/^tag (.+)$/) {
3198 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
3199 $tag{'author'} = $1;
3200 $tag{'author_epoch'} = $2;
3201 $tag{'author_tz'} = $3;
3202 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3203 $tag{'author_name'} = $1;
3204 $tag{'author_email'} = $2;
3206 $tag{'author_name'} = $tag{'author'};
3208 } elsif ($line =~ m/--BEGIN/) {
3209 push @comment, $line;
3211 } elsif ($line eq "") {
3215 push @comment, <$fd>;
3216 $tag{'comment'} = \
@comment;
3217 close $fd or return;
3218 if (!defined $tag{'name'}) {
3224 sub parse_commit_text
{
3225 my ($commit_text, $withparents) = @_;
3226 my @commit_lines = split '\n', $commit_text;
3229 pop @commit_lines; # Remove '\0'
3231 if (! @commit_lines) {
3235 my $header = shift @commit_lines;
3236 if ($header !~ m/^[0-9a-fA-F]{40}/) {
3239 ($co{'id'}, my @parents) = split ' ', $header;
3240 while (my $line = shift @commit_lines) {
3241 last if $line eq "\n";
3242 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
3244 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
3246 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
3247 $co{'author'} = to_utf8
($1);
3248 $co{'author_epoch'} = $2;
3249 $co{'author_tz'} = $3;
3250 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3251 $co{'author_name'} = $1;
3252 $co{'author_email'} = $2;
3254 $co{'author_name'} = $co{'author'};
3256 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
3257 $co{'committer'} = to_utf8
($1);
3258 $co{'committer_epoch'} = $2;
3259 $co{'committer_tz'} = $3;
3260 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
3261 $co{'committer_name'} = $1;
3262 $co{'committer_email'} = $2;
3264 $co{'committer_name'} = $co{'committer'};
3268 if (!defined $co{'tree'}) {
3271 $co{'parents'} = \
@parents;
3272 $co{'parent'} = $parents[0];
3274 foreach my $title (@commit_lines) {
3277 $co{'title'} = chop_str
($title, 80, 5);
3278 # remove leading stuff of merges to make the interesting part visible
3279 if (length($title) > 50) {
3280 $title =~ s/^Automatic //;
3281 $title =~ s/^merge (of|with) /Merge ... /i;
3282 if (length($title) > 50) {
3283 $title =~ s/(http|rsync):\/\///;
3285 if (length($title) > 50) {
3286 $title =~ s/(master|www|rsync)\.//;
3288 if (length($title) > 50) {
3289 $title =~ s/kernel.org:?//;
3291 if (length($title) > 50) {
3292 $title =~ s/\/pub\/scm//;
3295 $co{'title_short'} = chop_str
($title, 50, 5);
3299 if (! defined $co{'title'} || $co{'title'} eq "") {
3300 $co{'title'} = $co{'title_short'} = '(no commit message)';
3302 # remove added spaces
3303 foreach my $line (@commit_lines) {
3306 $co{'comment'} = \
@commit_lines;
3308 my $age = time - $co{'committer_epoch'};
3310 $co{'age_string'} = age_string
($age);
3311 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
3312 if ($age > 60*60*24*7*2) {
3313 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3314 $co{'age_string_age'} = $co{'age_string'};
3316 $co{'age_string_date'} = $co{'age_string'};
3317 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3323 my ($commit_id) = @_;
3328 open my $fd, "-|", git_cmd
(), "rev-list",
3334 or die_error
(500, "Open git-rev-list failed");
3335 %co = parse_commit_text
(<$fd>, 1);
3342 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
3350 open my $fd, "-|", git_cmd
(), "rev-list",
3353 ("--max-count=" . $maxcount),
3354 ("--skip=" . $skip),
3358 ($filename ?
($filename) : ())
3359 or die_error
(500, "Open git-rev-list failed");
3360 while (my $line = <$fd>) {
3361 my %co = parse_commit_text
($line);
3366 return wantarray ?
@cos : \
@cos;
3369 # parse line of git-diff-tree "raw" output
3370 sub parse_difftree_raw_line
{
3374 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3375 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
3376 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
3377 $res{'from_mode'} = $1;
3378 $res{'to_mode'} = $2;
3379 $res{'from_id'} = $3;
3381 $res{'status'} = $5;
3382 $res{'similarity'} = $6;
3383 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
3384 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
3386 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
3389 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3390 # combined diff (for merge commit)
3391 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
3392 $res{'nparents'} = length($1);
3393 $res{'from_mode'} = [ split(' ', $2) ];
3394 $res{'to_mode'} = pop @
{$res{'from_mode'}};
3395 $res{'from_id'} = [ split(' ', $3) ];
3396 $res{'to_id'} = pop @
{$res{'from_id'}};
3397 $res{'status'} = [ split('', $4) ];
3398 $res{'to_file'} = unquote
($5);
3400 # 'c512b523472485aef4fff9e57b229d9d243c967f'
3401 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
3402 $res{'commit'} = $1;
3405 return wantarray ?
%res : \
%res;
3408 # wrapper: return parsed line of git-diff-tree "raw" output
3409 # (the argument might be raw line, or parsed info)
3410 sub parsed_difftree_line
{
3411 my $line_or_ref = shift;
3413 if (ref($line_or_ref) eq "HASH") {
3414 # pre-parsed (or generated by hand)
3415 return $line_or_ref;
3417 return parse_difftree_raw_line
($line_or_ref);
3421 # parse line of git-ls-tree output
3422 sub parse_ls_tree_line
{
3428 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
3429 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40}) +(-|[0-9]+)\t(.+)$/s;
3438 $res{'name'} = unquote
($5);
3441 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
3442 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
3450 $res{'name'} = unquote
($4);
3454 return wantarray ?
%res : \
%res;
3457 # generates _two_ hashes, references to which are passed as 2 and 3 argument
3458 sub parse_from_to_diffinfo
{
3459 my ($diffinfo, $from, $to, @parents) = @_;
3461 if ($diffinfo->{'nparents'}) {
3463 $from->{'file'} = [];
3464 $from->{'href'} = [];
3465 fill_from_file_info
($diffinfo, @parents)
3466 unless exists $diffinfo->{'from_file'};
3467 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
3468 $from->{'file'}[$i] =
3469 defined $diffinfo->{'from_file'}[$i] ?
3470 $diffinfo->{'from_file'}[$i] :
3471 $diffinfo->{'to_file'};
3472 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3473 $from->{'href'}[$i] = href
(action
=>"blob",
3474 hash_base
=>$parents[$i],
3475 hash
=>$diffinfo->{'from_id'}[$i],
3476 file_name
=>$from->{'file'}[$i]);
3478 $from->{'href'}[$i] = undef;
3482 # ordinary (not combined) diff
3483 $from->{'file'} = $diffinfo->{'from_file'};
3484 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3485 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
3486 hash
=>$diffinfo->{'from_id'},
3487 file_name
=>$from->{'file'});
3489 delete $from->{'href'};
3493 $to->{'file'} = $diffinfo->{'to_file'};
3494 if (!is_deleted
($diffinfo)) { # file exists in result
3495 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
3496 hash
=>$diffinfo->{'to_id'},
3497 file_name
=>$to->{'file'});
3499 delete $to->{'href'};
3503 ## ......................................................................
3504 ## parse to array of hashes functions
3506 sub git_get_heads_list
{
3507 my ($limit, @classes) = @_;
3508 @classes = ('heads') unless @classes;
3509 my @patterns = map { "refs/$_" } @classes;
3512 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3513 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
3514 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
3517 while (my $line = <$fd>) {
3521 my ($refinfo, $committerinfo) = split(/\0/, $line);
3522 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3523 my ($committer, $epoch, $tz) =
3524 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
3525 $ref_item{'fullname'} = $name;
3526 $name =~ s!^refs/(?:head|remote)s/!!;
3528 $ref_item{'name'} = $name;
3529 $ref_item{'id'} = $hash;
3530 $ref_item{'title'} = $title || '(no commit message)';
3531 $ref_item{'epoch'} = $epoch;
3533 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3535 $ref_item{'age'} = "unknown";
3538 push @headslist, \
%ref_item;
3542 return wantarray ?
@headslist : \
@headslist;
3545 sub git_get_tags_list
{
3549 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3550 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
3551 '--format=%(objectname) %(objecttype) %(refname) '.
3552 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3555 while (my $line = <$fd>) {
3559 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3560 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3561 my ($creator, $epoch, $tz) =
3562 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
3563 $ref_item{'fullname'} = $name;
3564 $name =~ s!^refs/tags/!!;
3566 $ref_item{'type'} = $type;
3567 $ref_item{'id'} = $id;
3568 $ref_item{'name'} = $name;
3569 if ($type eq "tag") {
3570 $ref_item{'subject'} = $title;
3571 $ref_item{'reftype'} = $reftype;
3572 $ref_item{'refid'} = $refid;
3574 $ref_item{'reftype'} = $type;
3575 $ref_item{'refid'} = $id;
3578 if ($type eq "tag" || $type eq "commit") {
3579 $ref_item{'epoch'} = $epoch;
3581 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3583 $ref_item{'age'} = "unknown";
3587 push @tagslist, \
%ref_item;
3591 return wantarray ?
@tagslist : \
@tagslist;
3594 ## ----------------------------------------------------------------------
3595 ## filesystem-related functions
3597 sub get_file_owner
{
3600 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3601 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3602 if (!defined $gcos) {
3606 $owner =~ s/[,;].*$//;
3607 return to_utf8
($owner);
3610 # assume that file exists
3612 my $filename = shift;
3614 open my $fd, '<', $filename;
3615 print map { to_utf8
($_) } <$fd>;
3619 ## ......................................................................
3620 ## mimetype related functions
3622 sub mimetype_guess_file
{
3623 my $filename = shift;
3624 my $mimemap = shift;
3625 -r
$mimemap or return undef;
3628 open(my $mh, '<', $mimemap) or return undef;
3630 next if m/^#/; # skip comments
3631 my ($mimetype, @exts) = split(/\s+/);
3632 foreach my $ext (@exts) {
3633 $mimemap{$ext} = $mimetype;
3638 $filename =~ /\.([^.]*)$/;
3639 return $mimemap{$1};
3642 sub mimetype_guess
{
3643 my $filename = shift;
3645 $filename =~ /\./ or return undef;
3647 if ($mimetypes_file) {
3648 my $file = $mimetypes_file;
3649 if ($file !~ m!^/!) { # if it is relative path
3650 # it is relative to project
3651 $file = "$projectroot/$project/$file";
3653 $mime = mimetype_guess_file
($filename, $file);
3655 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
3661 my $filename = shift;
3664 my $mime = mimetype_guess
($filename);
3665 $mime and return $mime;
3669 return $default_blob_plain_mimetype unless $fd;
3672 return 'text/plain';
3673 } elsif (! $filename) {
3674 return 'application/octet-stream';
3675 } elsif ($filename =~ m/\.png$/i) {
3677 } elsif ($filename =~ m/\.gif$/i) {
3679 } elsif ($filename =~ m/\.jpe?g$/i) {
3680 return 'image/jpeg';
3682 return 'application/octet-stream';
3686 sub blob_contenttype
{
3687 my ($fd, $file_name, $type) = @_;
3689 $type ||= blob_mimetype
($fd, $file_name);
3690 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3691 $type .= "; charset=$default_text_plain_charset";
3697 # guess file syntax for syntax highlighting; return undef if no highlighting
3698 # the name of syntax can (in the future) depend on syntax highlighter used
3699 sub guess_file_syntax
{
3700 my ($highlight, $mimetype, $file_name) = @_;
3701 return undef unless ($highlight && defined $file_name);
3702 my $basename = basename
($file_name, '.in');
3703 return $highlight_basename{$basename}
3704 if exists $highlight_basename{$basename};
3706 $basename =~ /\.([^.]*)$/;
3707 my $ext = $1 or return undef;
3708 return $highlight_ext{$ext}
3709 if exists $highlight_ext{$ext};
3714 # run highlighter and return FD of its output,
3715 # or return original FD if no highlighting
3716 sub run_highlighter
{
3717 my ($fd, $highlight, $syntax) = @_;
3718 return $fd unless ($highlight && defined $syntax);
3721 open $fd, quote_command
(git_cmd
(), "cat-file", "blob", $hash)." | ".
3722 quote_command
($highlight_bin).
3723 " --replace-tabs=8 --fragment --syntax $syntax |"
3724 or die_error
(500, "Couldn't open file or run syntax highlighter");
3728 ## ======================================================================
3729 ## functions printing HTML: header, footer, error page
3731 sub get_page_title
{
3732 my $title = to_utf8
($site_name);
3734 return $title unless (defined $project);
3735 $title .= " - " . to_utf8
($project);
3737 return $title unless (defined $action);
3738 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
3740 return $title unless (defined $file_name);
3741 $title .= " - " . esc_path
($file_name);
3742 if ($action eq "tree" && $file_name !~ m
|/$|) {
3749 sub get_content_type_html
{
3750 # require explicit support from the UA if we are to send the page as
3751 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
3752 # we have to do this because MSIE sometimes globs '*/*', pretending to
3753 # support xhtml+xml but choking when it gets what it asked for.
3754 if (defined $cgi->http('HTTP_ACCEPT') &&
3755 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
3756 $cgi->Accept('application/xhtml+xml') != 0) {
3757 return 'application/xhtml+xml';
3763 sub print_feed_meta
{
3764 if (defined $project) {
3765 my %href_params = get_feed_info
();
3766 if (!exists $href_params{'-title'}) {
3767 $href_params{'-title'} = 'log';
3770 foreach my $format (qw(RSS Atom)) {
3771 my $type = lc($format);
3773 '-rel' => 'alternate',
3774 '-title' => esc_attr
("$project - $href_params{'-title'} - $format feed"),
3775 '-type' => "application/$type+xml"
3778 $href_params{'action'} = $type;
3779 $link_attr{'-href'} = href
(%href_params);
3781 "rel=\"$link_attr{'-rel'}\" ".
3782 "title=\"$link_attr{'-title'}\" ".
3783 "href=\"$link_attr{'-href'}\" ".
3784 "type=\"$link_attr{'-type'}\" ".
3787 $href_params{'extra_options'} = '--no-merges';
3788 $link_attr{'-href'} = href
(%href_params);
3789 $link_attr{'-title'} .= ' (no merges)';
3791 "rel=\"$link_attr{'-rel'}\" ".
3792 "title=\"$link_attr{'-title'}\" ".
3793 "href=\"$link_attr{'-href'}\" ".
3794 "type=\"$link_attr{'-type'}\" ".
3799 printf('<link rel="alternate" title="%s projects list" '.
3800 'href="%s" type="text/plain; charset=utf-8" />'."\n",
3801 esc_attr
($site_name), href
(project
=>undef, action
=>"project_index"));
3802 printf('<link rel="alternate" title="%s projects feeds" '.
3803 'href="%s" type="text/x-opml" />'."\n",
3804 esc_attr
($site_name), href
(project
=>undef, action
=>"opml"));
3808 sub print_header_links
{
3811 # print out each stylesheet that exist, providing backwards capability
3812 # for those people who defined $stylesheet in a config file
3813 if (defined $stylesheet) {
3814 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3816 foreach my $stylesheet (@stylesheets) {
3817 next unless $stylesheet;
3818 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3822 if ($status eq '200 OK');
3823 if (defined $favicon) {
3824 print qq(<link rel
="shortcut icon" href
=").esc_url($favicon).qq(" type
="image/png" />\n);
3828 sub print_nav_breadcrumbs
{
3831 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
3832 if (defined $project) {
3833 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
3834 if (defined $action) {
3835 my $action_print = $action ;
3836 if (defined $opts{-action_extra
}) {
3837 $action_print = $cgi->a({-href
=> href
(action
=>$action)},
3840 print " / $action_print";
3842 if (defined $opts{-action_extra
}) {
3843 print " / $opts{-action_extra}";
3849 sub print_search_form
{
3850 if (!defined $searchtext) {
3854 if (defined $hash_base) {
3855 $search_hash = $hash_base;
3856 } elsif (defined $hash) {
3857 $search_hash = $hash;
3859 $search_hash = "HEAD";
3861 my $action = $my_uri;
3862 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3863 if ($use_pathinfo) {
3864 $action .= "/".esc_url
($project);
3866 print $cgi->startform(-method
=> "get", -action
=> $action) .
3867 "<div class=\"search\">\n" .
3869 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3870 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3871 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3872 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3873 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3874 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3876 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
3877 "<span title=\"Extended regular expression\">" .
3878 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3879 -checked
=> $search_use_regexp) .
3882 $cgi->end_form() . "\n";
3885 sub git_header_html
{
3886 my $status = shift || "200 OK";
3887 my $expires = shift;
3890 my $title = get_page_title
();
3891 my $content_type = get_content_type_html
();
3892 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
3893 -status
=> $status, -expires
=> $expires)
3894 unless ($opts{'-no_http_header'});
3895 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
3897 <?xml version="1.0" encoding="utf-8"?>
3898 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3899 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
3900 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
3901 <!-- git core binaries version $git_version -->
3903 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
3904 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
3905 <meta name="robots" content="index, nofollow"/>
3906 <title>$title</title>
3908 # the stylesheet, favicon etc urls won't work correctly with path_info
3909 # unless we set the appropriate base URL
3910 if ($ENV{'PATH_INFO'}) {
3911 print "<base href=\"".esc_url
($base_url)."\" />\n";
3913 print_header_links
($status);
3915 if (defined $site_html_head_string) {
3916 print to_utf8
($site_html_head_string);
3922 if (defined $site_header && -f
$site_header) {
3923 insert_file
($site_header);
3926 print "<div class=\"page_header\">\n";
3927 if (defined $logo) {
3928 print $cgi->a({-href
=> esc_url
($logo_url),
3929 -title
=> $logo_label},
3930 $cgi->img({-src
=> esc_url
($logo),
3931 -width
=> 72, -height
=> 27,
3933 -class => "logo"}));
3935 print_nav_breadcrumbs
(%opts);
3938 my $have_search = gitweb_check_feature
('search');
3939 if (defined $project && $have_search) {
3940 print_search_form
();
3944 sub git_footer_html
{
3945 my $feed_class = 'rss_logo';
3947 print "<div class=\"page_footer\">\n";
3948 if (defined $project) {
3949 my $descr = git_get_project_description
($project);
3950 if (defined $descr) {
3951 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3954 my %href_params = get_feed_info
();
3955 if (!%href_params) {
3956 $feed_class .= ' generic';
3958 $href_params{'-title'} ||= 'log';
3960 foreach my $format (qw(RSS Atom)) {
3961 $href_params{'action'} = lc($format);
3962 print $cgi->a({-href
=> href
(%href_params),
3963 -title
=> "$href_params{'-title'} $format feed",
3964 -class => $feed_class}, $format)."\n";
3968 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3969 -class => $feed_class}, "OPML") . " ";
3970 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3971 -class => $feed_class}, "TXT") . "\n";
3973 print "</div>\n"; # class="page_footer"
3975 if (defined $t0 && gitweb_check_feature
('timed')) {
3976 print "<div id=\"generating_info\">\n";
3977 print 'This page took '.
3978 '<span id="generating_time" class="time_span">'.
3979 tv_interval
($t0, [ gettimeofday
() ]).
3982 '<span id="generating_cmd">'.
3983 $number_of_git_cmds.
3984 '</span> git commands '.
3986 print "</div>\n"; # class="page_footer"
3989 if (defined $site_footer && -f
$site_footer) {
3990 insert_file
($site_footer);
3993 print qq!<script type
="text/javascript" src
="!.esc_url($javascript).qq!"></script
>\n!;
3994 if (defined $action &&
3995 $action eq 'blame_incremental') {
3996 print qq!<script type
="text/javascript">\n!.
3997 qq!startBlame
("!. href(action=>"blame_data
", -replay=>1) .qq!",\n!.
3998 qq! "!. href() .qq!");\n!.
4001 my ($jstimezone, $tz_cookie, $datetime_class) =
4002 gitweb_get_feature
('javascript-timezone');
4004 print qq!<script type
="text/javascript">\n!.
4005 qq!window
.onload
= function
() {\n!;
4006 if (gitweb_check_feature
('javascript-actions')) {
4007 print qq! fixLinks
();\n!;
4009 if ($jstimezone && $tz_cookie && $datetime_class) {
4010 print qq! var tz_cookie
= { name
: '$tz_cookie', expires
: 14, path
: '/' };\n!. # in days
4011 qq! onloadTZSetup
('$jstimezone', tz_cookie
, '$datetime_class');\n!;
4021 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
4022 # Example: die_error(404, 'Hash not found')
4023 # By convention, use the following status codes (as defined in RFC 2616):
4024 # 400: Invalid or missing CGI parameters, or
4025 # requested object exists but has wrong type.
4026 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
4027 # this server or project.
4028 # 404: Requested object/revision/project doesn't exist.
4029 # 500: The server isn't configured properly, or
4030 # an internal error occurred (e.g. failed assertions caused by bugs), or
4031 # an unknown error occurred (e.g. the git binary died unexpectedly).
4032 # 503: The server is currently unavailable (because it is overloaded,
4033 # or down for maintenance). Generally, this is a temporary state.
4035 my $status = shift || 500;
4036 my $error = esc_html
(shift) || "Internal Server Error";
4040 my %http_responses = (
4041 400 => '400 Bad Request',
4042 403 => '403 Forbidden',
4043 404 => '404 Not Found',
4044 500 => '500 Internal Server Error',
4045 503 => '503 Service Unavailable',
4047 git_header_html
($http_responses{$status}, undef, %opts);
4049 <div class="page_body">
4054 if (defined $extra) {
4062 unless ($opts{'-error_handler'});
4065 ## ----------------------------------------------------------------------
4066 ## functions printing or outputting HTML: navigation
4068 sub git_print_page_nav
{
4069 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
4070 $extra = '' if !defined $extra; # pager or formats
4072 my @navs = qw(summary shortlog log commit commitdiff tree);
4074 @navs = grep { $_ ne $suppress } @navs;
4077 my %arg = map { $_ => {action
=>$_} } @navs;
4078 if (defined $head) {
4079 for (qw(commit commitdiff)) {
4080 $arg{$_}{'hash'} = $head;
4082 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
4083 for (qw(shortlog log)) {
4084 $arg{$_}{'hash'} = $head;
4089 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
4090 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
4092 my @actions = gitweb_get_feature
('actions');
4095 'n' => $project, # project name
4096 'f' => $git_dir, # project path within filesystem
4097 'h' => $treehead || '', # current hash ('h' parameter)
4098 'b' => $treebase || '', # hash base ('hb' parameter)
4101 my ($label, $link, $pos) = splice(@actions,0,3);
4103 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
4105 $link =~ s/%([%nfhb])/$repl{$1}/g;
4106 $arg{$label}{'_href'} = $link;
4109 print "<div class=\"page_nav\">\n" .
4111 map { $_ eq $current ?
4112 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
4114 print "<br/>\n$extra<br/>\n" .
4118 # returns a submenu for the nagivation of the refs views (tags, heads,
4119 # remotes) with the current view disabled and the remotes view only
4120 # available if the feature is enabled
4121 sub format_ref_views
{
4123 my @ref_views = qw{tags heads
};
4124 push @ref_views, 'remotes' if gitweb_check_feature
('remote_heads');
4125 return join " | ", map {
4126 $_ eq $current ?
$_ :
4127 $cgi->a({-href
=> href
(action
=>$_)}, $_)
4131 sub format_paging_nav
{
4132 my ($action, $page, $has_next_link) = @_;
4138 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)}, "first") .
4140 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
4141 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
4143 $paging_nav .= "first ⋅ prev";
4146 if ($has_next_link) {
4147 $paging_nav .= " ⋅ " .
4148 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
4149 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
4151 $paging_nav .= " ⋅ next";
4157 ## ......................................................................
4158 ## functions printing or outputting HTML: div
4160 sub git_print_header_div
{
4161 my ($action, $title, $hash, $hash_base) = @_;
4164 $args{'action'} = $action;
4165 $args{'hash'} = $hash if $hash;
4166 $args{'hash_base'} = $hash_base if $hash_base;
4168 print "<div class=\"header\">\n" .
4169 $cgi->a({-href
=> href
(%args), -class => "title"},
4170 $title ?
$title : $action) .
4174 sub format_repo_url
{
4175 my ($name, $url) = @_;
4176 return "<tr class=\"metadata_url\"><td>$name</td><td>$url</td></tr>\n";
4179 # Group output by placing it in a DIV element and adding a header.
4180 # Options for start_div() can be provided by passing a hash reference as the
4181 # first parameter to the function.
4182 # Options to git_print_header_div() can be provided by passing an array
4183 # reference. This must follow the options to start_div if they are present.
4184 # The content can be a scalar, which is output as-is, a scalar reference, which
4185 # is output after html escaping, an IO handle passed either as *handle or
4186 # *handle{IO}, or a function reference. In the latter case all following
4187 # parameters will be taken as argument to the content function call.
4188 sub git_print_section
{
4189 my ($div_args, $header_args, $content);
4191 if (ref($arg) eq 'HASH') {
4195 if (ref($arg) eq 'ARRAY') {
4196 $header_args = $arg;
4201 print $cgi->start_div($div_args);
4202 git_print_header_div
(@
$header_args);
4204 if (ref($content) eq 'CODE') {
4206 } elsif (ref($content) eq 'SCALAR') {
4207 print esc_html
($$content);
4208 } elsif (ref($content) eq 'GLOB' or ref($content) eq 'IO::Handle') {
4210 } elsif (!ref($content) && defined($content)) {
4214 print $cgi->end_div;
4217 sub format_timestamp_html
{
4219 my $strtime = $date->{'rfc2822'};
4221 my (undef, undef, $datetime_class) =
4222 gitweb_get_feature
('javascript-timezone');
4223 if ($datetime_class) {
4224 $strtime = qq!<span
class="$datetime_class">$strtime</span
>!;
4227 my $localtime_format = '(%02d:%02d %s)';
4228 if ($date->{'hour_local'} < 6) {
4229 $localtime_format = '(<span class="atnight">%02d:%02d</span> %s)';
4232 sprintf($localtime_format,
4233 $date->{'hour_local'}, $date->{'minute_local'}, $date->{'tz_local'});
4238 # Outputs the author name and date in long form
4239 sub git_print_authorship
{
4242 my $tag = $opts{-tag
} || 'div';
4243 my $author = $co->{'author_name'};
4245 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
4246 print "<$tag class=\"author_date\">" .
4247 format_search_author
($author, "author", esc_html
($author)) .
4248 " [".format_timestamp_html
(\
%ad)."]".
4249 git_get_avatar
($co->{'author_email'}, -pad_before
=> 1) .
4253 # Outputs table rows containing the full author or committer information,
4254 # in the format expected for 'commit' view (& similar).
4255 # Parameters are a commit hash reference, followed by the list of people
4256 # to output information for. If the list is empty it defaults to both
4257 # author and committer.
4258 sub git_print_authorship_rows
{
4260 # too bad we can't use @people = @_ || ('author', 'committer')
4262 @people = ('author', 'committer') unless @people;
4263 foreach my $who (@people) {
4264 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
4265 print "<tr><td>$who</td><td>" .
4266 format_search_author
($co->{"${who}_name"}, $who,
4267 esc_html
($co->{"${who}_name"})) . " " .
4268 format_search_author
($co->{"${who}_email"}, $who,
4269 esc_html
("<" . $co->{"${who}_email"} . ">")) .
4270 "</td><td rowspan=\"2\">" .
4271 git_get_avatar
($co->{"${who}_email"}, -size
=> 'double') .
4275 format_timestamp_html
(\
%wd) .
4281 sub git_print_page_path
{
4287 print "<div class=\"page_path\">";
4288 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
4289 -title
=> 'tree root'}, to_utf8
("[$project]"));
4291 if (defined $name) {
4292 my @dirname = split '/', $name;
4293 my $basename = pop @dirname;
4296 foreach my $dir (@dirname) {
4297 $fullname .= ($fullname ?
'/' : '') . $dir;
4298 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
4300 -title
=> $fullname}, esc_path
($dir));
4303 if (defined $type && $type eq 'blob') {
4304 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
4306 -title
=> $name}, esc_path
($basename));
4307 if (gitweb_check_feature
('highlight')) {
4308 print '
4309 <a id="lineNoToggle" href="#" onclick="toggleLineNumbers();"></a>
4311 function toggleLineNumbers() {
4312 e = document.getElementById("lineNoStyle");
4313 e2 = document.getElementById("lineNoToggle");
4314 if (e2.innerHTML == "[Hide line numbers]") {
4315 e.innerHTML = ".linenr { display:none; }";
4316 e2.innerHTML = "[Show line numbers]";
4320 e2.innerHTML = "[Hide line numbers]";
4323 var style = document.createElement("style");
4324 style.setAttribute("id", "lineNoStyle");
4325 document.getElementsByTagName("head")[0].appendChild(style);
4326 toggleLineNumbers();
4330 } elsif (defined $type && $type eq 'tree') {
4331 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
4333 -title
=> $name}, esc_path
($basename));
4336 print esc_path
($basename);
4339 print "<br/></div>\n";
4346 if ($opts{'-remove_title'}) {
4347 # remove title, i.e. first line of log
4350 # remove leading empty lines
4351 while (defined $log->[0] && $log->[0] eq "") {
4358 foreach my $line (@
$log) {
4359 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
4362 if (! $opts{'-remove_signoff'}) {
4363 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
4366 # remove signoff lines
4373 # print only one empty line
4374 # do not print empty line after signoff
4376 next if ($empty || $signoff);
4382 print format_log_line_html
($line) . "<br/>\n";
4385 if ($opts{'-final_empty_line'}) {
4386 # end with single empty line
4387 print "<br/>\n" unless $empty;
4391 # return link target (what link points to)
4392 sub git_get_link_target
{
4397 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4401 $link_target = <$fd>;
4406 return $link_target;
4409 # given link target, and the directory (basedir) the link is in,
4410 # return target of link relative to top directory (top tree);
4411 # return undef if it is not possible (including absolute links).
4412 sub normalize_link_target
{
4413 my ($link_target, $basedir) = @_;
4415 # absolute symlinks (beginning with '/') cannot be normalized
4416 return if (substr($link_target, 0, 1) eq '/');
4418 # normalize link target to path from top (root) tree (dir)
4421 $path = $basedir . '/' . $link_target;
4423 # we are in top (root) tree (dir)
4424 $path = $link_target;
4427 # remove //, /./, and /../
4429 foreach my $part (split('/', $path)) {
4430 # discard '.' and ''
4431 next if (!$part || $part eq '.');
4433 if ($part eq '..') {
4437 # link leads outside repository (outside top dir)
4441 push @path_parts, $part;
4444 $path = join('/', @path_parts);
4449 # print tree entry (row of git_tree), but without encompassing <tr> element
4450 sub git_print_tree_entry
{
4451 my ($t, $basedir, $hash_base, $have_blame) = @_;
4454 $base_key{'hash_base'} = $hash_base if defined $hash_base;
4456 # The format of a table row is: mode list link. Where mode is
4457 # the mode of the entry, list is the name of the entry, an href,
4458 # and link is the action links of the entry.
4460 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
4461 if (exists $t->{'size'}) {
4462 print "<td class=\"size\">$t->{'size'}</td>\n";
4464 if ($t->{'type'} eq "blob") {
4465 print "<td class=\"list\">" .
4466 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4467 file_name
=>"$basedir$t->{'name'}", %base_key),
4468 -class => "list"}, esc_path
($t->{'name'}));
4469 if (S_ISLNK
(oct $t->{'mode'})) {
4470 my $link_target = git_get_link_target
($t->{'hash'});
4472 my $norm_target = normalize_link_target
($link_target, $basedir);
4473 if (defined $norm_target) {
4475 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
4476 file_name
=>$norm_target),
4477 -title
=> $norm_target}, esc_path
($link_target));
4479 print " -> " . esc_path
($link_target);
4484 print "<td class=\"link\">";
4485 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4486 file_name
=>"$basedir$t->{'name'}", %base_key)},
4490 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
4491 file_name
=>"$basedir$t->{'name'}", %base_key)},
4494 if (defined $hash_base) {
4496 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4497 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
4501 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
4502 file_name
=>"$basedir$t->{'name'}")},
4506 } elsif ($t->{'type'} eq "tree") {
4507 print "<td class=\"list\">";
4508 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4509 file_name
=>"$basedir$t->{'name'}",
4511 esc_path
($t->{'name'}));
4513 print "<td class=\"link\">";
4514 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4515 file_name
=>"$basedir$t->{'name'}",
4518 if (defined $hash_base) {
4520 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4521 file_name
=>"$basedir$t->{'name'}")},
4526 # unknown object: we can only present history for it
4527 # (this includes 'commit' object, i.e. submodule support)
4528 print "<td class=\"list\">" .
4529 esc_path
($t->{'name'}) .
4531 print "<td class=\"link\">";
4532 if (defined $hash_base) {
4533 print $cgi->a({-href
=> href
(action
=>"history",
4534 hash_base
=>$hash_base,
4535 file_name
=>"$basedir$t->{'name'}")},
4542 ## ......................................................................
4543 ## functions printing large fragments of HTML
4545 # get pre-image filenames for merge (combined) diff
4546 sub fill_from_file_info
{
4547 my ($diff, @parents) = @_;
4549 $diff->{'from_file'} = [ ];
4550 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4551 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4552 if ($diff->{'status'}[$i] eq 'R' ||
4553 $diff->{'status'}[$i] eq 'C') {
4554 $diff->{'from_file'}[$i] =
4555 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
4562 # is current raw difftree line of file deletion
4564 my $diffinfo = shift;
4566 return $diffinfo->{'to_id'} eq ('0' x
40);
4569 # does patch correspond to [previous] difftree raw line
4570 # $diffinfo - hashref of parsed raw diff format
4571 # $patchinfo - hashref of parsed patch diff format
4572 # (the same keys as in $diffinfo)
4573 sub is_patch_split
{
4574 my ($diffinfo, $patchinfo) = @_;
4576 return defined $diffinfo && defined $patchinfo
4577 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4581 sub git_difftree_body
{
4582 my ($difftree, $hash, @parents) = @_;
4583 my ($parent) = $parents[0];
4584 my $have_blame = gitweb_check_feature
('blame');
4585 print "<div class=\"list_head\">\n";
4586 if ($#{$difftree} > 10) {
4587 print(($#{$difftree} + 1) . " files changed:\n");
4591 print "<table class=\"" .
4592 (@parents > 1 ?
"combined " : "") .
4595 # header only for combined diff in 'commitdiff' view
4596 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
4599 print "<thead><tr>\n" .
4600 "<th></th><th></th>\n"; # filename, patchN link
4601 for (my $i = 0; $i < @parents; $i++) {
4602 my $par = $parents[$i];
4604 $cgi->a({-href
=> href
(action
=>"commitdiff",
4605 hash
=>$hash, hash_parent
=>$par),
4606 -title
=> 'commitdiff to parent number ' .
4607 ($i+1) . ': ' . substr($par,0,7)},
4611 print "</tr></thead>\n<tbody>\n";
4616 foreach my $line (@
{$difftree}) {
4617 my $diff = parsed_difftree_line
($line);
4620 print "<tr class=\"dark\">\n";
4622 print "<tr class=\"light\">\n";
4626 if (exists $diff->{'nparents'}) { # combined diff
4628 fill_from_file_info
($diff, @parents)
4629 unless exists $diff->{'from_file'};
4631 if (!is_deleted
($diff)) {
4632 # file exists in the result (child) commit
4634 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4635 file_name
=>$diff->{'to_file'},
4637 -class => "list"}, esc_path
($diff->{'to_file'})) .
4641 esc_path
($diff->{'to_file'}) .
4645 if ($action eq 'commitdiff') {
4648 print "<td class=\"link\">" .
4649 $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4655 my $has_history = 0;
4656 my $not_deleted = 0;
4657 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4658 my $hash_parent = $parents[$i];
4659 my $from_hash = $diff->{'from_id'}[$i];
4660 my $from_path = $diff->{'from_file'}[$i];
4661 my $status = $diff->{'status'}[$i];
4663 $has_history ||= ($status ne 'A');
4664 $not_deleted ||= ($status ne 'D');
4666 if ($status eq 'A') {
4667 print "<td class=\"link\" align=\"right\"> | </td>\n";
4668 } elsif ($status eq 'D') {
4669 print "<td class=\"link\">" .
4670 $cgi->a({-href
=> href
(action
=>"blob",
4673 file_name
=>$from_path)},
4677 if ($diff->{'to_id'} eq $from_hash) {
4678 print "<td class=\"link nochange\">";
4680 print "<td class=\"link\">";
4682 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4683 hash
=>$diff->{'to_id'},
4684 hash_parent
=>$from_hash,
4686 hash_parent_base
=>$hash_parent,
4687 file_name
=>$diff->{'to_file'},
4688 file_parent
=>$from_path)},
4694 print "<td class=\"link\">";
4696 print $cgi->a({-href
=> href
(action
=>"blob",
4697 hash
=>$diff->{'to_id'},
4698 file_name
=>$diff->{'to_file'},
4701 print " | " if ($has_history);
4704 print $cgi->a({-href
=> href
(action
=>"history",
4705 file_name
=>$diff->{'to_file'},
4712 next; # instead of 'else' clause, to avoid extra indent
4714 # else ordinary diff
4716 my ($to_mode_oct, $to_mode_str, $to_file_type);
4717 my ($from_mode_oct, $from_mode_str, $from_file_type);
4718 if ($diff->{'to_mode'} ne ('0' x
6)) {
4719 $to_mode_oct = oct $diff->{'to_mode'};
4720 if (S_ISREG
($to_mode_oct)) { # only for regular file
4721 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4723 $to_file_type = file_type
($diff->{'to_mode'});
4725 if ($diff->{'from_mode'} ne ('0' x
6)) {
4726 $from_mode_oct = oct $diff->{'from_mode'};
4727 if (S_ISREG
($from_mode_oct)) { # only for regular file
4728 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4730 $from_file_type = file_type
($diff->{'from_mode'});
4733 if ($diff->{'status'} eq "A") { # created
4734 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4735 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4736 $mode_chng .= "]</span>";
4738 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4739 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4740 -class => "list"}, esc_path
($diff->{'file'}));
4742 print "<td>$mode_chng</td>\n";
4743 print "<td class=\"link\">";
4744 if ($action eq 'commitdiff') {
4747 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4751 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4752 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4756 } elsif ($diff->{'status'} eq "D") { # deleted
4757 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4759 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4760 hash_base
=>$parent, file_name
=>$diff->{'file'}),
4761 -class => "list"}, esc_path
($diff->{'file'}));
4763 print "<td>$mode_chng</td>\n";
4764 print "<td class=\"link\">";
4765 if ($action eq 'commitdiff') {
4768 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4772 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4773 hash_base
=>$parent, file_name
=>$diff->{'file'})},
4776 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
4777 file_name
=>$diff->{'file'})},
4780 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
4781 file_name
=>$diff->{'file'})},
4785 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4786 my $mode_chnge = "";
4787 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4788 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4789 if ($from_file_type ne $to_file_type) {
4790 $mode_chnge .= " from $from_file_type to $to_file_type";
4792 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4793 if ($from_mode_str && $to_mode_str) {
4794 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4795 } elsif ($to_mode_str) {
4796 $mode_chnge .= " mode: $to_mode_str";
4799 $mode_chnge .= "]</span>\n";
4802 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4803 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4804 -class => "list"}, esc_path
($diff->{'file'}));
4806 print "<td>$mode_chnge</td>\n";
4807 print "<td class=\"link\">";
4808 if ($action eq 'commitdiff') {
4811 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4814 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4815 # "commit" view and modified file (not onlu mode changed)
4816 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4817 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4818 hash_base
=>$hash, hash_parent_base
=>$parent,
4819 file_name
=>$diff->{'file'})},
4823 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4824 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4827 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4828 file_name
=>$diff->{'file'})},
4831 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4832 file_name
=>$diff->{'file'})},
4836 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4837 my %status_name = ('R' => 'moved', 'C' => 'copied');
4838 my $nstatus = $status_name{$diff->{'status'}};
4840 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4841 # mode also for directories, so we cannot use $to_mode_str
4842 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4845 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
4846 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
4847 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
4848 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4849 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
4850 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
4851 -class => "list"}, esc_path
($diff->{'from_file'})) .
4852 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4853 "<td class=\"link\">";
4854 if ($action eq 'commitdiff') {
4857 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4860 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4861 # "commit" view and modified file (not only pure rename or copy)
4862 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4863 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4864 hash_base
=>$hash, hash_parent_base
=>$parent,
4865 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
4869 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4870 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
4873 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4874 file_name
=>$diff->{'to_file'})},
4877 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4878 file_name
=>$diff->{'to_file'})},
4882 } # we should not encounter Unmerged (U) or Unknown (X) status
4885 print "</tbody>" if $has_header;
4889 sub print_sidebyside_diff_chunk
{
4891 my (@ctx, @rem, @add);
4893 return unless @chunk;
4895 # incomplete last line might be among removed or added lines,
4896 # or both, or among context lines: find which
4897 for (my $i = 1; $i < @chunk; $i++) {
4898 if ($chunk[$i][0] eq 'incomplete') {
4899 $chunk[$i][0] = $chunk[$i-1][0];
4904 push @chunk, ["", ""];
4906 foreach my $line_info (@chunk) {
4907 my ($class, $line) = @
$line_info;
4909 # print chunk headers
4910 if ($class && $class eq 'chunk_header') {
4915 ## print from accumulator when type of class of lines change
4916 # empty contents block on start rem/add block, or end of chunk
4917 if (@ctx && (!$class || $class eq 'rem' || $class eq 'add')) {
4919 '<div class="chunk_block ctx">',
4920 '<div class="old">',
4923 '<div class="new">',
4929 # empty add/rem block on start context block, or end of chunk
4930 if ((@rem || @add) && (!$class || $class eq 'ctx')) {
4934 '<div class="chunk_block rem">',
4935 '<div class="old">',
4942 '<div class="chunk_block add">',
4943 '<div class="new">',
4948 # assume that it is change
4950 '<div class="chunk_block chg">',
4951 '<div class="old">',
4954 '<div class="new">',
4962 ## adding lines to accumulator
4965 # rem, add or change
4966 if ($class eq 'rem') {
4968 } elsif ($class eq 'add') {
4972 if ($class eq 'ctx') {
4978 sub git_patchset_body
{
4979 my ($fd, $diff_style, $difftree, $hash, @hash_parents) = @_;
4980 my ($hash_parent) = $hash_parents[0];
4982 my $is_combined = (@hash_parents > 1);
4984 my $patch_number = 0;
4989 my @chunk; # for side-by-side diff
4991 print "<div class=\"patchset\">\n";
4993 # skip to first patch
4994 while ($patch_line = <$fd>) {
4997 last if ($patch_line =~ m/^diff /);
5001 while ($patch_line) {
5003 # parse "git diff" header line
5004 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
5005 # $1 is from_name, which we do not use
5006 $to_name = unquote
($2);
5007 $to_name =~ s!^b/!!;
5008 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
5009 # $1 is 'cc' or 'combined', which we do not use
5010 $to_name = unquote
($2);
5015 # check if current patch belong to current raw line
5016 # and parse raw git-diff line if needed
5017 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
5018 # this is continuation of a split patch
5019 print "<div class=\"patch cont\">\n";
5021 # advance raw git-diff output if needed
5022 $patch_idx++ if defined $diffinfo;
5024 # read and prepare patch information
5025 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5027 # compact combined diff output can have some patches skipped
5028 # find which patch (using pathname of result) we are at now;
5030 while ($to_name ne $diffinfo->{'to_file'}) {
5031 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5032 format_diff_cc_simplified
($diffinfo, @hash_parents) .
5033 "</div>\n"; # class="patch"
5038 last if $patch_idx > $#$difftree;
5039 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5043 # modifies %from, %to hashes
5044 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
5046 # this is first patch for raw difftree line with $patch_idx index
5047 # we index @$difftree array from 0, but number patches from 1
5048 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
5052 #assert($patch_line =~ m/^diff /) if DEBUG;
5053 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
5055 # print "git diff" header
5056 print format_git_diff_header_line
($patch_line, $diffinfo,
5059 # print extended diff header
5060 print "<div class=\"diff extended_header\">\n";
5062 while ($patch_line = <$fd>) {
5065 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
5067 print format_extended_diff_header_line
($patch_line, $diffinfo,
5070 print "</div>\n"; # class="diff extended_header"
5072 # from-file/to-file diff header
5073 if (! $patch_line) {
5074 print "</div>\n"; # class="patch"
5077 next PATCH
if ($patch_line =~ m/^diff /);
5078 #assert($patch_line =~ m/^---/) if DEBUG;
5080 my $last_patch_line = $patch_line;
5081 $patch_line = <$fd>;
5083 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
5085 print format_diff_from_to_header
($last_patch_line, $patch_line,
5086 $diffinfo, \
%from, \
%to,
5091 while ($patch_line = <$fd>) {
5094 next PATCH
if ($patch_line =~ m/^diff /);
5096 my ($class, $line) = process_diff_line
($patch_line, \
%from, \
%to);
5097 my $diff_classes = "diff";
5098 $diff_classes .= " $class" if ($class);
5099 $line = "<div class=\"$diff_classes\">$line</div>\n";
5101 if ($diff_style eq 'sidebyside' && !$is_combined) {
5102 if ($class eq 'chunk_header') {
5103 print_sidebyside_diff_chunk
(@chunk);
5104 @chunk = ( [ $class, $line ] );
5106 push @chunk, [ $class, $line ];
5109 # default 'inline' style and unknown styles
5116 print_sidebyside_diff_chunk
(@chunk);
5119 print "</div>\n"; # class="patch"
5122 # for compact combined (--cc) format, with chunk and patch simplification
5123 # the patchset might be empty, but there might be unprocessed raw lines
5124 for (++$patch_idx if $patch_number > 0;
5125 $patch_idx < @
$difftree;
5127 # read and prepare patch information
5128 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5130 # generate anchor for "patch" links in difftree / whatchanged part
5131 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5132 format_diff_cc_simplified
($diffinfo, @hash_parents) .
5133 "</div>\n"; # class="patch"
5138 if ($patch_number == 0) {
5139 if (@hash_parents > 1) {
5140 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
5142 print "<div class=\"diff nodifferences\">No differences found</div>\n";
5146 print "</div>\n"; # class="patchset"
5149 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5151 # fills project list info (age, description, owner, category, forks)
5152 # for each project in the list, removing invalid projects from
5154 # NOTE: modifies $projlist, but does not remove entries from it
5155 sub fill_project_list_info
{
5156 my $projlist = shift;
5159 my $show_ctags = gitweb_check_feature
('ctags');
5161 foreach my $pr (@
$projlist) {
5162 my (@activity) = git_get_last_activity
($pr->{'path'});
5163 unless (@activity) {
5166 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
5167 if (!defined $pr->{'descr'}) {
5168 my $descr = git_get_project_description
($pr->{'path'}) || "";
5169 $descr = to_utf8
($descr);
5170 $pr->{'descr_long'} = $descr;
5171 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
5173 if (!defined $pr->{'owner'}) {
5174 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
5177 $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
5179 if ($projects_list_group_categories && !defined $pr->{'category'}) {
5180 my $cat = git_get_project_category
($pr->{'path'}) ||
5181 $project_list_default_category;
5182 $pr->{'category'} = to_utf8
($cat);
5185 push @projects, $pr;
5191 sub sort_projects_list
{
5192 my ($projlist, $order) = @_;
5196 project
=> { key
=> 'path', type
=> 'str' },
5197 descr
=> { key
=> 'descr_long', type
=> 'str' },
5198 owner
=> { key
=> 'owner', type
=> 'str' },
5199 age
=> { key
=> 'age', type
=> 'num' }
5201 my $oi = $order_info{$order};
5202 return @
$projlist unless defined $oi;
5203 if ($oi->{'type'} eq 'str') {
5204 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @
$projlist;
5206 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @
$projlist;
5212 # returns a hash of categories, containing the list of project
5213 # belonging to each category
5214 sub build_projlist_by_category
{
5215 my ($projlist, $from, $to) = @_;
5218 $from = 0 unless defined $from;
5219 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5221 for (my $i = $from; $i <= $to; $i++) {
5222 my $pr = $projlist->[$i];
5223 push @
{$categories{ $pr->{'category'} }}, $pr;
5226 return wantarray ?
%categories : \
%categories;
5229 # print 'sort by' <th> element, generating 'sort by $name' replay link
5230 # if that order is not selected
5232 print format_sort_th
(@_);
5235 sub format_sort_th
{
5236 my ($name, $order, $header) = @_;
5238 $header ||= ucfirst($name);
5240 if ($order eq $name) {
5241 $sort_th .= "<th>$header</th>\n";
5243 $sort_th .= "<th>" .
5244 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
5245 -class => "header"}, $header) .
5252 sub git_project_list_rows
{
5253 my ($projlist, $from, $to, $check_forks) = @_;
5255 $from = 0 unless defined $from;
5256 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5259 for (my $i = $from; $i <= $to; $i++) {
5260 my $pr = $projlist->[$i];
5263 print "<tr class=\"dark\">\n";
5265 print "<tr class=\"light\">\n";
5271 if ($pr->{'forks'}) {
5272 my $nforks = scalar @
{$pr->{'forks'}};
5274 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks"),
5275 -title
=> "$nforks forks"}, "+");
5277 print $cgi->span({-title
=> "$nforks forks"}, "+");
5282 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5283 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
5284 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5285 -class => "list", -title
=> $pr->{'descr_long'}},
5286 esc_html
($pr->{'descr'})) . "</td>\n" .
5287 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
5288 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
5289 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
5290 "<td class=\"link\">" .
5291 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
5292 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
5293 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
5294 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
5295 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
5301 sub git_project_list_body
{
5302 # actually uses global variable $project
5303 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
5304 my @projects = @
$projlist;
5306 my $check_forks = gitweb_check_feature
('forks');
5307 my $show_ctags = gitweb_check_feature
('ctags');
5308 my $tagfilter = $show_ctags ?
$cgi->param('by_tag') : undef;
5309 $check_forks = undef
5310 if ($tagfilter || $searchtext);
5312 # filtering out forks before filling info allows to do less work
5313 @projects = filter_forks_from_projects_list
(\
@projects)
5315 @projects = fill_project_list_info
(\
@projects);
5316 # searching projects require filling to be run before it
5317 @projects = search_projects_list
(\
@projects,
5318 'searchtext' => $searchtext,
5319 'tagfilter' => $tagfilter)
5320 if ($tagfilter || $searchtext);
5322 $order ||= $default_projects_order;
5323 $from = 0 unless defined $from;
5324 $to = $#projects if (!defined $to || $#projects < $to);
5329 "<b>No such projects found</b><br />\n".
5330 "Click ".$cgi->a({-href
=>href
(project
=>undef)},"here")." to view all projects<br />\n".
5331 "</center>\n<br />\n";
5335 @projects = sort_projects_list
(\
@projects, $order);
5338 my $ctags = git_gather_all_ctags
(\
@projects);
5339 my $cloud = git_populate_project_tagcloud
($ctags);
5340 print git_show_project_tagcloud
($cloud, 64);
5343 print "<table class=\"project_list\">\n";
5344 unless ($no_header) {
5347 print "<th></th>\n";
5349 print_sort_th
('project', $order, 'Project');
5350 print_sort_th
('descr', $order, 'Description');
5351 print_sort_th
('owner', $order, 'Owner');
5352 print_sort_th
('age', $order, 'Last Change');
5353 print "<th></th>\n" . # for links
5357 if ($projects_list_group_categories) {
5358 # only display categories with projects in the $from-$to window
5359 @projects = sort {$a->{'category'} cmp $b->{'category'}} @projects[$from..$to];
5360 my %categories = build_projlist_by_category
(\
@projects, $from, $to);
5361 foreach my $cat (sort keys %categories) {
5362 unless ($cat eq "") {
5365 print "<td></td>\n";
5367 print "<td class=\"category\" colspan=\"5\">".esc_html
($cat)."</td>\n";
5371 git_project_list_rows
($categories{$cat}, undef, undef, $check_forks);
5374 git_project_list_rows
(\
@projects, $from, $to, $check_forks);
5377 if (defined $extra) {
5380 print "<td></td>\n";
5382 print "<td colspan=\"5\">$extra</td>\n" .
5389 # uses global variable $project
5390 my ($commitlist, $from, $to, $refs, $extra) = @_;
5392 $from = 0 unless defined $from;
5393 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5395 for (my $i = 0; $i <= $to; $i++) {
5396 my %co = %{$commitlist->[$i]};
5398 my $commit = $co{'id'};
5399 my $ref = format_ref_marker
($refs, $commit);
5400 git_print_header_div
('commit',
5401 "<span class=\"age\">$co{'age_string'}</span>" .
5402 esc_html
($co{'title'}) . $ref,
5404 print "<div class=\"title_text\">\n" .
5405 "<div class=\"log_link\">\n" .
5406 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
5408 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
5410 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
5413 git_print_authorship
(\
%co, -tag
=> 'span');
5414 print "<br/>\n</div>\n";
5416 print "<div class=\"log_body\">\n";
5417 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
5421 print "<div class=\"page_nav\">\n";
5427 sub git_shortlog_body
{
5428 # uses global variable $project
5429 my ($commitlist, $from, $to, $refs, $extra) = @_;
5431 $from = 0 unless defined $from;
5432 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5434 print "<table class=\"shortlog\">\n";
5436 for (my $i = $from; $i <= $to; $i++) {
5437 my %co = %{$commitlist->[$i]};
5438 my $commit = $co{'id'};
5439 my $ref = format_ref_marker
($refs, $commit);
5441 print "<tr class=\"dark\">\n";
5443 print "<tr class=\"light\">\n";
5446 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
5447 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5448 format_author_html
('td', \
%co, 10) . "<td>";
5449 print format_subject_html
($co{'title'}, $co{'title_short'},
5450 href
(action
=>"commit", hash
=>$commit), $ref);
5452 "<td class=\"link\">" .
5453 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
5454 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
5455 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
5456 my $snapshot_links = format_snapshot_links
($commit);
5457 if (defined $snapshot_links) {
5458 print " | " . $snapshot_links;
5463 if (defined $extra) {
5465 "<td colspan=\"4\">$extra</td>\n" .
5471 sub git_history_body
{
5472 # Warning: assumes constant type (blob or tree) during history
5473 my ($commitlist, $from, $to, $refs, $extra,
5474 $file_name, $file_hash, $ftype) = @_;
5476 $from = 0 unless defined $from;
5477 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
5479 print "<table class=\"history\">\n";
5481 for (my $i = $from; $i <= $to; $i++) {
5482 my %co = %{$commitlist->[$i]};
5486 my $commit = $co{'id'};
5488 my $ref = format_ref_marker
($refs, $commit);
5491 print "<tr class=\"dark\">\n";
5493 print "<tr class=\"light\">\n";
5496 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5497 # shortlog: format_author_html('td', \%co, 10)
5498 format_author_html
('td', \
%co, 15, 3) . "<td>";
5499 # originally git_history used chop_str($co{'title'}, 50)
5500 print format_subject_html
($co{'title'}, $co{'title_short'},
5501 href
(action
=>"commit", hash
=>$commit), $ref);
5503 "<td class=\"link\">" .
5504 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
5505 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
5507 if ($ftype eq 'blob') {
5508 my $blob_current = $file_hash;
5509 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
5510 if (defined $blob_current && defined $blob_parent &&
5511 $blob_current ne $blob_parent) {
5513 $cgi->a({-href
=> href
(action
=>"blobdiff",
5514 hash
=>$blob_current, hash_parent
=>$blob_parent,
5515 hash_base
=>$hash_base, hash_parent_base
=>$commit,
5516 file_name
=>$file_name)},
5523 if (defined $extra) {
5525 "<td colspan=\"4\">$extra</td>\n" .
5532 # uses global variable $project
5533 my ($taglist, $from, $to, $extra) = @_;
5534 $from = 0 unless defined $from;
5535 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
5537 print "<table class=\"tags\">\n";
5539 for (my $i = $from; $i <= $to; $i++) {
5540 my $entry = $taglist->[$i];
5542 my $comment = $tag{'subject'};
5544 if (defined $comment) {
5545 $comment_short = chop_str
($comment, 30, 5);
5548 print "<tr class=\"dark\">\n";
5550 print "<tr class=\"light\">\n";
5553 if (defined $tag{'age'}) {
5554 print "<td><i>$tag{'age'}</i></td>\n";
5556 print "<td></td>\n";
5559 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
5560 -class => "list name"}, esc_html
($tag{'name'})) .
5563 if (defined $comment) {
5564 print format_subject_html
($comment, $comment_short,
5565 href
(action
=>"tag", hash
=>$tag{'id'}));
5568 "<td class=\"selflink\">";
5569 if ($tag{'type'} eq "tag") {
5570 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
5575 "<td class=\"link\">" . " | " .
5576 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
5577 if ($tag{'reftype'} eq "commit") {
5578 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
5579 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
5580 } elsif ($tag{'reftype'} eq "blob") {
5581 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
5586 if (defined $extra) {
5588 "<td colspan=\"5\">$extra</td>\n" .
5594 sub git_heads_body
{
5595 # uses global variable $project
5596 my ($headlist, $head, $from, $to, $extra) = @_;
5597 $from = 0 unless defined $from;
5598 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
5600 print "<table class=\"heads\">\n";
5602 for (my $i = $from; $i <= $to; $i++) {
5603 my $entry = $headlist->[$i];
5605 my $curr = $ref{'id'} eq $head;
5607 print "<tr class=\"dark\">\n";
5609 print "<tr class=\"light\">\n";
5612 print "<td><i>$ref{'age'}</i></td>\n" .
5613 ($curr ?
"<td class=\"current_head\">" : "<td>") .
5614 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
5615 -class => "list name"},esc_html
($ref{'name'})) .
5617 "<td class=\"link\">" .
5618 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
5619 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
5620 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'fullname'})}, "tree") .
5624 if (defined $extra) {
5626 "<td colspan=\"3\">$extra</td>\n" .
5632 # Display a single remote block
5633 sub git_remote_block
{
5634 my ($remote, $rdata, $limit, $head) = @_;
5636 my $heads = $rdata->{'heads'};
5637 my $fetch = $rdata->{'fetch'};
5638 my $push = $rdata->{'push'};
5640 my $urls_table = "<table class=\"projects_list\">\n" ;
5642 if (defined $fetch) {
5643 if ($fetch eq $push) {
5644 $urls_table .= format_repo_url
("URL", $fetch);
5646 $urls_table .= format_repo_url
("Fetch URL", $fetch);
5647 $urls_table .= format_repo_url
("Push URL", $push) if defined $push;
5649 } elsif (defined $push) {
5650 $urls_table .= format_repo_url
("Push URL", $push);
5652 $urls_table .= format_repo_url
("", "No remote URL");
5655 $urls_table .= "</table>\n";
5658 if (defined $limit && $limit < @
$heads) {
5659 $dots = $cgi->a({-href
=> href
(action
=>"remotes", hash
=>$remote)}, "...");
5663 git_heads_body
($heads, $head, 0, $limit, $dots);
5666 # Display a list of remote names with the respective fetch and push URLs
5667 sub git_remotes_list
{
5668 my ($remotedata, $limit) = @_;
5669 print "<table class=\"heads\">\n";
5671 my @remotes = sort keys %$remotedata;
5673 my $limited = $limit && $limit < @remotes;
5675 $#remotes = $limit - 1 if $limited;
5677 while (my $remote = shift @remotes) {
5678 my $rdata = $remotedata->{$remote};
5679 my $fetch = $rdata->{'fetch'};
5680 my $push = $rdata->{'push'};
5682 print "<tr class=\"dark\">\n";
5684 print "<tr class=\"light\">\n";
5688 $cgi->a({-href
=> href
(action
=>'remotes', hash
=>$remote),
5689 -class=> "list name"},esc_html
($remote)) .
5691 print "<td class=\"link\">" .
5692 (defined $fetch ?
$cgi->a({-href
=> $fetch}, "fetch") : "fetch") .
5694 (defined $push ?
$cgi->a({-href
=> $push}, "push") : "push") .
5702 "<td colspan=\"3\">" .
5703 $cgi->a({-href
=> href
(action
=>"remotes")}, "...") .
5704 "</td>\n" . "</tr>\n";
5710 # Display remote heads grouped by remote, unless there are too many
5711 # remotes, in which case we only display the remote names
5712 sub git_remotes_body
{
5713 my ($remotedata, $limit, $head) = @_;
5714 if ($limit and $limit < keys %$remotedata) {
5715 git_remotes_list
($remotedata, $limit);
5717 fill_remote_heads
($remotedata);
5718 while (my ($remote, $rdata) = each %$remotedata) {
5719 git_print_section
({-class=>"remote", -id
=>$remote},
5720 ["remotes", $remote, $remote], sub {
5721 git_remote_block
($remote, $rdata, $limit, $head);
5727 sub git_search_message
{
5731 if ($searchtype eq 'commit') {
5732 $greptype = "--grep=";
5733 } elsif ($searchtype eq 'author') {
5734 $greptype = "--author=";
5735 } elsif ($searchtype eq 'committer') {
5736 $greptype = "--committer=";
5738 $greptype .= $searchtext;
5739 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5740 $greptype, '--regexp-ignore-case',
5741 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5743 my $paging_nav = '';
5746 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)},
5749 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5750 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5752 $paging_nav .= "first ⋅ prev";
5755 if ($#commitlist >= 100) {
5757 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5758 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5759 $paging_nav .= " ⋅ $next_link";
5761 $paging_nav .= " ⋅ next";
5766 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5767 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5768 if ($page == 0 && !@commitlist) {
5769 print "<p>No match.</p>\n";
5771 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5777 sub git_search_changes
{
5781 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5782 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5783 ($search_use_regexp ?
'--pickaxe-regex' : ())
5784 or die_error
(500, "Open git-log failed");
5788 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5789 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5791 print "<table class=\"pickaxe search\">\n";
5795 while (my $line = <$fd>) {
5799 my %set = parse_difftree_raw_line
($line);
5800 if (defined $set{'commit'}) {
5801 # finish previous commit
5804 "<td class=\"link\">" .
5805 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5808 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5809 hash_base
=>$co{'id'})},
5816 print "<tr class=\"dark\">\n";
5818 print "<tr class=\"light\">\n";
5821 %co = parse_commit
($set{'commit'});
5822 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5823 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5824 "<td><i>$author</i></td>\n" .
5826 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5827 -class => "list subject"},
5828 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5829 } elsif (defined $set{'to_id'}) {
5830 next if ($set{'to_id'} =~ m/^0{40}$/);
5832 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5833 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5835 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5841 # finish last commit (warning: repetition!)
5844 "<td class=\"link\">" .
5845 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5848 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5849 hash_base
=>$co{'id'})},
5860 sub git_search_files
{
5864 open my $fd, "-|", git_cmd
(), 'grep', '-n', '-z',
5865 $search_use_regexp ?
('-E', '-i') : '-F',
5866 $searchtext, $co{'tree'}
5867 or die_error
(500, "Open git-grep failed");
5871 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5872 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5874 print "<table class=\"grep_search\">\n";
5878 while (my $line = <$fd>) {
5880 my ($file, $file_href, $lno, $ltext, $binary);
5881 last if ($matches++ > 1000);
5882 if ($line =~ /^Binary file (.+) matches$/) {
5886 ($file, $lno, $ltext) = split(/\0/, $line, 3);
5887 $file =~ s/^$co{'tree'}://;
5889 if ($file ne $lastfile) {
5890 $lastfile and print "</td></tr>\n";
5892 print "<tr class=\"dark\">\n";
5894 print "<tr class=\"light\">\n";
5896 $file_href = href
(action
=>"blob", hash_base
=>$co{'id'},
5898 print "<td class=\"list\">".
5899 $cgi->a({-href
=> $file_href, -class => "list"}, esc_path
($file));
5900 print "</td><td>\n";
5904 print "<div class=\"binary\">Binary file</div>\n";
5906 $ltext = untabify
($ltext);
5907 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5908 $ltext = esc_html
($1, -nbsp
=>1);
5909 $ltext .= '<span class="match">';
5910 $ltext .= esc_html
($2, -nbsp
=>1);
5911 $ltext .= '</span>';
5912 $ltext .= esc_html
($3, -nbsp
=>1);
5914 $ltext = esc_html
($ltext, -nbsp
=>1);
5916 print "<div class=\"pre\">" .
5917 $cgi->a({-href
=> $file_href.'#l'.$lno,
5918 -class => "linenr"}, sprintf('%4i', $lno)) .
5919 ' ' . $ltext . "</div>\n";
5923 print "</td></tr>\n";
5924 if ($matches > 1000) {
5925 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5928 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5937 sub git_search_grep_body
{
5938 my ($commitlist, $from, $to, $extra) = @_;
5939 $from = 0 unless defined $from;
5940 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5942 print "<table class=\"commit_search\">\n";
5944 for (my $i = $from; $i <= $to; $i++) {
5945 my %co = %{$commitlist->[$i]};
5949 my $commit = $co{'id'};
5951 print "<tr class=\"dark\">\n";
5953 print "<tr class=\"light\">\n";
5956 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5957 format_author_html
('td', \
%co, 15, 5) .
5959 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5960 -class => "list subject"},
5961 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5962 my $comment = $co{'comment'};
5963 foreach my $line (@
$comment) {
5964 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5965 my ($lead, $match, $trail) = ($1, $2, $3);
5966 $match = chop_str
($match, 70, 5, 'center');
5967 my $contextlen = int((80 - length($match))/2);
5968 $contextlen = 30 if ($contextlen > 30);
5969 $lead = chop_str
($lead, $contextlen, 10, 'left');
5970 $trail = chop_str
($trail, $contextlen, 10, 'right');
5972 $lead = esc_html
($lead);
5973 $match = esc_html
($match);
5974 $trail = esc_html
($trail);
5976 print "$lead<span class=\"match\">$match</span>$trail<br />";
5980 "<td class=\"link\">" .
5981 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5983 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
5985 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5989 if (defined $extra) {
5991 "<td colspan=\"3\">$extra</td>\n" .
5997 ## ======================================================================
5998 ## ======================================================================
6001 sub git_project_list
{
6002 my $order = $input_params{'order'};
6003 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
6004 die_error
(400, "Unknown order parameter");
6007 my @list = git_get_projects_list
();
6009 die_error
(404, "No projects found");
6013 if (defined $home_text && -f
$home_text) {
6014 print "<div class=\"index_include\">\n";
6015 insert_file
($home_text);
6018 print $cgi->startform(-method
=> "get") .
6019 "<p class=\"projsearch\">Search:\n" .
6020 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
6022 $cgi->end_form() . "\n";
6023 git_project_list_body
(\
@list, $order);
6028 my $order = $input_params{'order'};
6029 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
6030 die_error
(400, "Unknown order parameter");
6033 my @list = git_get_projects_list
($project);
6035 die_error
(404, "No forks found");
6039 git_print_page_nav
('','');
6040 git_print_header_div
('summary', "$project forks");
6041 git_project_list_body
(\
@list, $order);
6045 sub git_project_index
{
6046 my @projects = git_get_projects_list
();
6048 die_error
(404, "No projects found");
6052 -type
=> 'text/plain',
6053 -charset
=> 'utf-8',
6054 -content_disposition
=> 'inline; filename="index.aux"');
6056 foreach my $pr (@projects) {
6057 if (!exists $pr->{'owner'}) {
6058 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
6061 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
6062 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
6063 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
6064 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
6068 print "$path $owner\n";
6073 my $descr = git_get_project_description
($project) || "none";
6074 my %co = parse_commit
("HEAD");
6075 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
6076 my $head = $co{'id'};
6077 my $remote_heads = gitweb_check_feature
('remote_heads');
6079 my $owner = git_get_project_owner
($project);
6081 my $refs = git_get_references
();
6082 # These get_*_list functions return one more to allow us to see if
6083 # there are more ...
6084 my @taglist = git_get_tags_list
(16);
6085 my @headlist = git_get_heads_list
(16);
6086 my %remotedata = $remote_heads ? git_get_remotes_list
() : ();
6088 my $check_forks = gitweb_check_feature
('forks');
6091 # find forks of a project
6092 @forklist = git_get_projects_list
($project);
6093 # filter out forks of forks
6094 @forklist = filter_forks_from_projects_list
(\
@forklist)
6099 git_print_page_nav
('summary','', $head);
6101 print "<div class=\"title\"> </div>\n";
6102 print "<table class=\"projects_list\">\n" .
6103 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
6104 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
6105 if (defined $cd{'rfc2822'}) {
6106 print "<tr id=\"metadata_lchange\"><td>last change</td>" .
6107 "<td>".format_timestamp_html
(\
%cd)."</td></tr>\n";
6110 # use per project git URL list in $projectroot/$project/cloneurl
6111 # or make project git URL from git base URL and project name
6112 my $url_tag = "URL";
6113 my @url_list = git_get_project_url_list
($project);
6114 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
6115 foreach my $git_url (@url_list) {
6116 next unless $git_url;
6117 print format_repo_url
($url_tag, $git_url);
6122 my $show_ctags = gitweb_check_feature
('ctags');
6124 my $ctags = git_get_project_ctags
($project);
6126 # without ability to add tags, don't show if there are none
6127 my $cloud = git_populate_project_tagcloud
($ctags);
6128 print "<tr id=\"metadata_ctags\">" .
6129 "<td>content tags</td>" .
6130 "<td>".git_show_project_tagcloud
($cloud, 48)."</td>" .
6137 # If XSS prevention is on, we don't include README.html.
6138 # TODO: Allow a readme in some safe format.
6139 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
6140 print "<div class=\"title\">readme</div>\n" .
6141 "<div class=\"readme\">\n";
6142 insert_file
("$projectroot/$project/README.html");
6143 print "\n</div>\n"; # class="readme"
6146 # we need to request one more than 16 (0..15) to check if
6148 my @commitlist = $head ? parse_commits
($head, 17) : ();
6150 git_print_header_div
('shortlog');
6151 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
6152 $#commitlist <= 15 ?
undef :
6153 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
6157 git_print_header_div
('tags');
6158 git_tags_body
(\
@taglist, 0, 15,
6159 $#taglist <= 15 ?
undef :
6160 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
6164 git_print_header_div
('heads');
6165 git_heads_body
(\
@headlist, $head, 0, 15,
6166 $#headlist <= 15 ?
undef :
6167 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
6171 git_print_header_div
('remotes');
6172 git_remotes_body
(\
%remotedata, 15, $head);
6176 git_print_header_div
('forks');
6177 git_project_list_body
(\
@forklist, 'age', 0, 15,
6178 $#forklist <= 15 ?
undef :
6179 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
6187 my %tag = parse_tag
($hash);
6190 die_error
(404, "Unknown tag object");
6193 my $head = git_get_head_hash
($project);
6195 git_print_page_nav
('','', $head,undef,$head);
6196 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
6197 print "<div class=\"title_text\">\n" .
6198 "<table class=\"object_header\">\n" .
6200 "<td>object</td>\n" .
6201 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6202 $tag{'object'}) . "</td>\n" .
6203 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6204 $tag{'type'}) . "</td>\n" .
6206 if (defined($tag{'author'})) {
6207 git_print_authorship_rows
(\
%tag, 'author');
6209 print "</table>\n\n" .
6211 print "<div class=\"page_body\">";
6212 my $comment = $tag{'comment'};
6213 foreach my $line (@
$comment) {
6215 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
6221 sub git_blame_common
{
6222 my $format = shift || 'porcelain';
6223 if ($format eq 'porcelain' && $cgi->param('js')) {
6224 $format = 'incremental';
6225 $action = 'blame_incremental'; # for page title etc
6229 gitweb_check_feature
('blame')
6230 or die_error
(403, "Blame view not allowed");
6233 die_error
(400, "No file name given") unless $file_name;
6234 $hash_base ||= git_get_head_hash
($project);
6235 die_error
(404, "Couldn't find base commit") unless $hash_base;
6236 my %co = parse_commit
($hash_base)
6237 or die_error
(404, "Commit not found");
6239 if (!defined $hash) {
6240 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
6241 or die_error
(404, "Error looking up file");
6243 $ftype = git_get_type
($hash);
6244 if ($ftype !~ "blob") {
6245 die_error
(400, "Object is not a blob");
6250 if ($format eq 'incremental') {
6251 # get file contents (as base)
6252 open $fd, "-|", git_cmd
(), 'cat-file', 'blob', $hash
6253 or die_error
(500, "Open git-cat-file failed");
6254 } elsif ($format eq 'data') {
6255 # run git-blame --incremental
6256 open $fd, "-|", git_cmd
(), "blame", "--incremental",
6257 $hash_base, "--", $file_name
6258 or die_error
(500, "Open git-blame --incremental failed");
6260 # run git-blame --porcelain
6261 open $fd, "-|", git_cmd
(), "blame", '-p',
6262 $hash_base, '--', $file_name
6263 or die_error
(500, "Open git-blame --porcelain failed");
6266 # incremental blame data returns early
6267 if ($format eq 'data') {
6269 -type
=>"text/plain", -charset
=> "utf-8",
6270 -status
=> "200 OK");
6271 local $| = 1; # output autoflush
6272 while (my $line = <$fd>) {
6273 print to_utf8
($line);
6276 or print "ERROR $!\n";
6279 if (defined $t0 && gitweb_check_feature
('timed')) {
6281 tv_interval
($t0, [ gettimeofday
() ]).
6282 ' '.$number_of_git_cmds;
6292 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
6295 if ($format eq 'incremental') {
6297 $cgi->a({-href
=> href
(action
=>"blame", javascript
=>0, -replay
=>1)},
6298 "blame") . " (non-incremental)";
6301 $cgi->a({-href
=> href
(action
=>"blame_incremental", -replay
=>1)},
6302 "blame") . " (incremental)";
6306 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6309 $cgi->a({-href
=> href
(action
=>$action, file_name
=>$file_name)},
6311 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6312 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6313 git_print_page_path
($file_name, $ftype, $hash_base);
6316 if ($format eq 'incremental') {
6317 print "<noscript>\n<div class=\"error\"><center><b>\n".
6318 "This page requires JavaScript to run.\n Use ".
6319 $cgi->a({-href
=> href
(action
=>'blame',javascript
=>0,-replay
=>1)},
6322 "</b></center></div>\n</noscript>\n";
6324 print qq!<div id
="progress_bar" style
="width: 100%; background-color: yellow"></div
>\n!;
6327 print qq!<div
class="page_body">\n!;
6328 print qq!<div id
="progress_info">... / ...</div
>\n!
6329 if ($format eq 'incremental');
6330 print qq!<table id
="blame_table" class="blame" width
="100%">\n!.
6331 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
6333 qq!<tr
><th
>Commit
</th><th>Line</th
><th
>Data
</th></tr
>\n!.
6337 my @rev_color = qw(light dark);
6338 my $num_colors = scalar(@rev_color);
6339 my $current_color = 0;
6341 if ($format eq 'incremental') {
6342 my $color_class = $rev_color[$current_color];
6347 while (my $line = <$fd>) {
6351 print qq!<tr id
="l$linenr" class="$color_class">!.
6352 qq!<td
class="sha1"><a href
=""> </a></td
>!.
6353 qq!<td
class="linenr">!.
6354 qq!<a
class="linenr" href
="">$linenr</a></td
>!;
6355 print qq!<td
class="pre">! . esc_html
($line) . "</td>\n";
6359 } else { # porcelain, i.e. ordinary blame
6360 my %metainfo = (); # saves information about commits
6364 while (my $line = <$fd>) {
6366 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
6367 # no <lines in group> for subsequent lines in group of lines
6368 my ($full_rev, $orig_lineno, $lineno, $group_size) =
6369 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
6370 if (!exists $metainfo{$full_rev}) {
6371 $metainfo{$full_rev} = { 'nprevious' => 0 };
6373 my $meta = $metainfo{$full_rev};
6375 while ($data = <$fd>) {
6377 last if ($data =~ s/^\t//); # contents of line
6378 if ($data =~ /^(\S+)(?: (.*))?$/) {
6379 $meta->{$1} = $2 unless exists $meta->{$1};
6381 if ($data =~ /^previous /) {
6382 $meta->{'nprevious'}++;
6385 my $short_rev = substr($full_rev, 0, 8);
6386 my $author = $meta->{'author'};
6388 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
6389 my $date = $date{'iso-tz'};
6391 $current_color = ($current_color + 1) % $num_colors;
6393 my $tr_class = $rev_color[$current_color];
6394 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
6395 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
6396 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
6397 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
6399 print "<td class=\"sha1\"";
6400 print " title=\"". esc_html
($author) . ", $date\"";
6401 print " rowspan=\"$group_size\"" if ($group_size > 1);
6403 print $cgi->a({-href
=> href
(action
=>"commit",
6405 file_name
=>$file_name)},
6406 esc_html
($short_rev));
6407 if ($group_size >= 2) {
6408 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
6409 if (@author_initials) {
6411 esc_html
(join('', @author_initials));
6417 # 'previous' <sha1 of parent commit> <filename at commit>
6418 if (exists $meta->{'previous'} &&
6419 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
6420 $meta->{'parent'} = $1;
6421 $meta->{'file_parent'} = unquote
($2);
6424 exists($meta->{'parent'}) ?
6425 $meta->{'parent'} : $full_rev;
6426 my $linenr_filename =
6427 exists($meta->{'file_parent'}) ?
6428 $meta->{'file_parent'} : unquote
($meta->{'filename'});
6429 my $blamed = href
(action
=> 'blame',
6430 file_name
=> $linenr_filename,
6431 hash_base
=> $linenr_commit);
6432 print "<td class=\"linenr\">";
6433 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
6434 -class => "linenr" },
6437 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
6445 "</table>\n"; # class="blame"
6446 print "</div>\n"; # class="blame_body"
6448 or print "Reading blob failed\n";
6457 sub git_blame_incremental
{
6458 git_blame_common
('incremental');
6461 sub git_blame_data
{
6462 git_blame_common
('data');
6466 my $head = git_get_head_hash
($project);
6468 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('tags'));
6469 git_print_header_div
('summary', $project);
6471 my @tagslist = git_get_tags_list
();
6473 git_tags_body
(\
@tagslist);
6479 my $head = git_get_head_hash
($project);
6481 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('heads'));
6482 git_print_header_div
('summary', $project);
6484 my @headslist = git_get_heads_list
();
6486 git_heads_body
(\
@headslist, $head);
6491 # used both for single remote view and for list of all the remotes
6493 gitweb_check_feature
('remote_heads')
6494 or die_error
(403, "Remote heads view is disabled");
6496 my $head = git_get_head_hash
($project);
6497 my $remote = $input_params{'hash'};
6499 my $remotedata = git_get_remotes_list
($remote);
6500 die_error
(500, "Unable to get remote information") unless defined $remotedata;
6502 unless (%$remotedata) {
6503 die_error
(404, defined $remote ?
6504 "Remote $remote not found" :
6505 "No remotes found");
6508 git_header_html
(undef, undef, -action_extra
=> $remote);
6509 git_print_page_nav
('', '', $head, undef, $head,
6510 format_ref_views
($remote ?
'' : 'remotes'));
6512 fill_remote_heads
($remotedata);
6513 if (defined $remote) {
6514 git_print_header_div
('remotes', "$remote remote for $project");
6515 git_remote_block
($remote, $remotedata->{$remote}, undef, $head);
6517 git_print_header_div
('summary', "$project remotes");
6518 git_remotes_body
($remotedata, undef, $head);
6524 sub git_blob_plain
{
6528 if (!defined $hash) {
6529 if (defined $file_name) {
6530 my $base = $hash_base || git_get_head_hash
($project);
6531 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6532 or die_error
(404, "Cannot find file");
6534 die_error
(400, "No file name defined");
6536 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6537 # blobs defined by non-textual hash id's can be cached
6541 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6542 or die_error
(500, "Open git-cat-file blob '$hash' failed");
6544 # content-type (can include charset)
6545 $type = blob_contenttype
($fd, $file_name, $type);
6547 # "save as" filename, even when no $file_name is given
6548 my $save_as = "$hash";
6549 if (defined $file_name) {
6550 $save_as = $file_name;
6551 } elsif ($type =~ m/^text\//) {
6555 # With XSS prevention on, blobs of all types except a few known safe
6556 # ones are served with "Content-Disposition: attachment" to make sure
6557 # they don't run in our security domain. For certain image types,
6558 # blob view writes an <img> tag referring to blob_plain view, and we
6559 # want to be sure not to break that by serving the image as an
6560 # attachment (though Firefox 3 doesn't seem to care).
6561 my $sandbox = $prevent_xss &&
6562 $type !~ m!^(?:text/[a-z]+|image/(?:gif|png|jpeg))(?:[ ;]|$)!;
6564 # serve text/* as text/plain
6566 ($type =~ m!^text/[a-z]+\b(.*)$! ||
6567 ($type =~ m!^[a-z]+/[a-z]\+xml\b(.*)$! && -T
$fd))) {
6569 $rest = defined $rest ?
$rest : '';
6570 $type = "text/plain$rest";
6575 -expires
=> $expires,
6576 -content_disposition
=>
6577 ($sandbox ?
'attachment' : 'inline')
6578 . '; filename="' . $save_as . '"');
6580 binmode STDOUT
, ':raw';
6582 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6589 if (!defined $hash) {
6590 if (defined $file_name) {
6591 my $base = $hash_base || git_get_head_hash
($project);
6592 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6593 or die_error
(404, "Cannot find file");
6595 die_error
(400, "No file name defined");
6597 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6598 # blobs defined by non-textual hash id's can be cached
6602 my $have_blame = gitweb_check_feature
('blame');
6603 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6604 or die_error
(500, "Couldn't cat $file_name, $hash");
6605 my $mimetype = blob_mimetype
($fd, $file_name);
6606 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
6607 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
6609 return git_blob_plain
($mimetype);
6611 # we can have blame only for text/* mimetype
6612 $have_blame &&= ($mimetype =~ m!^text/!);
6614 my $highlight_js = gitweb_check_feature
('syntaxhighlighter_js');
6615 if ($highlight_js) {
6616 push @stylesheets, $highlight_js->{url
} . '/styles/shCore'
6617 . $highlight_js->{style
} . '.css';
6618 push @stylesheets, $highlight_js->{url
} . '/styles/shTheme'
6619 . $highlight_js->{theme
} . '.css';
6622 my $highlight = gitweb_check_feature
('highlight');
6623 if ($highlight_js && $highlight) {
6624 die_error
(500, 'The highlight and syntaxhighlighter_js are'
6625 . 'mutually exclusive');
6627 my $syntax = guess_file_syntax
($highlight, $mimetype, $file_name);
6628 $fd = run_highlighter
($fd, $highlight, $syntax)
6631 git_header_html
(undef, $expires);
6632 my $formats_nav = '';
6633 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6634 if (defined $file_name) {
6637 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
6642 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6645 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6648 $cgi->a({-href
=> href
(action
=>"blob",
6649 hash_base
=>"HEAD", file_name
=>$file_name)},
6653 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6656 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6657 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6659 print "<div class=\"page_nav\">\n" .
6660 "<br/><br/></div>\n" .
6661 "<div class=\"title\">".esc_html
($hash)."</div>\n";
6663 git_print_page_path
($file_name, "blob", $hash_base);
6664 print "<div class=\"page_body\">\n";
6665 if ($mimetype =~ m!^image/!) {
6666 print qq!<img type
="!.esc_attr($mimetype).qq!"!;
6668 print qq! alt
="!.esc_attr($file_name).qq!" title
="!.esc_attr($file_name).qq!"!;
6671 href(action=>"blob_plain
", hash=>$hash,
6672 hash_base=>$hash_base, file_name=>$file_name) .
6674 } elsif ($highlight_js) {
6675 my $ext = $file_name;
6677 print qq!<pre
class="brush:!.$ext.qq!">!;
6678 while (my $line = <$fd>) {
6679 $line =~ s!&!\&!g;
6680 $line =~ s!<!\<!g;
6684 foreach my $name ('Core', 'Autoloader') {
6685 print qq!<script src
="!.$highlight_js->{url}
6686 .qq!/scripts/sh!.$name
6687 .qq!.js" type
="text/javascript"></script
>!;
6689 print qq!<script type
="text/javascript">!;
6690 print qq!SyntaxHighlighter
.defaults
["pad-line-numbers"] = 3;!;
6691 print qq!SyntaxHighlighter
.defaults
["toolbar"] = false
;!;
6692 # for XHTML compliance
6693 print qq!SyntaxHighlighter
.config
["space"] = ' ';!;
6694 print qq!SyntaxHighlighter
.autoloader
(!;
6695 my $brush_prefix = $highlight_js->{url
} . '/scripts/shBrush';
6696 foreach my $language ('applescript AppleScript',
6697 'actionscript3 as3 AS3',
6700 'coldfusion cf ColdFusion',
6702 'c# c-sharp csharp CSharp',
6704 'delphi pascal Delphi',
6705 'diff patch pas Diff',
6706 'erl erlang Erlang',
6709 'jfx javafx JavaFX',
6710 'js jscript javascript JScript',
6715 'ruby rails ror rb Ruby',
6720 'xml xhtml xslt html Xml') {
6721 my $lang = $language;
6722 $lang =~ s! (\S+)$! $brush_prefix$1!;
6723 print "'".$lang.qq!.js
',!;
6725 print qq!''); SyntaxHighlighter.all();!
6726 .qq!function scrollTo(number) {!
6727 .qq! var elements = document.getElementsByClassName(number);!
6728 .qq! if (elements.length == 0) setTimeout('scrollTo
("' + number + '");', 50);!
6730 .qq! window.scroll(0, elements[0].offsetTop);!
6731 .qq! window.scrollTo(0, elements[0].offsetTop);!
6732 .qq! elements[0].style.color = '#ff0000';!
6735 .qq!var lineRegex
= /#l(\\d+)\$/;!
6736 .qq!var lineNumber
= lineRegex
.exec(document
.URL
);!
6737 .qq!if (lineNumber
)!
6738 .qq! scrollTo
('number' + lineNumber
[1]);!
6742 while (my $line = <$fd>) {
6745 $line = untabify
($line);
6746 printf qq!<div
class="pre"><a id
="l%i" href
="%s#l%i" class="linenr">%4i</a> %s</div
>\n!,
6747 $nr, esc_attr
(href
(-replay
=> 1)), $nr, $nr,
6748 $syntax ? sanitize
($line) : esc_html
($line, -nbsp
=>1);
6752 or print "Reading blob failed.\n";
6758 if (!defined $hash_base) {
6759 $hash_base = "HEAD";
6761 if (!defined $hash) {
6762 if (defined $file_name) {
6763 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
6768 die_error
(404, "No such tree") unless defined($hash);
6770 my $show_sizes = gitweb_check_feature
('show-sizes');
6771 my $have_blame = gitweb_check_feature
('blame');
6776 open my $fd, "-|", git_cmd
(), "ls-tree", '-z',
6777 ($show_sizes ?
'-l' : ()), @extra_options, $hash
6778 or die_error
(500, "Open git-ls-tree failed");
6779 @entries = map { chomp; $_ } <$fd>;
6781 or die_error
(404, "Reading tree failed");
6784 my $refs = git_get_references
();
6785 my $ref = format_ref_marker
($refs, $hash_base);
6788 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6790 if (defined $file_name) {
6792 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6794 $cgi->a({-href
=> href
(action
=>"tree",
6795 hash_base
=>"HEAD", file_name
=>$file_name)},
6798 my $snapshot_links = format_snapshot_links
($hash);
6799 if (defined $snapshot_links) {
6800 # FIXME: Should be available when we have no hash base as well.
6801 push @views_nav, $snapshot_links;
6803 git_print_page_nav
('tree','', $hash_base, undef, undef,
6804 join(' | ', @views_nav));
6805 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
6808 print "<div class=\"page_nav\">\n";
6809 print "<br/><br/></div>\n";
6810 print "<div class=\"title\">".esc_html
($hash)."</div>\n";
6812 if (defined $file_name) {
6813 $basedir = $file_name;
6814 if ($basedir ne '' && substr($basedir, -1) ne '/') {
6817 git_print_page_path
($file_name, 'tree', $hash_base);
6819 print "<div class=\"page_body\">\n";
6820 print "<table class=\"tree\">\n";
6822 # '..' (top directory) link if possible
6823 if (defined $hash_base &&
6824 defined $file_name && $file_name =~ m![^/]+$!) {
6826 print "<tr class=\"dark\">\n";
6828 print "<tr class=\"light\">\n";
6832 my $up = $file_name;
6833 $up =~ s!/?[^/]+$!!;
6834 undef $up unless $up;
6835 # based on git_print_tree_entry
6836 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
6837 print '<td class="size"> </td>'."\n" if $show_sizes;
6838 print '<td class="list">';
6839 print $cgi->a({-href
=> href
(action
=>"tree",
6840 hash_base
=>$hash_base,
6844 print "<td class=\"link\"></td>\n";
6848 foreach my $line (@entries) {
6849 my %t = parse_ls_tree_line
($line, -z
=> 1, -l
=> $show_sizes);
6852 print "<tr class=\"dark\">\n";
6854 print "<tr class=\"light\">\n";
6858 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
6862 print "</table>\n" .
6868 my ($project, $hash) = @_;
6870 # path/to/project.git -> project
6871 # path/to/project/.git -> project
6872 my $name = to_utf8
($project);
6873 $name =~ s
,([^/])/*\
.git
$,$1,;
6874 $name = basename
($name);
6876 $name =~ s/[[:cntrl:]]/?/g;
6879 if ($hash =~ /^[0-9a-fA-F]+$/) {
6880 # shorten SHA-1 hash
6881 my $full_hash = git_get_full_hash
($project, $hash);
6882 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
6883 $ver = git_get_short_hash
($project, $hash);
6885 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
6886 # tags don't need shortened SHA-1 hash
6889 # branches and other need shortened SHA-1 hash
6890 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
6893 $ver .= '-' . git_get_short_hash
($project, $hash);
6895 # in case of hierarchical branch names
6898 # name = project-version_string
6899 $name = "$name-$ver";
6901 return wantarray ?
($name, $name) : $name;
6905 my $format = $input_params{'snapshot_format'};
6906 if (!@snapshot_fmts) {
6907 die_error
(403, "Snapshots not allowed");
6909 # default to first supported snapshot format
6910 $format ||= $snapshot_fmts[0];
6911 if ($format !~ m/^[a-z0-9]+$/) {
6912 die_error
(400, "Invalid snapshot format parameter");
6913 } elsif (!exists($known_snapshot_formats{$format})) {
6914 die_error
(400, "Unknown snapshot format");
6915 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
6916 die_error
(403, "Snapshot format not allowed");
6917 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
6918 die_error
(403, "Unsupported snapshot format");
6921 my $type = git_get_type
("$hash^{}");
6923 die_error
(404, 'Object does not exist');
6924 } elsif ($type eq 'blob') {
6925 die_error
(400, 'Object is not a tree-ish');
6928 my ($name, $prefix) = snapshot_name
($project, $hash);
6929 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
6930 my $cmd = quote_command
(
6931 git_cmd
(), 'archive',
6932 "--format=$known_snapshot_formats{$format}{'format'}",
6933 "--prefix=$prefix/", $hash);
6934 if (exists $known_snapshot_formats{$format}{'compressor'}) {
6935 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
6938 $filename =~ s/(["\\])/\\$1/g;
6940 -type
=> $known_snapshot_formats{$format}{'type'},
6941 -content_disposition
=> 'inline; filename="' . $filename . '"',
6942 -status
=> '200 OK');
6944 open my $fd, "-|", $cmd
6945 or die_error
(500, "Execute git-archive failed");
6946 binmode STDOUT
, ':raw';
6948 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6952 sub git_log_generic
{
6953 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
6955 my $head = git_get_head_hash
($project);
6956 if (!defined $base) {
6959 if (!defined $page) {
6962 my $refs = git_get_references
();
6964 my $commit_hash = $base;
6965 if (defined $parent) {
6966 $commit_hash = "$parent..$base";
6969 parse_commits
($commit_hash, 101, (100 * $page),
6970 defined $file_name ?
($file_name, "--full-history") : ());
6973 if (!defined $file_hash && defined $file_name) {
6974 # some commits could have deleted file in question,
6975 # and not have it in tree, but one of them has to have it
6976 for (my $i = 0; $i < @commitlist; $i++) {
6977 $file_hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
6978 last if defined $file_hash;
6981 if (defined $file_hash) {
6982 $ftype = git_get_type
($file_hash);
6984 if (defined $file_name && !defined $ftype) {
6985 die_error
(500, "Unknown type of object");
6988 if (defined $file_name) {
6989 %co = parse_commit
($base)
6990 or die_error
(404, "Unknown commit object");
6994 my $paging_nav = format_paging_nav
($fmt_name, $page, $#commitlist >= 100);
6996 if ($#commitlist >= 100) {
6998 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6999 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
7001 my $patch_max = gitweb_get_feature
('patches');
7002 if ($patch_max && !defined $file_name) {
7003 if ($patch_max < 0 || @commitlist <= $patch_max) {
7004 $paging_nav .= " ⋅ " .
7005 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
7011 git_print_page_nav
($fmt_name,'', $hash,$hash,$hash, $paging_nav);
7012 if (defined $file_name) {
7013 git_print_header_div
('commit', esc_html
($co{'title'}), $base);
7015 git_print_header_div
('summary', $project)
7017 git_print_page_path
($file_name, $ftype, $hash_base)
7018 if (defined $file_name);
7020 $body_subr->(\
@commitlist, 0, 99, $refs, $next_link,
7021 $file_name, $file_hash, $ftype);
7027 git_log_generic
('log', \
&git_log_body
,
7028 $hash, $hash_parent);
7032 $hash ||= $hash_base || "HEAD";
7033 my %co = parse_commit
($hash)
7034 or die_error
(404, "Unknown commit object");
7036 my $parent = $co{'parent'};
7037 my $parents = $co{'parents'}; # listref
7039 # we need to prepare $formats_nav before any parameter munging
7041 if (!defined $parent) {
7043 $formats_nav .= '(initial)';
7044 } elsif (@
$parents == 1) {
7045 # single parent commit
7048 $cgi->a({-href
=> href
(action
=>"commit",
7050 esc_html
(substr($parent, 0, 7))) .
7057 $cgi->a({-href
=> href
(action
=>"commit",
7059 esc_html
(substr($_, 0, 7)));
7063 if (gitweb_check_feature
('patches') && @
$parents <= 1) {
7064 $formats_nav .= " | " .
7065 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
7069 if (!defined $parent) {
7073 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
7075 (@
$parents <= 1 ?
$parent : '-c'),
7077 or die_error
(500, "Open git-diff-tree failed");
7078 @difftree = map { chomp; $_ } <$fd>;
7079 close $fd or die_error
(404, "Reading git-diff-tree failed");
7081 # non-textual hash id's can be cached
7083 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
7086 my $refs = git_get_references
();
7087 my $ref = format_ref_marker
($refs, $co{'id'});
7089 git_header_html
(undef, $expires);
7090 git_print_page_nav
('commit', '',
7091 $hash, $co{'tree'}, $hash,
7094 if (defined $co{'parent'}) {
7095 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
7097 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
7099 print "<div class=\"title_text\">\n" .
7100 "<table class=\"object_header\">\n";
7101 git_print_authorship_rows
(\
%co);
7102 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
7105 "<td class=\"sha1\">" .
7106 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
7107 class => "list"}, $co{'tree'}) .
7109 "<td class=\"link\">" .
7110 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
7112 my $snapshot_links = format_snapshot_links
($hash);
7113 if (defined $snapshot_links) {
7114 print " | " . $snapshot_links;
7119 foreach my $par (@
$parents) {
7122 "<td class=\"sha1\">" .
7123 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
7124 class => "list"}, $par) .
7126 "<td class=\"link\">" .
7127 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
7129 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
7136 print "<div class=\"page_body\">\n";
7137 git_print_log
($co{'comment'});
7140 git_difftree_body
(\
@difftree, $hash, @
$parents);
7146 # object is defined by:
7147 # - hash or hash_base alone
7148 # - hash_base and file_name
7151 # - hash or hash_base alone
7152 if ($hash || ($hash_base && !defined $file_name)) {
7153 my $object_id = $hash || $hash_base;
7155 open my $fd, "-|", quote_command
(
7156 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
7157 or die_error
(404, "Object does not exist");
7161 or die_error
(404, "Object does not exist");
7163 # - hash_base and file_name
7164 } elsif ($hash_base && defined $file_name) {
7165 $file_name =~ s
,/+$,,;
7167 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
7168 or die_error
(404, "Base object does not exist");
7170 # here errors should not hapen
7171 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
7172 or die_error
(500, "Open git-ls-tree failed");
7176 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
7177 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
7178 die_error
(404, "File or directory for given base does not exist");
7183 die_error
(400, "Not enough information to find object");
7186 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
7187 hash
=>$hash, hash_base
=>$hash_base,
7188 file_name
=>$file_name),
7189 -status
=> '302 Found');
7193 my $format = shift || 'html';
7194 my $diff_style = $input_params{'diff_style'} || 'inline';
7201 # preparing $fd and %diffinfo for git_patchset_body
7203 if (defined $hash_base && defined $hash_parent_base) {
7204 if (defined $file_name) {
7206 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7207 $hash_parent_base, $hash_base,
7208 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7209 or die_error
(500, "Open git-diff-tree failed");
7210 @difftree = map { chomp; $_ } <$fd>;
7212 or die_error
(404, "Reading git-diff-tree failed");
7214 or die_error
(404, "Blob diff not found");
7216 } elsif (defined $hash &&
7217 $hash =~ /[0-9a-fA-F]{40}/) {
7218 # try to find filename from $hash
7220 # read filtered raw output
7221 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7222 $hash_parent_base, $hash_base, "--"
7223 or die_error
(500, "Open git-diff-tree failed");
7225 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
7227 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
7228 map { chomp; $_ } <$fd>;
7230 or die_error
(404, "Reading git-diff-tree failed");
7232 or die_error
(404, "Blob diff not found");
7235 die_error
(400, "Missing one of the blob diff parameters");
7238 if (@difftree > 1) {
7239 die_error
(400, "Ambiguous blob diff specification");
7242 %diffinfo = parse_difftree_raw_line
($difftree[0]);
7243 $file_parent ||= $diffinfo{'from_file'} || $file_name;
7244 $file_name ||= $diffinfo{'to_file'};
7246 $hash_parent ||= $diffinfo{'from_id'};
7247 $hash ||= $diffinfo{'to_id'};
7249 # non-textual hash id's can be cached
7250 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
7251 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
7256 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7257 '-p', ($format eq 'html' ?
"--full-index" : ()),
7258 $hash_parent_base, $hash_base,
7259 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7260 or die_error
(500, "Open git-diff-tree failed");
7263 # old/legacy style URI -- not generated anymore since 1.4.3.
7265 die_error
('404 Not Found', "Missing one of the blob diff parameters")
7269 if ($format eq 'html') {
7271 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
7273 $formats_nav .= diff_style_nav
($diff_style);
7274 git_header_html
(undef, $expires);
7275 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
7276 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
7277 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
7279 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
7280 print "<div class=\"title\">".esc_html
("$hash vs $hash_parent")."</div>\n";
7282 if (defined $file_name) {
7283 git_print_page_path
($file_name, "blob", $hash_base);
7285 print "<div class=\"page_path\"></div>\n";
7288 } elsif ($format eq 'plain') {
7290 -type
=> 'text/plain',
7291 -charset
=> 'utf-8',
7292 -expires
=> $expires,
7293 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
7295 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7298 die_error
(400, "Unknown blobdiff format");
7302 if ($format eq 'html') {
7303 print "<div class=\"page_body\">\n";
7305 git_patchset_body
($fd, $diff_style,
7306 [ \
%diffinfo ], $hash_base, $hash_parent_base);
7309 print "</div>\n"; # class="page_body"
7313 while (my $line = <$fd>) {
7314 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
7315 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
7319 last if $line =~ m!^\+\+\+!;
7327 sub git_blobdiff_plain
{
7328 git_blobdiff
('plain');
7331 # assumes that it is added as later part of already existing navigation,
7332 # so it returns "| foo | bar" rather than just "foo | bar"
7333 sub diff_style_nav
{
7334 my ($diff_style, $is_combined) = @_;
7335 $diff_style ||= 'inline';
7337 return "" if ($is_combined);
7339 my @styles = (inline
=> 'inline', 'sidebyside' => 'side by side');
7340 my %styles = @styles;
7342 @styles[ map { $_ * 2 } 0..$#styles/2 ];
7347 $_ eq $diff_style ?
$styles{$_} :
7348 $cgi->a({-href
=> href
(-replay
=>1, diff_style
=> $_)}, $styles{$_})
7352 sub git_commitdiff
{
7354 my $format = $params{-format
} || 'html';
7355 my $diff_style = $input_params{'diff_style'} || 'inline';
7357 my ($patch_max) = gitweb_get_feature
('patches');
7358 if ($format eq 'patch') {
7359 die_error
(403, "Patch view not allowed") unless $patch_max;
7362 $hash ||= $hash_base || "HEAD";
7363 my %co = parse_commit
($hash)
7364 or die_error
(404, "Unknown commit object");
7366 # choose format for commitdiff for merge
7367 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
7368 $hash_parent = '--cc';
7370 # we need to prepare $formats_nav before almost any parameter munging
7372 if ($format eq 'html') {
7374 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
7376 if ($patch_max && @
{$co{'parents'}} <= 1) {
7377 $formats_nav .= " | " .
7378 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
7381 $formats_nav .= diff_style_nav
($diff_style, @
{$co{'parents'}} > 1);
7383 if (defined $hash_parent &&
7384 $hash_parent ne '-c' && $hash_parent ne '--cc') {
7385 # commitdiff with two commits given
7386 my $hash_parent_short = $hash_parent;
7387 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
7388 $hash_parent_short = substr($hash_parent, 0, 7);
7392 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
7393 if ($co{'parents'}[$i] eq $hash_parent) {
7394 $formats_nav .= ' parent ' . ($i+1);
7398 $formats_nav .= ': ' .
7399 $cgi->a({-href
=> href
(-replay
=>1,
7400 hash
=>$hash_parent, hash_base
=>undef)},
7401 esc_html
($hash_parent_short)) .
7403 } elsif (!$co{'parent'}) {
7405 $formats_nav .= ' (initial)';
7406 } elsif (scalar @
{$co{'parents'}} == 1) {
7407 # single parent commit
7410 $cgi->a({-href
=> href
(-replay
=>1,
7411 hash
=>$co{'parent'}, hash_base
=>undef)},
7412 esc_html
(substr($co{'parent'}, 0, 7))) .
7416 if ($hash_parent eq '--cc') {
7417 $formats_nav .= ' | ' .
7418 $cgi->a({-href
=> href
(-replay
=>1,
7419 hash
=>$hash, hash_parent
=>'-c')},
7421 } else { # $hash_parent eq '-c'
7422 $formats_nav .= ' | ' .
7423 $cgi->a({-href
=> href
(-replay
=>1,
7424 hash
=>$hash, hash_parent
=>'--cc')},
7430 $cgi->a({-href
=> href
(-replay
=>1,
7431 hash
=>$_, hash_base
=>undef)},
7432 esc_html
(substr($_, 0, 7)));
7433 } @
{$co{'parents'}} ) .
7438 my $hash_parent_param = $hash_parent;
7439 if (!defined $hash_parent_param) {
7440 # --cc for multiple parents, --root for parentless
7441 $hash_parent_param =
7442 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
7448 if ($format eq 'html') {
7449 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7450 "--no-commit-id", "--patch-with-raw", "--full-index",
7451 $hash_parent_param, $hash, "--"
7452 or die_error
(500, "Open git-diff-tree failed");
7454 while (my $line = <$fd>) {
7456 # empty line ends raw part of diff-tree output
7458 push @difftree, scalar parse_difftree_raw_line
($line);
7461 } elsif ($format eq 'plain') {
7462 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7463 '-p', $hash_parent_param, $hash, "--"
7464 or die_error
(500, "Open git-diff-tree failed");
7465 } elsif ($format eq 'patch') {
7466 # For commit ranges, we limit the output to the number of
7467 # patches specified in the 'patches' feature.
7468 # For single commits, we limit the output to a single patch,
7469 # diverging from the git-format-patch default.
7470 my @commit_spec = ();
7472 if ($patch_max > 0) {
7473 push @commit_spec, "-$patch_max";
7475 push @commit_spec, '-n', "$hash_parent..$hash";
7477 if ($params{-single
}) {
7478 push @commit_spec, '-1';
7480 if ($patch_max > 0) {
7481 push @commit_spec, "-$patch_max";
7483 push @commit_spec, "-n";
7485 push @commit_spec, '--root', $hash;
7487 open $fd, "-|", git_cmd
(), "format-patch", @diff_opts,
7488 '--encoding=utf8', '--stdout', @commit_spec
7489 or die_error
(500, "Open git-format-patch failed");
7491 die_error
(400, "Unknown commitdiff format");
7494 # non-textual hash id's can be cached
7496 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
7500 # write commit message
7501 if ($format eq 'html') {
7502 my $refs = git_get_references
();
7503 my $ref = format_ref_marker
($refs, $co{'id'});
7505 git_header_html
(undef, $expires);
7506 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
7507 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
7508 print "<div class=\"title_text\">\n" .
7509 "<table class=\"object_header\">\n";
7510 git_print_authorship_rows
(\
%co);
7513 print "<div class=\"page_body\">\n";
7514 if (@
{$co{'comment'}} > 1) {
7515 print "<div class=\"log\">\n";
7516 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
7517 print "</div>\n"; # class="log"
7520 } elsif ($format eq 'plain') {
7521 my $refs = git_get_references
("tags");
7522 my $tagname = git_get_rev_name_tags
($hash);
7523 my $filename = basename
($project) . "-$hash.patch";
7526 -type
=> 'text/plain',
7527 -charset
=> 'utf-8',
7528 -expires
=> $expires,
7529 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7530 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7531 print "From: " . to_utf8
($co{'author'}) . "\n";
7532 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
7533 print "Subject: " . to_utf8
($co{'title'}) . "\n";
7535 print "X-Git-Tag: $tagname\n" if $tagname;
7536 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7538 foreach my $line (@
{$co{'comment'}}) {
7539 print to_utf8
($line) . "\n";
7542 } elsif ($format eq 'patch') {
7543 my $filename = basename
($project) . "-$hash.patch";
7546 -type
=> 'text/plain',
7547 -charset
=> 'utf-8',
7548 -expires
=> $expires,
7549 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7553 if ($format eq 'html') {
7554 my $use_parents = !defined $hash_parent ||
7555 $hash_parent eq '-c' || $hash_parent eq '--cc';
7556 git_difftree_body
(\
@difftree, $hash,
7557 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7560 git_patchset_body
($fd, $diff_style,
7562 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7564 print "</div>\n"; # class="page_body"
7567 } elsif ($format eq 'plain') {
7571 or print "Reading git-diff-tree failed\n";
7572 } elsif ($format eq 'patch') {
7576 or print "Reading git-format-patch failed\n";
7580 sub git_commitdiff_plain
{
7581 git_commitdiff
(-format
=> 'plain');
7584 # format-patch-style patches
7586 git_commitdiff
(-format
=> 'patch', -single
=> 1);
7590 git_commitdiff
(-format
=> 'patch');
7594 git_log_generic
('history', \
&git_history_body
,
7595 $hash_base, $hash_parent_base,
7600 $searchtype ||= 'commit';
7602 # check if appropriate features are enabled
7603 gitweb_check_feature
('search')
7604 or die_error
(403, "Search is disabled");
7605 if ($searchtype eq 'pickaxe') {
7606 # pickaxe may take all resources of your box and run for several minutes
7607 # with every query - so decide by yourself how public you make this feature
7608 gitweb_check_feature
('pickaxe')
7609 or die_error
(403, "Pickaxe search is disabled");
7611 if ($searchtype eq 'grep') {
7612 # grep search might be potentially CPU-intensive, too
7613 gitweb_check_feature
('grep')
7614 or die_error
(403, "Grep search is disabled");
7617 if (!defined $searchtext) {
7618 die_error
(400, "Text field is empty");
7620 if (!defined $hash) {
7621 $hash = git_get_head_hash
($project);
7623 my %co = parse_commit
($hash);
7625 die_error
(404, "Unknown commit object");
7627 if (!defined $page) {
7631 if ($searchtype eq 'commit' ||
7632 $searchtype eq 'author' ||
7633 $searchtype eq 'committer') {
7634 git_search_message
(%co);
7635 } elsif ($searchtype eq 'pickaxe') {
7636 git_search_changes
(%co);
7637 } elsif ($searchtype eq 'grep') {
7638 git_search_files
(%co);
7640 die_error
(400, "Unknown search type");
7644 sub git_search_help
{
7646 git_print_page_nav
('','', $hash,$hash,$hash);
7648 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
7649 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
7650 the pattern entered is recognized as the POSIX extended
7651 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
7654 <dt><b>commit</b></dt>
7655 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
7657 my $have_grep = gitweb_check_feature
('grep');
7660 <dt><b>grep</b></dt>
7661 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
7662 a different one) are searched for the given pattern. On large trees, this search can take
7663 a while and put some strain on the server, so please use it with some consideration. Note that
7664 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
7665 case-sensitive.</dd>
7669 <dt><b>author</b></dt>
7670 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
7671 <dt><b>committer</b></dt>
7672 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
7674 my $have_pickaxe = gitweb_check_feature
('pickaxe');
7675 if ($have_pickaxe) {
7677 <dt><b>pickaxe</b></dt>
7678 <dd>All commits that caused the string to appear or disappear from any file (changes that
7679 added, removed or "modified" the string) will be listed. This search can take a while and
7680 takes a lot of strain on the server, so please use it wisely. Note that since you may be
7681 interested even in changes just changing the case as well, this search is case sensitive.</dd>
7689 git_log_generic
('shortlog', \
&git_shortlog_body
,
7690 $hash, $hash_parent);
7693 ## ......................................................................
7694 ## feeds (RSS, Atom; OPML)
7697 my $format = shift || 'atom';
7698 my $have_blame = gitweb_check_feature
('blame');
7700 # Atom: http://www.atomenabled.org/developers/syndication/
7701 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
7702 if ($format ne 'rss' && $format ne 'atom') {
7703 die_error
(400, "Unknown web feed format");
7706 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
7707 my $head = $hash || 'HEAD';
7708 my @commitlist = parse_commits
($head, 150, 0, $file_name);
7712 my $content_type = "application/$format+xml";
7713 if (defined $cgi->http('HTTP_ACCEPT') &&
7714 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
7715 # browser (feed reader) prefers text/xml
7716 $content_type = 'text/xml';
7718 if (defined($commitlist[0])) {
7719 %latest_commit = %{$commitlist[0]};
7720 my $latest_epoch = $latest_commit{'committer_epoch'};
7721 %latest_date = parse_date
($latest_epoch, $latest_commit{'comitter_tz'});
7722 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
7723 if (defined $if_modified) {
7725 if (eval { require HTTP
::Date
; 1; }) {
7726 $since = HTTP
::Date
::str2time
($if_modified);
7727 } elsif (eval { require Time
::ParseDate
; 1; }) {
7728 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
7730 if (defined $since && $latest_epoch <= $since) {
7732 -type
=> $content_type,
7733 -charset
=> 'utf-8',
7734 -last_modified
=> $latest_date{'rfc2822'},
7735 -status
=> '304 Not Modified');
7740 -type
=> $content_type,
7741 -charset
=> 'utf-8',
7742 -last_modified
=> $latest_date{'rfc2822'});
7745 -type
=> $content_type,
7746 -charset
=> 'utf-8');
7749 # Optimization: skip generating the body if client asks only
7750 # for Last-Modified date.
7751 return if ($cgi->request_method() eq 'HEAD');
7754 my $title = "$site_name - $project/$action";
7755 my $feed_type = 'log';
7756 if (defined $hash) {
7757 $title .= " - '$hash'";
7758 $feed_type = 'branch log';
7759 if (defined $file_name) {
7760 $title .= " :: $file_name";
7761 $feed_type = 'history';
7763 } elsif (defined $file_name) {
7764 $title .= " - $file_name";
7765 $feed_type = 'history';
7767 $title .= " $feed_type";
7768 my $descr = git_get_project_description
($project);
7769 if (defined $descr) {
7770 $descr = esc_html
($descr);
7772 $descr = "$project " .
7773 ($format eq 'rss' ?
'RSS' : 'Atom') .
7776 my $owner = git_get_project_owner
($project);
7777 $owner = esc_html
($owner);
7781 if (defined $file_name) {
7782 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
7783 } elsif (defined $hash) {
7784 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
7786 $alt_url = href
(-full
=>1, action
=>"summary");
7788 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
7789 if ($format eq 'rss') {
7791 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
7794 print "<title>$title</title>\n" .
7795 "<link>$alt_url</link>\n" .
7796 "<description>$descr</description>\n" .
7797 "<language>en</language>\n" .
7798 # project owner is responsible for 'editorial' content
7799 "<managingEditor>$owner</managingEditor>\n";
7800 if (defined $logo || defined $favicon) {
7801 # prefer the logo to the favicon, since RSS
7802 # doesn't allow both
7803 my $img = esc_url
($logo || $favicon);
7805 "<url>$img</url>\n" .
7806 "<title>$title</title>\n" .
7807 "<link>$alt_url</link>\n" .
7811 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
7812 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
7814 print "<generator>gitweb v.$version/$git_version</generator>\n";
7815 } elsif ($format eq 'atom') {
7817 <feed xmlns="http://www.w3.org/2005/Atom">
7819 print "<title>$title</title>\n" .
7820 "<subtitle>$descr</subtitle>\n" .
7821 '<link rel="alternate" type="text/html" href="' .
7822 $alt_url . '" />' . "\n" .
7823 '<link rel="self" type="' . $content_type . '" href="' .
7824 $cgi->self_url() . '" />' . "\n" .
7825 "<id>" . href
(-full
=>1) . "</id>\n" .
7826 # use project owner for feed author
7827 "<author><name>$owner</name></author>\n";
7828 if (defined $favicon) {
7829 print "<icon>" . esc_url
($favicon) . "</icon>\n";
7831 if (defined $logo) {
7832 # not twice as wide as tall: 72 x 27 pixels
7833 print "<logo>" . esc_url
($logo) . "</logo>\n";
7835 if (! %latest_date) {
7836 # dummy date to keep the feed valid until commits trickle in:
7837 print "<updated>1970-01-01T00:00:00Z</updated>\n";
7839 print "<updated>$latest_date{'iso-8601'}</updated>\n";
7841 print "<generator version='$version/$git_version'>gitweb</generator>\n";
7845 for (my $i = 0; $i <= $#commitlist; $i++) {
7846 my %co = %{$commitlist[$i]};
7847 my $commit = $co{'id'};
7848 # we read 150, we always show 30 and the ones more recent than 48 hours
7849 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
7852 my %cd = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7854 # get list of changed files
7855 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7856 $co{'parent'} || "--root",
7857 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
7859 my @difftree = map { chomp; $_ } <$fd>;
7863 # print element (entry, item)
7864 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
7865 if ($format eq 'rss') {
7867 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
7868 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
7869 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
7870 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
7871 "<link>$co_url</link>\n" .
7872 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
7873 "<content:encoded>" .
7875 } elsif ($format eq 'atom') {
7877 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
7878 "<updated>$cd{'iso-8601'}</updated>\n" .
7880 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
7881 if ($co{'author_email'}) {
7882 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
7884 print "</author>\n" .
7885 # use committer for contributor
7887 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
7888 if ($co{'committer_email'}) {
7889 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
7891 print "</contributor>\n" .
7892 "<published>$cd{'iso-8601'}</published>\n" .
7893 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
7894 "<id>$co_url</id>\n" .
7895 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
7896 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
7898 my $comment = $co{'comment'};
7900 foreach my $line (@
$comment) {
7901 $line = esc_html
($line);
7904 print "</pre><ul>\n";
7905 foreach my $difftree_line (@difftree) {
7906 my %difftree = parse_difftree_raw_line
($difftree_line);
7907 next if !$difftree{'from_id'};
7909 my $file = $difftree{'file'} || $difftree{'to_file'};
7913 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
7914 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
7915 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
7916 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
7917 -title
=> "diff"}, 'D');
7919 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
7920 file_name
=>$file, hash_base
=>$commit),
7921 -title
=> "blame"}, 'B');
7923 # if this is not a feed of a file history
7924 if (!defined $file_name || $file_name ne $file) {
7925 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
7926 file_name
=>$file, hash
=>$commit),
7927 -title
=> "history"}, 'H');
7929 $file = esc_path
($file);
7933 if ($format eq 'rss') {
7934 print "</ul>]]>\n" .
7935 "</content:encoded>\n" .
7937 } elsif ($format eq 'atom') {
7938 print "</ul>\n</div>\n" .
7945 if ($format eq 'rss') {
7946 print "</channel>\n</rss>\n";
7947 } elsif ($format eq 'atom') {
7961 my @list = git_get_projects_list
();
7963 die_error
(404, "No projects found");
7967 -type
=> 'text/xml',
7968 -charset
=> 'utf-8',
7969 -content_disposition
=> 'inline; filename="opml.xml"');
7971 my $title = esc_html
($site_name);
7973 <?xml version="1.0" encoding="utf-8"?>
7974 <opml version="1.0">
7976 <title>$title OPML Export</title>
7979 <outline text="git RSS feeds">
7982 foreach my $pr (@list) {
7984 my $head = git_get_head_hash
($proj{'path'});
7985 if (!defined $head) {
7988 $git_dir = "$projectroot/$proj{'path'}";
7989 my %co = parse_commit
($head);
7994 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
7995 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
7996 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
7997 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";