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 # filename of html text to include at top of each page
89 our $site_header = "++GITWEB_SITE_HEADER++";
90 # html text to include at home page
91 our $home_text = "++GITWEB_HOMETEXT++";
92 # filename of html text to include at bottom of each page
93 our $site_footer = "++GITWEB_SITE_FOOTER++";
96 our @stylesheets = ("++GITWEB_CSS++");
97 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
98 our $stylesheet = undef;
99 # URI of GIT logo (72x27 size)
100 our $logo = "++GITWEB_LOGO++";
101 # URI of GIT favicon, assumed to be image/png type
102 our $favicon = "++GITWEB_FAVICON++";
103 # URI of gitweb.js (JavaScript code for gitweb)
104 our $javascript = "++GITWEB_JS++";
106 # URI and label (title) of GIT logo link
107 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
108 #our $logo_label = "git documentation";
109 our $logo_url = "http://git-scm.com/";
110 our $logo_label = "git homepage";
112 # source of projects list
113 our $projects_list = "++GITWEB_LIST++";
115 # the width (in characters) of the projects list "Description" column
116 our $projects_list_description_width = 25;
118 # group projects by category on the projects list
119 # (enabled if this variable evaluates to true)
120 our $projects_list_group_categories = 0;
122 # default category if none specified
123 # (leave the empty string for no category)
124 our $project_list_default_category = "";
126 # default order of projects list
127 # valid values are none, project, descr, owner, and age
128 our $default_projects_order = "project";
130 # show repository only if this file exists
131 # (only effective if this variable evaluates to true)
132 our $export_ok = "++GITWEB_EXPORT_OK++";
134 # show repository only if this subroutine returns true
135 # when given the path to the project, for example:
136 # sub { return -e "$_[0]/git-daemon-export-ok"; }
137 our $export_auth_hook = undef;
139 # only allow viewing of repositories also shown on the overview page
140 our $strict_export = "++GITWEB_STRICT_EXPORT++";
142 # list of git base URLs used for URL to where fetch project from,
143 # i.e. full URL is "$git_base_url/$project"
144 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
146 # default blob_plain mimetype and default charset for text/plain blob
147 our $default_blob_plain_mimetype = 'text/plain';
148 our $default_text_plain_charset = undef;
150 # file to use for guessing MIME types before trying /etc/mime.types
151 # (relative to the current git repository)
152 our $mimetypes_file = undef;
154 # assume this charset if line contains non-UTF-8 characters;
155 # it should be valid encoding (see Encoding::Supported(3pm) for list),
156 # for which encoding all byte sequences are valid, for example
157 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
158 # could be even 'utf-8' for the old behavior)
159 our $fallback_encoding = 'latin1';
161 # rename detection options for git-diff and git-diff-tree
162 # - default is '-M', with the cost proportional to
163 # (number of removed files) * (number of new files).
164 # - more costly is '-C' (which implies '-M'), with the cost proportional to
165 # (number of changed files + number of removed files) * (number of new files)
166 # - even more costly is '-C', '--find-copies-harder' with cost
167 # (number of files in the original tree) * (number of new files)
168 # - one might want to include '-B' option, e.g. '-B', '-M'
169 our @diff_opts = ('-M'); # taken from git_commit
171 # Disables features that would allow repository owners to inject script into
173 our $prevent_xss = 0;
175 # Path to the highlight executable to use (must be the one from
176 # http://www.andre-simon.de due to assumptions about parameters and output).
177 # Useful if highlight is not installed on your webserver's PATH.
178 # [Default: highlight]
179 our $highlight_bin = "++HIGHLIGHT_BIN++";
181 # information about snapshot formats that gitweb is capable of serving
182 our %known_snapshot_formats = (
184 # 'display' => display name,
185 # 'type' => mime type,
186 # 'suffix' => filename suffix,
187 # 'format' => --format for git-archive,
188 # 'compressor' => [compressor command and arguments]
189 # (array reference, optional)
190 # 'disabled' => boolean (optional)}
193 'display' => 'tar.gz',
194 'type' => 'application/x-gzip',
195 'suffix' => '.tar.gz',
197 'compressor' => ['gzip', '-n']},
200 'display' => 'tar.bz2',
201 'type' => 'application/x-bzip2',
202 'suffix' => '.tar.bz2',
204 'compressor' => ['bzip2']},
207 'display' => 'tar.xz',
208 'type' => 'application/x-xz',
209 'suffix' => '.tar.xz',
211 'compressor' => ['xz'],
216 'type' => 'application/x-zip',
221 # Aliases so we understand old gitweb.snapshot values in repository
223 our %known_snapshot_format_aliases = (
228 # backward compatibility: legacy gitweb config support
229 'x-gzip' => undef, 'gz' => undef,
230 'x-bzip2' => undef, 'bz2' => undef,
231 'x-zip' => undef, '' => undef,
234 # Pixel sizes for icons and avatars. If the default font sizes or lineheights
235 # are changed, it may be appropriate to change these values too via
242 # Used to set the maximum load that we will still respond to gitweb queries.
243 # If server load exceed this value then return "503 server busy" error.
244 # If gitweb cannot determined server load, it is taken to be 0.
245 # Leave it undefined (or set to 'undef') to turn off load checking.
248 # configuration for 'highlight' (http://www.andre-simon.de/)
250 our %highlight_basename = (
253 'SConstruct' => 'py', # SCons equivalent of Makefile
254 'Makefile' => 'make',
257 our %highlight_ext = (
258 # main extensions, defining name of syntax;
259 # see files in /usr/share/highlight/langDefs/ directory
261 qw(py c cpp rb java css php sh pl js tex bib xml awk bat ini spec tcl sql make),
262 # alternate extensions, see /etc/highlight/filetypes.conf
264 map { $_ => 'sh' } qw(bash zsh ksh),
265 map { $_ => 'cpp' } qw(cxx c++ cc),
266 map { $_ => 'php' } qw(php3 php4 php5 phps),
267 map { $_ => 'pl' } qw(perl pm), # perhaps also 'cgi'
268 map { $_ => 'make'} qw(mak mk),
269 map { $_ => 'xml' } qw(xhtml html htm),
272 # You define site-wide feature defaults here; override them with
273 # $GITWEB_CONFIG as necessary.
276 # 'sub' => feature-sub (subroutine),
277 # 'override' => allow-override (boolean),
278 # 'default' => [ default options...] (array reference)}
280 # if feature is overridable (it means that allow-override has true value),
281 # then feature-sub will be called with default options as parameters;
282 # return value of feature-sub indicates if to enable specified feature
284 # if there is no 'sub' key (no feature-sub), then feature cannot be
287 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
288 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
291 # Enable the 'blame' blob view, showing the last commit that modified
292 # each line in the file. This can be very CPU-intensive.
294 # To enable system wide have in $GITWEB_CONFIG
295 # $feature{'blame'}{'default'} = [1];
296 # To have project specific config enable override in $GITWEB_CONFIG
297 # $feature{'blame'}{'override'} = 1;
298 # and in project config gitweb.blame = 0|1;
300 'sub' => sub { feature_bool
('blame', @_) },
304 # Enable the 'snapshot' link, providing a compressed archive of any
305 # tree. This can potentially generate high traffic if you have large
308 # Value is a list of formats defined in %known_snapshot_formats that
310 # To disable system wide have in $GITWEB_CONFIG
311 # $feature{'snapshot'}{'default'} = [];
312 # To have project specific config enable override in $GITWEB_CONFIG
313 # $feature{'snapshot'}{'override'} = 1;
314 # and in project config, a comma-separated list of formats or "none"
315 # to disable. Example: gitweb.snapshot = tbz2,zip;
317 'sub' => \
&feature_snapshot
,
319 'default' => ['tgz']},
321 # Enable text search, which will list the commits which match author,
322 # committer or commit text to a given string. Enabled by default.
323 # Project specific override is not supported.
325 # Note that this controls all search features, which means that if
326 # it is disabled, then 'grep' and 'pickaxe' search would also be
332 # Enable grep search, which will list the files in currently selected
333 # tree containing the given string. Enabled by default. This can be
334 # potentially CPU-intensive, of course.
335 # Note that you need to have 'search' feature enabled too.
337 # To enable system wide have in $GITWEB_CONFIG
338 # $feature{'grep'}{'default'} = [1];
339 # To have project specific config enable override in $GITWEB_CONFIG
340 # $feature{'grep'}{'override'} = 1;
341 # and in project config gitweb.grep = 0|1;
343 'sub' => sub { feature_bool
('grep', @_) },
347 # Enable the pickaxe search, which will list the commits that modified
348 # a given string in a file. This can be practical and quite faster
349 # alternative to 'blame', but still potentially CPU-intensive.
350 # Note that you need to have 'search' feature enabled too.
352 # To enable system wide have in $GITWEB_CONFIG
353 # $feature{'pickaxe'}{'default'} = [1];
354 # To have project specific config enable override in $GITWEB_CONFIG
355 # $feature{'pickaxe'}{'override'} = 1;
356 # and in project config gitweb.pickaxe = 0|1;
358 'sub' => sub { feature_bool
('pickaxe', @_) },
362 # Enable showing size of blobs in a 'tree' view, in a separate
363 # column, similar to what 'ls -l' does. This cost a bit of IO.
365 # To disable system wide have in $GITWEB_CONFIG
366 # $feature{'show-sizes'}{'default'} = [0];
367 # To have project specific config enable override in $GITWEB_CONFIG
368 # $feature{'show-sizes'}{'override'} = 1;
369 # and in project config gitweb.showsizes = 0|1;
371 'sub' => sub { feature_bool
('showsizes', @_) },
375 # Make gitweb use an alternative format of the URLs which can be
376 # more readable and natural-looking: project name is embedded
377 # directly in the path and the query string contains other
378 # auxiliary information. All gitweb installations recognize
379 # URL in either format; this configures in which formats gitweb
382 # To enable system wide have in $GITWEB_CONFIG
383 # $feature{'pathinfo'}{'default'} = [1];
384 # Project specific override is not supported.
386 # Note that you will need to change the default location of CSS,
387 # favicon, logo and possibly other files to an absolute URL. Also,
388 # if gitweb.cgi serves as your indexfile, you will need to force
389 # $my_uri to contain the script name in your $GITWEB_CONFIG.
394 # Make gitweb consider projects in project root subdirectories
395 # to be forks of existing projects. Given project $projname.git,
396 # projects matching $projname/*.git will not be shown in the main
397 # projects list, instead a '+' mark will be added to $projname
398 # there and a 'forks' view will be enabled for the project, listing
399 # all the forks. If project list is taken from a file, forks have
400 # to be listed after the main project.
402 # To enable system wide have in $GITWEB_CONFIG
403 # $feature{'forks'}{'default'} = [1];
404 # Project specific override is not supported.
409 # Insert custom links to the action bar of all project pages.
410 # This enables you mainly to link to third-party scripts integrating
411 # into gitweb; e.g. git-browser for graphical history representation
412 # or custom web-based repository administration interface.
414 # The 'default' value consists of a list of triplets in the form
415 # (label, link, position) where position is the label after which
416 # to insert the link and link is a format string where %n expands
417 # to the project name, %f to the project path within the filesystem,
418 # %h to the current hash (h gitweb parameter) and %b to the current
419 # hash base (hb gitweb parameter); %% expands to %.
421 # To enable system wide have in $GITWEB_CONFIG e.g.
422 # $feature{'actions'}{'default'} = [('graphiclog',
423 # '/git-browser/by-commit.html?r=%n', 'summary')];
424 # Project specific override is not supported.
429 # Allow gitweb scan project content tags of project repository,
430 # and display the popular Web 2.0-ish "tag cloud" near the projects
431 # list. Note that this is something COMPLETELY different from the
434 # gitweb by itself can show existing tags, but it does not handle
435 # tagging itself; you need to do it externally, outside gitweb.
436 # The format is described in git_get_project_ctags() subroutine.
437 # You may want to install the HTML::TagCloud Perl module to get
438 # a pretty tag cloud instead of just a list of tags.
440 # To enable system wide have in $GITWEB_CONFIG
441 # $feature{'ctags'}{'default'} = [1];
442 # Project specific override is not supported.
444 # In the future whether ctags editing is enabled might depend
445 # on the value, but using 1 should always mean no editing of ctags.
450 # The maximum number of patches in a patchset generated in patch
451 # view. Set this to 0 or undef to disable patch view, or to a
452 # negative number to remove any limit.
454 # To disable system wide have in $GITWEB_CONFIG
455 # $feature{'patches'}{'default'} = [0];
456 # To have project specific config enable override in $GITWEB_CONFIG
457 # $feature{'patches'}{'override'} = 1;
458 # and in project config gitweb.patches = 0|n;
459 # where n is the maximum number of patches allowed in a patchset.
461 'sub' => \
&feature_patches
,
465 # Avatar support. When this feature is enabled, views such as
466 # shortlog or commit will display an avatar associated with
467 # the email of the committer(s) and/or author(s).
469 # Currently available providers are gravatar and picon.
470 # If an unknown provider is specified, the feature is disabled.
472 # Gravatar depends on Digest::MD5.
473 # Picon currently relies on the indiana.edu database.
475 # To enable system wide have in $GITWEB_CONFIG
476 # $feature{'avatar'}{'default'} = ['<provider>'];
477 # where <provider> is either gravatar or picon.
478 # To have project specific config enable override in $GITWEB_CONFIG
479 # $feature{'avatar'}{'override'} = 1;
480 # and in project config gitweb.avatar = <provider>;
482 'sub' => \
&feature_avatar
,
486 # Enable displaying how much time and how many git commands
487 # it took to generate and display page. Disabled by default.
488 # Project specific override is not supported.
493 # Enable turning some links into links to actions which require
494 # JavaScript to run (like 'blame_incremental'). Not enabled by
495 # default. Project specific override is currently not supported.
496 'javascript-actions' => {
500 # Enable and configure ability to change common timezone for dates
501 # in gitweb output via JavaScript. Enabled by default.
502 # Project specific override is not supported.
503 'javascript-timezone' => {
506 'local', # default timezone: 'utc', 'local', or '(-|+)HHMM' format,
507 # or undef to turn off this feature
508 'gitweb_tz', # name of cookie where to store selected timezone
509 'datetime', # CSS class used to mark up dates for manipulation
512 # Syntax highlighting support. This is based on Daniel Svensson's
513 # and Sham Chukoury's work in gitweb-xmms2.git.
514 # It requires the 'highlight' program present in $PATH,
515 # and therefore is disabled by default.
517 # To enable system wide have in $GITWEB_CONFIG
518 # $feature{'highlight'}{'default'} = [1];
521 'sub' => sub { feature_bool
('highlight', @_) },
525 # Enable displaying of remote heads in the heads list
527 # To enable system wide have in $GITWEB_CONFIG
528 # $feature{'remote_heads'}{'default'} = [1];
529 # To have project specific config enable override in $GITWEB_CONFIG
530 # $feature{'remote_heads'}{'override'} = 1;
531 # and in project config gitweb.remote_heads = 0|1;
533 'sub' => sub { feature_bool
('remote_heads', @_) },
538 sub gitweb_get_feature
{
540 return unless exists $feature{$name};
541 my ($sub, $override, @defaults) = (
542 $feature{$name}{'sub'},
543 $feature{$name}{'override'},
544 @
{$feature{$name}{'default'}});
545 # project specific override is possible only if we have project
546 our $git_dir; # global variable, declared later
547 if (!$override || !defined $git_dir) {
551 warn "feature $name is not overridable";
554 return $sub->(@defaults);
557 # A wrapper to check if a given feature is enabled.
558 # With this, you can say
560 # my $bool_feat = gitweb_check_feature('bool_feat');
561 # gitweb_check_feature('bool_feat') or somecode;
565 # my ($bool_feat) = gitweb_get_feature('bool_feat');
566 # (gitweb_get_feature('bool_feat'))[0] or somecode;
568 sub gitweb_check_feature
{
569 return (gitweb_get_feature
(@_))[0];
575 my ($val) = git_get_project_config
($key, '--bool');
579 } elsif ($val eq 'true') {
581 } elsif ($val eq 'false') {
586 sub feature_snapshot
{
589 my ($val) = git_get_project_config
('snapshot');
592 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
598 sub feature_patches
{
599 my @val = (git_get_project_config
('patches', '--int'));
609 my @val = (git_get_project_config
('avatar'));
611 return @val ?
@val : @_;
614 # checking HEAD file with -e is fragile if the repository was
615 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
617 sub check_head_link
{
619 my $headfile = "$dir/HEAD";
620 return ((-e
$headfile) ||
621 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
624 sub check_export_ok
{
626 return (check_head_link
($dir) &&
627 (!$export_ok || -e
"$dir/$export_ok") &&
628 (!$export_auth_hook || $export_auth_hook->($dir)));
631 # process alternate names for backward compatibility
632 # filter out unsupported (unknown) snapshot formats
633 sub filter_snapshot_fmts
{
637 exists $known_snapshot_format_aliases{$_} ?
638 $known_snapshot_format_aliases{$_} : $_} @fmts;
640 exists $known_snapshot_formats{$_} &&
641 !$known_snapshot_formats{$_}{'disabled'}} @fmts;
644 # If it is set to code reference, it is code that it is to be run once per
645 # request, allowing updating configurations that change with each request,
646 # while running other code in config file only once.
648 # Otherwise, if it is false then gitweb would process config file only once;
649 # if it is true then gitweb config would be run for each request.
650 our $per_request_config = 1;
652 # read and parse gitweb config file given by its parameter.
653 # returns true on success, false on recoverable error, allowing
654 # to chain this subroutine, using first file that exists.
655 # dies on errors during parsing config file, as it is unrecoverable.
656 sub read_config_file
{
657 my $filename = shift;
658 return unless defined $filename;
659 # die if there are errors parsing config file
668 our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM, $GITWEB_CONFIG_COMMON);
669 sub evaluate_gitweb_config
{
670 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
671 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
672 our $GITWEB_CONFIG_COMMON = $ENV{'GITWEB_CONFIG_COMMON'} || "++GITWEB_CONFIG_COMMON++";
674 # Protect agains duplications of file names, to not read config twice.
675 # Only one of $GITWEB_CONFIG and $GITWEB_CONFIG_SYSTEM is used, so
676 # there possibility of duplication of filename there doesn't matter.
677 $GITWEB_CONFIG = "" if ($GITWEB_CONFIG eq $GITWEB_CONFIG_COMMON);
678 $GITWEB_CONFIG_SYSTEM = "" if ($GITWEB_CONFIG_SYSTEM eq $GITWEB_CONFIG_COMMON);
680 # Common system-wide settings for convenience.
681 # Those settings can be ovverriden by GITWEB_CONFIG or GITWEB_CONFIG_SYSTEM.
682 read_config_file
($GITWEB_CONFIG_COMMON);
684 # Use first config file that exists. This means use the per-instance
685 # GITWEB_CONFIG if exists, otherwise use GITWEB_SYSTEM_CONFIG.
686 read_config_file
($GITWEB_CONFIG) and return;
687 read_config_file
($GITWEB_CONFIG_SYSTEM);
690 # Get loadavg of system, to compare against $maxload.
691 # Currently it requires '/proc/loadavg' present to get loadavg;
692 # if it is not present it returns 0, which means no load checking.
694 if( -e
'/proc/loadavg' ){
695 open my $fd, '<', '/proc/loadavg'
697 my @load = split(/\s+/, scalar <$fd>);
700 # The first three columns measure CPU and IO utilization of the last one,
701 # five, and 10 minute periods. The fourth column shows the number of
702 # currently running processes and the total number of processes in the m/n
703 # format. The last column displays the last process ID used.
704 return $load[0] || 0;
706 # additional checks for load average should go here for things that don't export
712 # version of the core git binary
714 sub evaluate_git_version
{
715 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
716 $number_of_git_cmds++;
720 if (defined $maxload && get_loadavg
() > $maxload) {
721 die_error
(503, "The load average on the server is too high");
725 # ======================================================================
726 # input validation and dispatch
728 # input parameters can be collected from a variety of sources (presently, CGI
729 # and PATH_INFO), so we define an %input_params hash that collects them all
730 # together during validation: this allows subsequent uses (e.g. href()) to be
731 # agnostic of the parameter origin
733 our %input_params = ();
735 # input parameters are stored with the long parameter name as key. This will
736 # also be used in the href subroutine to convert parameters to their CGI
737 # equivalent, and since the href() usage is the most frequent one, we store
738 # the name -> CGI key mapping here, instead of the reverse.
740 # XXX: Warning: If you touch this, check the search form for updating,
743 our @cgi_param_mapping = (
751 hash_parent_base
=> "hpb",
756 snapshot_format
=> "sf",
757 extra_options
=> "opt",
758 search_use_regexp
=> "sr",
761 # this must be last entry (for manipulation from JavaScript)
764 our %cgi_param_mapping = @cgi_param_mapping;
766 # we will also need to know the possible actions, for validation
768 "blame" => \
&git_blame
,
769 "blame_incremental" => \
&git_blame_incremental
,
770 "blame_data" => \
&git_blame_data
,
771 "blobdiff" => \
&git_blobdiff
,
772 "blobdiff_plain" => \
&git_blobdiff_plain
,
773 "blob" => \
&git_blob
,
774 "blob_plain" => \
&git_blob_plain
,
775 "commitdiff" => \
&git_commitdiff
,
776 "commitdiff_plain" => \
&git_commitdiff_plain
,
777 "commit" => \
&git_commit
,
778 "forks" => \
&git_forks
,
779 "heads" => \
&git_heads
,
780 "history" => \
&git_history
,
782 "patch" => \
&git_patch
,
783 "patches" => \
&git_patches
,
784 "remotes" => \
&git_remotes
,
786 "atom" => \
&git_atom
,
787 "search" => \
&git_search
,
788 "search_help" => \
&git_search_help
,
789 "shortlog" => \
&git_shortlog
,
790 "summary" => \
&git_summary
,
792 "tags" => \
&git_tags
,
793 "tree" => \
&git_tree
,
794 "snapshot" => \
&git_snapshot
,
795 "object" => \
&git_object
,
796 # those below don't need $project
797 "opml" => \
&git_opml
,
798 "project_list" => \
&git_project_list
,
799 "project_index" => \
&git_project_index
,
802 # finally, we have the hash of allowed extra_options for the commands that
804 our %allowed_options = (
805 "--no-merges" => [ qw(rss atom log shortlog history) ],
808 # fill %input_params with the CGI parameters. All values except for 'opt'
809 # should be single values, but opt can be an array. We should probably
810 # build an array of parameters that can be multi-valued, but since for the time
811 # being it's only this one, we just single it out
812 sub evaluate_query_params
{
815 while (my ($name, $symbol) = each %cgi_param_mapping) {
816 if ($symbol eq 'opt') {
817 $input_params{$name} = [ $cgi->param($symbol) ];
819 $input_params{$name} = $cgi->param($symbol);
824 # now read PATH_INFO and update the parameter list for missing parameters
825 sub evaluate_path_info
{
826 return if defined $input_params{'project'};
827 return if !$path_info;
828 $path_info =~ s
,^/+,,;
829 return if !$path_info;
831 # find which part of PATH_INFO is project
832 my $project = $path_info;
834 while ($project && !check_head_link
("$projectroot/$project")) {
835 $project =~ s
,/*[^/]*$,,;
837 return unless $project;
838 $input_params{'project'} = $project;
840 # do not change any parameters if an action is given using the query string
841 return if $input_params{'action'};
842 $path_info =~ s
,^\Q
$project\E
/*,,;
844 # next, check if we have an action
845 my $action = $path_info;
847 if (exists $actions{$action}) {
848 $path_info =~ s
,^$action/*,,;
849 $input_params{'action'} = $action;
852 # list of actions that want hash_base instead of hash, but can have no
853 # pathname (f) parameter
859 # we want to catch, among others
860 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
861 my ($parentrefname, $parentpathname, $refname, $pathname) =
862 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?([^:]+?)?(?::(.+))?$/);
864 # first, analyze the 'current' part
865 if (defined $pathname) {
866 # we got "branch:filename" or "branch:dir/"
867 # we could use git_get_type(branch:pathname), but:
868 # - it needs $git_dir
869 # - it does a git() call
870 # - the convention of terminating directories with a slash
871 # makes it superfluous
872 # - embedding the action in the PATH_INFO would make it even
874 $pathname =~ s
,^/+,,;
875 if (!$pathname || substr($pathname, -1) eq "/") {
876 $input_params{'action'} ||= "tree";
879 # the default action depends on whether we had parent info
881 if ($parentrefname) {
882 $input_params{'action'} ||= "blobdiff_plain";
884 $input_params{'action'} ||= "blob_plain";
887 $input_params{'hash_base'} ||= $refname;
888 $input_params{'file_name'} ||= $pathname;
889 } elsif (defined $refname) {
890 # we got "branch". In this case we have to choose if we have to
891 # set hash or hash_base.
893 # Most of the actions without a pathname only want hash to be
894 # set, except for the ones specified in @wants_base that want
895 # hash_base instead. It should also be noted that hand-crafted
896 # links having 'history' as an action and no pathname or hash
897 # set will fail, but that happens regardless of PATH_INFO.
898 if (defined $parentrefname) {
899 # if there is parent let the default be 'shortlog' action
900 # (for http://git.example.com/repo.git/A..B links); if there
901 # is no parent, dispatch will detect type of object and set
902 # action appropriately if required (if action is not set)
903 $input_params{'action'} ||= "shortlog";
905 if ($input_params{'action'} &&
906 grep { $_ eq $input_params{'action'} } @wants_base) {
907 $input_params{'hash_base'} ||= $refname;
909 $input_params{'hash'} ||= $refname;
913 # next, handle the 'parent' part, if present
914 if (defined $parentrefname) {
915 # a missing pathspec defaults to the 'current' filename, allowing e.g.
916 # someproject/blobdiff/oldrev..newrev:/filename
917 if ($parentpathname) {
918 $parentpathname =~ s
,^/+,,;
919 $parentpathname =~ s
,/$,,;
920 $input_params{'file_parent'} ||= $parentpathname;
922 $input_params{'file_parent'} ||= $input_params{'file_name'};
924 # we assume that hash_parent_base is wanted if a path was specified,
925 # or if the action wants hash_base instead of hash
926 if (defined $input_params{'file_parent'} ||
927 grep { $_ eq $input_params{'action'} } @wants_base) {
928 $input_params{'hash_parent_base'} ||= $parentrefname;
930 $input_params{'hash_parent'} ||= $parentrefname;
934 # for the snapshot action, we allow URLs in the form
935 # $project/snapshot/$hash.ext
936 # where .ext determines the snapshot and gets removed from the
937 # passed $refname to provide the $hash.
939 # To be able to tell that $refname includes the format extension, we
940 # require the following two conditions to be satisfied:
941 # - the hash input parameter MUST have been set from the $refname part
942 # of the URL (i.e. they must be equal)
943 # - the snapshot format MUST NOT have been defined already (e.g. from
945 # It's also useless to try any matching unless $refname has a dot,
946 # so we check for that too
947 if (defined $input_params{'action'} &&
948 $input_params{'action'} eq 'snapshot' &&
949 defined $refname && index($refname, '.') != -1 &&
950 $refname eq $input_params{'hash'} &&
951 !defined $input_params{'snapshot_format'}) {
952 # We loop over the known snapshot formats, checking for
953 # extensions. Allowed extensions are both the defined suffix
954 # (which includes the initial dot already) and the snapshot
955 # format key itself, with a prepended dot
956 while (my ($fmt, $opt) = each %known_snapshot_formats) {
958 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
962 # a valid suffix was found, so set the snapshot format
963 # and reset the hash parameter
964 $input_params{'snapshot_format'} = $fmt;
965 $input_params{'hash'} = $hash;
966 # we also set the format suffix to the one requested
967 # in the URL: this way a request for e.g. .tgz returns
968 # a .tgz instead of a .tar.gz
969 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
975 our ($action, $project, $file_name, $file_parent, $hash, $hash_parent, $hash_base,
976 $hash_parent_base, @extra_options, $page, $searchtype, $search_use_regexp,
977 $searchtext, $search_regexp);
978 sub evaluate_and_validate_params
{
979 our $action = $input_params{'action'};
980 if (defined $action) {
981 if (!validate_action
($action)) {
982 die_error
(400, "Invalid action parameter");
986 # parameters which are pathnames
987 our $project = $input_params{'project'};
988 if (defined $project) {
989 if (!validate_project
($project)) {
991 die_error
(404, "No such project");
995 our $file_name = $input_params{'file_name'};
996 if (defined $file_name) {
997 if (!validate_pathname
($file_name)) {
998 die_error
(400, "Invalid file parameter");
1002 our $file_parent = $input_params{'file_parent'};
1003 if (defined $file_parent) {
1004 if (!validate_pathname
($file_parent)) {
1005 die_error
(400, "Invalid file parent parameter");
1009 # parameters which are refnames
1010 our $hash = $input_params{'hash'};
1011 if (defined $hash) {
1012 if (!validate_refname
($hash)) {
1013 die_error
(400, "Invalid hash parameter");
1017 our $hash_parent = $input_params{'hash_parent'};
1018 if (defined $hash_parent) {
1019 if (!validate_refname
($hash_parent)) {
1020 die_error
(400, "Invalid hash parent parameter");
1024 our $hash_base = $input_params{'hash_base'};
1025 if (defined $hash_base) {
1026 if (!validate_refname
($hash_base)) {
1027 die_error
(400, "Invalid hash base parameter");
1031 our @extra_options = @
{$input_params{'extra_options'}};
1032 # @extra_options is always defined, since it can only be (currently) set from
1033 # CGI, and $cgi->param() returns the empty array in array context if the param
1035 foreach my $opt (@extra_options) {
1036 if (not exists $allowed_options{$opt}) {
1037 die_error
(400, "Invalid option parameter");
1039 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
1040 die_error
(400, "Invalid option parameter for this action");
1044 our $hash_parent_base = $input_params{'hash_parent_base'};
1045 if (defined $hash_parent_base) {
1046 if (!validate_refname
($hash_parent_base)) {
1047 die_error
(400, "Invalid hash parent base parameter");
1052 our $page = $input_params{'page'};
1053 if (defined $page) {
1054 if ($page =~ m/[^0-9]/) {
1055 die_error
(400, "Invalid page parameter");
1059 our $searchtype = $input_params{'searchtype'};
1060 if (defined $searchtype) {
1061 if ($searchtype =~ m/[^a-z]/) {
1062 die_error
(400, "Invalid searchtype parameter");
1066 our $search_use_regexp = $input_params{'search_use_regexp'};
1068 our $searchtext = $input_params{'searchtext'};
1070 if (defined $searchtext) {
1071 if (length($searchtext) < 2) {
1072 die_error
(403, "At least two characters are required for search parameter");
1074 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
1077 $input_params{diff_style
} ||= 'inline';
1080 # path to the current git repository
1082 sub evaluate_git_dir
{
1083 our $git_dir = "$projectroot/$project" if $project;
1086 our (@snapshot_fmts, $git_avatar);
1087 sub configure_gitweb_features
{
1088 # list of supported snapshot formats
1089 our @snapshot_fmts = gitweb_get_feature
('snapshot');
1090 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1092 # check that the avatar feature is set to a known provider name,
1093 # and for each provider check if the dependencies are satisfied.
1094 # if the provider name is invalid or the dependencies are not met,
1095 # reset $git_avatar to the empty string.
1096 our ($git_avatar) = gitweb_get_feature
('avatar');
1097 if ($git_avatar eq 'gravatar') {
1098 $git_avatar = '' unless (eval { require Digest
::MD5
; 1; });
1099 } elsif ($git_avatar eq 'picon') {
1106 # custom error handler: 'die <message>' is Internal Server Error
1107 sub handle_errors_html
{
1108 my $msg = shift; # it is already HTML escaped
1110 # to avoid infinite loop where error occurs in die_error,
1111 # change handler to default handler, disabling handle_errors_html
1112 set_message
("Error occured when inside die_error:\n$msg");
1114 # you cannot jump out of die_error when called as error handler;
1115 # the subroutine set via CGI::Carp::set_message is called _after_
1116 # HTTP headers are already written, so it cannot write them itself
1117 die_error
(undef, undef, $msg, -error_handler
=> 1, -no_http_header
=> 1);
1119 set_message
(\
&handle_errors_html
);
1123 if (!defined $action) {
1124 if (defined $hash) {
1125 $action = git_get_type
($hash);
1126 } elsif (defined $hash_base && defined $file_name) {
1127 $action = git_get_type
("$hash_base:$file_name");
1128 } elsif (defined $project) {
1129 $action = 'summary';
1131 $action = 'project_list';
1134 if (!defined($actions{$action})) {
1135 die_error
(400, "Unknown action");
1137 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1139 die_error
(400, "Project needed");
1141 $actions{$action}->();
1145 our $t0 = [ gettimeofday
() ]
1147 our $number_of_git_cmds = 0;
1150 our $first_request = 1;
1155 if ($first_request) {
1156 evaluate_gitweb_config
();
1157 evaluate_git_version
();
1159 if ($per_request_config) {
1160 if (ref($per_request_config) eq 'CODE') {
1161 $per_request_config->();
1162 } elsif (!$first_request) {
1163 evaluate_gitweb_config
();
1168 # $projectroot and $projects_list might be set in gitweb config file
1169 $projects_list ||= $projectroot;
1171 evaluate_query_params
();
1172 evaluate_path_info
();
1173 evaluate_and_validate_params
();
1176 configure_gitweb_features
();
1181 our $is_last_request = sub { 1 };
1182 our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1185 sub configure_as_fcgi
{
1187 our $CGI = 'CGI::Fast';
1189 my $request_number = 0;
1190 # let each child service 100 requests
1191 our $is_last_request = sub { ++$request_number > 100 };
1194 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__
;
1196 if $script_name =~ /\.fcgi$/;
1198 return unless (@ARGV);
1200 require Getopt
::Long
;
1201 Getopt
::Long
::GetOptions
(
1202 'fastcgi|fcgi|f' => \
&configure_as_fcgi
,
1203 'nproc|n=i' => sub {
1204 my ($arg, $val) = @_;
1205 return unless eval { require FCGI
::ProcManager
; 1; };
1206 my $proc_manager = FCGI
::ProcManager
->new({
1207 n_processes
=> $val,
1209 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1210 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1211 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1220 $pre_listen_hook->()
1221 if $pre_listen_hook;
1224 while ($cgi = $CGI->new()) {
1225 $pre_dispatch_hook->()
1226 if $pre_dispatch_hook;
1230 $post_dispatch_hook->()
1231 if $post_dispatch_hook;
1234 last REQUEST
if ($is_last_request->());
1243 if (defined caller) {
1244 # wrapped in a subroutine processing requests,
1245 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1248 # pure CGI script, serving single request
1252 ## ======================================================================
1255 # possible values of extra options
1256 # -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1257 # -replay => 1 - start from a current view (replay with modifications)
1258 # -path_info => 0|1 - don't use/use path_info URL (if possible)
1259 # -anchor => ANCHOR - add #ANCHOR to end of URL, implies -replay if used alone
1262 # default is to use -absolute url() i.e. $my_uri
1263 my $href = $params{-full
} ?
$my_url : $my_uri;
1265 # implicit -replay, must be first of implicit params
1266 $params{-replay
} = 1 if (keys %params == 1 && $params{-anchor
});
1268 $params{'project'} = $project unless exists $params{'project'};
1270 if ($params{-replay
}) {
1271 while (my ($name, $symbol) = each %cgi_param_mapping) {
1272 if (!exists $params{$name}) {
1273 $params{$name} = $input_params{$name};
1278 my $use_pathinfo = gitweb_check_feature
('pathinfo');
1279 if (defined $params{'project'} &&
1280 (exists $params{-path_info
} ?
$params{-path_info
} : $use_pathinfo)) {
1281 # try to put as many parameters as possible in PATH_INFO:
1284 # - hash_parent or hash_parent_base:/file_parent
1285 # - hash or hash_base:/filename
1286 # - the snapshot_format as an appropriate suffix
1288 # When the script is the root DirectoryIndex for the domain,
1289 # $href here would be something like http://gitweb.example.com/
1290 # Thus, we strip any trailing / from $href, to spare us double
1291 # slashes in the final URL
1294 # Then add the project name, if present
1295 $href .= "/".esc_path_info
($params{'project'});
1296 delete $params{'project'};
1298 # since we destructively absorb parameters, we keep this
1299 # boolean that remembers if we're handling a snapshot
1300 my $is_snapshot = $params{'action'} eq 'snapshot';
1302 # Summary just uses the project path URL, any other action is
1304 if (defined $params{'action'}) {
1305 $href .= "/".esc_path_info
($params{'action'})
1306 unless $params{'action'} eq 'summary';
1307 delete $params{'action'};
1310 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1311 # stripping nonexistent or useless pieces
1312 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1313 || $params{'hash_parent'} || $params{'hash'});
1314 if (defined $params{'hash_base'}) {
1315 if (defined $params{'hash_parent_base'}) {
1316 $href .= esc_path_info
($params{'hash_parent_base'});
1317 # skip the file_parent if it's the same as the file_name
1318 if (defined $params{'file_parent'}) {
1319 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1320 delete $params{'file_parent'};
1321 } elsif ($params{'file_parent'} !~ /\.\./) {
1322 $href .= ":/".esc_path_info
($params{'file_parent'});
1323 delete $params{'file_parent'};
1327 delete $params{'hash_parent'};
1328 delete $params{'hash_parent_base'};
1329 } elsif (defined $params{'hash_parent'}) {
1330 $href .= esc_path_info
($params{'hash_parent'}). "..";
1331 delete $params{'hash_parent'};
1334 $href .= esc_path_info
($params{'hash_base'});
1335 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
1336 $href .= ":/".esc_path_info
($params{'file_name'});
1337 delete $params{'file_name'};
1339 delete $params{'hash'};
1340 delete $params{'hash_base'};
1341 } elsif (defined $params{'hash'}) {
1342 $href .= esc_path_info
($params{'hash'});
1343 delete $params{'hash'};
1346 # If the action was a snapshot, we can absorb the
1347 # snapshot_format parameter too
1349 my $fmt = $params{'snapshot_format'};
1350 # snapshot_format should always be defined when href()
1351 # is called, but just in case some code forgets, we
1352 # fall back to the default
1353 $fmt ||= $snapshot_fmts[0];
1354 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1355 delete $params{'snapshot_format'};
1359 # now encode the parameters explicitly
1361 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1362 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
1363 if (defined $params{$name}) {
1364 if (ref($params{$name}) eq "ARRAY") {
1365 foreach my $par (@
{$params{$name}}) {
1366 push @result, $symbol . "=" . esc_param
($par);
1369 push @result, $symbol . "=" . esc_param
($params{$name});
1373 $href .= "?" . join(';', @result) if scalar @result;
1375 # final transformation: trailing spaces must be escaped (URI-encoded)
1376 $href =~ s/(\s+)$/CGI::escape($1)/e;
1378 if ($params{-anchor
}) {
1379 $href .= "#".esc_param
($params{-anchor
});
1386 ## ======================================================================
1387 ## validation, quoting/unquoting and escaping
1389 sub validate_action
{
1390 my $input = shift || return undef;
1391 return undef unless exists $actions{$input};
1395 sub validate_project
{
1396 my $input = shift || return undef;
1397 if (!validate_pathname
($input) ||
1398 !(-d
"$projectroot/$input") ||
1399 !check_export_ok
("$projectroot/$input") ||
1400 ($strict_export && !project_in_list
($input))) {
1407 sub validate_pathname
{
1408 my $input = shift || return undef;
1410 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1411 # at the beginning, at the end, and between slashes.
1412 # also this catches doubled slashes
1413 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1416 # no null characters
1417 if ($input =~ m!\0!) {
1423 sub validate_refname
{
1424 my $input = shift || return undef;
1426 # textual hashes are O.K.
1427 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1430 # it must be correct pathname
1431 $input = validate_pathname
($input)
1433 # restrictions on ref name according to git-check-ref-format
1434 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1440 # decode sequences of octets in utf8 into Perl's internal form,
1441 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1442 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1445 return undef unless defined $str;
1446 if (utf8
::valid
($str)) {
1450 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
1454 # quote unsafe chars, but keep the slash, even when it's not
1455 # correct, but quoted slashes look too horrible in bookmarks
1458 return undef unless defined $str;
1459 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI
::escape
($1)/eg
;
1464 # the quoting rules for path_info fragment are slightly different
1467 return undef unless defined $str;
1469 # path_info doesn't treat '+' as space (specially), but '?' must be escaped
1470 $str =~ s/([^A-Za-z0-9\-_.~();\/;:@&= +]+)/CGI
::escape
($1)/eg
;
1475 # quote unsafe chars in whole URL, so some characters cannot be quoted
1478 return undef unless defined $str;
1479 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI
::escape
($1)/eg
;
1484 # quote unsafe characters in HTML attributes
1487 # for XHTML conformance escaping '"' to '"' is not enough
1488 return esc_html
(@_);
1491 # replace invalid utf8 character with SUBSTITUTION sequence
1496 return undef unless defined $str;
1498 $str = to_utf8
($str);
1499 $str = $cgi->escapeHTML($str);
1500 if ($opts{'-nbsp'}) {
1501 $str =~ s/ / /g;
1503 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1507 # quote control characters and escape filename to HTML
1512 return undef unless defined $str;
1514 $str = to_utf8
($str);
1515 $str = $cgi->escapeHTML($str);
1516 if ($opts{'-nbsp'}) {
1517 $str =~ s/ / /g;
1519 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1523 # Sanitize for use in XHTML + application/xml+xhtm (valid XML 1.0)
1527 return undef unless defined $str;
1529 $str = to_utf8
($str);
1530 $str =~ s
|([[:cntrl
:]])|($1 =~ /[\t\n\r]/ ?
$1 : quot_cec
($1))|eg
;
1534 # Make control characters "printable", using character escape codes (CEC)
1538 my %es = ( # character escape codes, aka escape sequences
1539 "\t" => '\t', # tab (HT)
1540 "\n" => '\n', # line feed (LF)
1541 "\r" => '\r', # carrige return (CR)
1542 "\f" => '\f', # form feed (FF)
1543 "\b" => '\b', # backspace (BS)
1544 "\a" => '\a', # alarm (bell) (BEL)
1545 "\e" => '\e', # escape (ESC)
1546 "\013" => '\v', # vertical tab (VT)
1547 "\000" => '\0', # nul character (NUL)
1549 my $chr = ( (exists $es{$cntrl})
1551 : sprintf('\%2x', ord($cntrl)) );
1552 if ($opts{-nohtml
}) {
1555 return "<span class=\"cntrl\">$chr</span>";
1559 # Alternatively use unicode control pictures codepoints,
1560 # Unicode "printable representation" (PR)
1565 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1566 if ($opts{-nohtml
}) {
1569 return "<span class=\"cntrl\">$chr</span>";
1573 # git may return quoted and escaped filenames
1579 my %es = ( # character escape codes, aka escape sequences
1580 't' => "\t", # tab (HT, TAB)
1581 'n' => "\n", # newline (NL)
1582 'r' => "\r", # return (CR)
1583 'f' => "\f", # form feed (FF)
1584 'b' => "\b", # backspace (BS)
1585 'a' => "\a", # alarm (bell) (BEL)
1586 'e' => "\e", # escape (ESC)
1587 'v' => "\013", # vertical tab (VT)
1590 if ($seq =~ m/^[0-7]{1,3}$/) {
1591 # octal char sequence
1592 return chr(oct($seq));
1593 } elsif (exists $es{$seq}) {
1594 # C escape sequence, aka character escape code
1597 # quoted ordinary character
1601 if ($str =~ m/^"(.*)"$/) {
1604 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1609 # escape tabs (convert tabs to spaces)
1613 while ((my $pos = index($line, "\t")) != -1) {
1614 if (my $count = (8 - ($pos % 8))) {
1615 my $spaces = ' ' x
$count;
1616 $line =~ s/\t/$spaces/;
1623 sub project_in_list
{
1624 my $project = shift;
1625 my @list = git_get_projects_list
();
1626 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1629 ## ----------------------------------------------------------------------
1630 ## HTML aware string manipulation
1632 # Try to chop given string on a word boundary between position
1633 # $len and $len+$add_len. If there is no word boundary there,
1634 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1635 # (marking chopped part) would be longer than given string.
1639 my $add_len = shift || 10;
1640 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1642 # Make sure perl knows it is utf8 encoded so we don't
1643 # cut in the middle of a utf8 multibyte char.
1644 $str = to_utf8
($str);
1646 # allow only $len chars, but don't cut a word if it would fit in $add_len
1647 # if it doesn't fit, cut it if it's still longer than the dots we would add
1648 # remove chopped character entities entirely
1650 # when chopping in the middle, distribute $len into left and right part
1651 # return early if chopping wouldn't make string shorter
1652 if ($where eq 'center') {
1653 return $str if ($len + 5 >= length($str)); # filler is length 5
1656 return $str if ($len + 4 >= length($str)); # filler is length 4
1659 # regexps: ending and beginning with word part up to $add_len
1660 my $endre = qr/.{$len}\w{0,$add_len}/;
1661 my $begre = qr/\w{0,$add_len}.{$len}/;
1663 if ($where eq 'left') {
1664 $str =~ m/^(.*?)($begre)$/;
1665 my ($lead, $body) = ($1, $2);
1666 if (length($lead) > 4) {
1669 return "$lead$body";
1671 } elsif ($where eq 'center') {
1672 $str =~ m/^($endre)(.*)$/;
1673 my ($left, $str) = ($1, $2);
1674 $str =~ m/^(.*?)($begre)$/;
1675 my ($mid, $right) = ($1, $2);
1676 if (length($mid) > 5) {
1679 return "$left$mid$right";
1682 $str =~ m/^($endre)(.*)$/;
1685 if (length($tail) > 4) {
1688 return "$body$tail";
1692 # takes the same arguments as chop_str, but also wraps a <span> around the
1693 # result with a title attribute if it does get chopped. Additionally, the
1694 # string is HTML-escaped.
1695 sub chop_and_escape_str
{
1698 my $chopped = chop_str
(@_);
1699 if ($chopped eq $str) {
1700 return esc_html
($chopped);
1702 $str =~ s/[[:cntrl:]]/?/g;
1703 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1707 ## ----------------------------------------------------------------------
1708 ## functions returning short strings
1710 # CSS class for given age value (in seconds)
1714 if (!defined $age) {
1716 } elsif ($age < 60*60*2) {
1718 } elsif ($age < 60*60*24*2) {
1725 # convert age in seconds to "nn units ago" string
1730 if ($age > 60*60*24*365*2) {
1731 $age_str = (int $age/60/60/24/365);
1732 $age_str .= " years ago";
1733 } elsif ($age > 60*60*24*(365/12)*2) {
1734 $age_str = int $age/60/60/24/(365/12);
1735 $age_str .= " months ago";
1736 } elsif ($age > 60*60*24*7*2) {
1737 $age_str = int $age/60/60/24/7;
1738 $age_str .= " weeks ago";
1739 } elsif ($age > 60*60*24*2) {
1740 $age_str = int $age/60/60/24;
1741 $age_str .= " days ago";
1742 } elsif ($age > 60*60*2) {
1743 $age_str = int $age/60/60;
1744 $age_str .= " hours ago";
1745 } elsif ($age > 60*2) {
1746 $age_str = int $age/60;
1747 $age_str .= " min ago";
1748 } elsif ($age > 2) {
1749 $age_str = int $age;
1750 $age_str .= " sec ago";
1752 $age_str .= " right now";
1758 S_IFINVALID
=> 0030000,
1759 S_IFGITLINK
=> 0160000,
1762 # submodule/subproject, a commit object reference
1766 return (($mode & S_IFMT
) == S_IFGITLINK
)
1769 # convert file mode in octal to symbolic file mode string
1771 my $mode = oct shift;
1773 if (S_ISGITLINK
($mode)) {
1774 return 'm---------';
1775 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1776 return 'drwxr-xr-x';
1777 } elsif (S_ISLNK
($mode)) {
1778 return 'lrwxrwxrwx';
1779 } elsif (S_ISREG
($mode)) {
1780 # git cares only about the executable bit
1781 if ($mode & S_IXUSR
) {
1782 return '-rwxr-xr-x';
1784 return '-rw-r--r--';
1787 return '----------';
1791 # convert file mode in octal to file type string
1795 if ($mode !~ m/^[0-7]+$/) {
1801 if (S_ISGITLINK
($mode)) {
1803 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1805 } elsif (S_ISLNK
($mode)) {
1807 } elsif (S_ISREG
($mode)) {
1814 # convert file mode in octal to file type description string
1815 sub file_type_long
{
1818 if ($mode !~ m/^[0-7]+$/) {
1824 if (S_ISGITLINK
($mode)) {
1826 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1828 } elsif (S_ISLNK
($mode)) {
1830 } elsif (S_ISREG
($mode)) {
1831 if ($mode & S_IXUSR
) {
1832 return "executable";
1842 ## ----------------------------------------------------------------------
1843 ## functions returning short HTML fragments, or transforming HTML fragments
1844 ## which don't belong to other sections
1846 # format line of commit message.
1847 sub format_log_line_html
{
1850 $line = esc_html
($line, -nbsp
=>1);
1851 $line =~ s
{\b([0-9a
-fA
-F
]{8,40})\b}{
1852 $cgi->a({-href
=> href
(action
=>"object", hash
=>$1),
1853 -class => "text"}, $1);
1859 # format marker of refs pointing to given object
1861 # the destination action is chosen based on object type and current context:
1862 # - for annotated tags, we choose the tag view unless it's the current view
1863 # already, in which case we go to shortlog view
1864 # - for other refs, we keep the current view if we're in history, shortlog or
1865 # log view, and select shortlog otherwise
1866 sub format_ref_marker
{
1867 my ($refs, $id) = @_;
1870 if (defined $refs->{$id}) {
1871 foreach my $ref (@
{$refs->{$id}}) {
1872 # this code exploits the fact that non-lightweight tags are the
1873 # only indirect objects, and that they are the only objects for which
1874 # we want to use tag instead of shortlog as action
1875 my ($type, $name) = qw();
1876 my $indirect = ($ref =~ s/\^\{\}$//);
1877 # e.g. tags/v2.6.11 or heads/next
1878 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1887 $class .= " indirect" if $indirect;
1889 my $dest_action = "shortlog";
1892 $dest_action = "tag" unless $action eq "tag";
1893 } elsif ($action =~ /^(history|(short)?log)$/) {
1894 $dest_action = $action;
1898 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1901 my $link = $cgi->a({
1903 action
=>$dest_action,
1907 $markers .= " <span class=\"".esc_attr
($class)."\" title=\"".esc_attr
($ref)."\">" .
1913 return ' <span class="refs">'. $markers . '</span>';
1919 # format, perhaps shortened and with markers, title line
1920 sub format_subject_html
{
1921 my ($long, $short, $href, $extra) = @_;
1922 $extra = '' unless defined($extra);
1924 if (length($short) < length($long)) {
1925 $long =~ s/[[:cntrl:]]/?/g;
1926 return $cgi->a({-href
=> $href, -class => "list subject",
1927 -title
=> to_utf8
($long)},
1928 esc_html
($short)) . $extra;
1930 return $cgi->a({-href
=> $href, -class => "list subject"},
1931 esc_html
($long)) . $extra;
1935 # Rather than recomputing the url for an email multiple times, we cache it
1936 # after the first hit. This gives a visible benefit in views where the avatar
1937 # for the same email is used repeatedly (e.g. shortlog).
1938 # The cache is shared by all avatar engines (currently gravatar only), which
1939 # are free to use it as preferred. Since only one avatar engine is used for any
1940 # given page, there's no risk for cache conflicts.
1941 our %avatar_cache = ();
1943 # Compute the picon url for a given email, by using the picon search service over at
1944 # http://www.cs.indiana.edu/picons/search.html
1946 my $email = lc shift;
1947 if (!$avatar_cache{$email}) {
1948 my ($user, $domain) = split('@', $email);
1949 $avatar_cache{$email} =
1950 "http://www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
1952 "users+domains+unknown/up/single";
1954 return $avatar_cache{$email};
1957 # Compute the gravatar url for a given email, if it's not in the cache already.
1958 # Gravatar stores only the part of the URL before the size, since that's the
1959 # one computationally more expensive. This also allows reuse of the cache for
1960 # different sizes (for this particular engine).
1962 my $email = lc shift;
1964 $avatar_cache{$email} ||=
1965 "http://www.gravatar.com/avatar/" .
1966 Digest
::MD5
::md5_hex
($email) . "?s=";
1967 return $avatar_cache{$email} . $size;
1970 # Insert an avatar for the given $email at the given $size if the feature
1972 sub git_get_avatar
{
1973 my ($email, %opts) = @_;
1974 my $pre_white = ($opts{-pad_before
} ?
" " : "");
1975 my $post_white = ($opts{-pad_after
} ?
" " : "");
1976 $opts{-size
} ||= 'default';
1977 my $size = $avatar_size{$opts{-size
}} || $avatar_size{'default'};
1979 if ($git_avatar eq 'gravatar') {
1980 $url = gravatar_url
($email, $size);
1981 } elsif ($git_avatar eq 'picon') {
1982 $url = picon_url
($email);
1984 # Other providers can be added by extending the if chain, defining $url
1985 # as needed. If no variant puts something in $url, we assume avatars
1986 # are completely disabled/unavailable.
1989 "<img width=\"$size\" " .
1990 "class=\"avatar\" " .
1991 "src=\"".esc_url
($url)."\" " .
1999 sub format_search_author
{
2000 my ($author, $searchtype, $displaytext) = @_;
2001 my $have_search = gitweb_check_feature
('search');
2005 if ($searchtype eq 'author') {
2006 $performed = "authored";
2007 } elsif ($searchtype eq 'committer') {
2008 $performed = "committed";
2011 return $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
2012 searchtext
=>$author,
2013 searchtype
=>$searchtype), class=>"list",
2014 title
=>"Search for commits $performed by $author"},
2018 return $displaytext;
2022 # format the author name of the given commit with the given tag
2023 # the author name is chopped and escaped according to the other
2024 # optional parameters (see chop_str).
2025 sub format_author_html
{
2028 my $author = chop_and_escape_str
($co->{'author_name'}, @_);
2029 return "<$tag class=\"author\">" .
2030 format_search_author
($co->{'author_name'}, "author",
2031 git_get_avatar
($co->{'author_email'}, -pad_after
=> 1) .
2036 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
2037 sub format_git_diff_header_line
{
2039 my $diffinfo = shift;
2040 my ($from, $to) = @_;
2042 if ($diffinfo->{'nparents'}) {
2044 $line =~ s!^(diff (.*?) )"?.*$!$1!;
2045 if ($to->{'href'}) {
2046 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2047 esc_path
($to->{'file'}));
2048 } else { # file was deleted (no href)
2049 $line .= esc_path
($to->{'file'});
2053 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
2054 if ($from->{'href'}) {
2055 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
2056 'a/' . esc_path
($from->{'file'}));
2057 } else { # file was added (no href)
2058 $line .= 'a/' . esc_path
($from->{'file'});
2061 if ($to->{'href'}) {
2062 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
2063 'b/' . esc_path
($to->{'file'}));
2064 } else { # file was deleted
2065 $line .= 'b/' . esc_path
($to->{'file'});
2069 return "<div class=\"diff header\">$line</div>\n";
2072 # format extended diff header line, before patch itself
2073 sub format_extended_diff_header_line
{
2075 my $diffinfo = shift;
2076 my ($from, $to) = @_;
2079 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
2080 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2081 esc_path
($from->{'file'}));
2083 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
2084 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2085 esc_path
($to->{'file'}));
2087 # match single <mode>
2088 if ($line =~ m/\s(\d{6})$/) {
2089 $line .= '<span class="info"> (' .
2090 file_type_long
($1) .
2094 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
2095 # can match only for combined diff
2097 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2098 if ($from->{'href'}[$i]) {
2099 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
2101 substr($diffinfo->{'from_id'}[$i],0,7));
2106 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
2109 if ($to->{'href'}) {
2110 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2111 substr($diffinfo->{'to_id'},0,7));
2116 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
2117 # can match only for ordinary diff
2118 my ($from_link, $to_link);
2119 if ($from->{'href'}) {
2120 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
2121 substr($diffinfo->{'from_id'},0,7));
2123 $from_link = '0' x
7;
2125 if ($to->{'href'}) {
2126 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
2127 substr($diffinfo->{'to_id'},0,7));
2131 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2132 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2135 return $line . "<br/>\n";
2138 # format from-file/to-file diff header
2139 sub format_diff_from_to_header
{
2140 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
2145 #assert($line =~ m/^---/) if DEBUG;
2146 # no extra formatting for "^--- /dev/null"
2147 if (! $diffinfo->{'nparents'}) {
2148 # ordinary (single parent) diff
2149 if ($line =~ m!^--- "?a/!) {
2150 if ($from->{'href'}) {
2152 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
2153 esc_path
($from->{'file'}));
2156 esc_path
($from->{'file'});
2159 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2162 # combined diff (merge commit)
2163 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2164 if ($from->{'href'}[$i]) {
2166 $cgi->a({-href
=>href
(action
=>"blobdiff",
2167 hash_parent
=>$diffinfo->{'from_id'}[$i],
2168 hash_parent_base
=>$parents[$i],
2169 file_parent
=>$from->{'file'}[$i],
2170 hash
=>$diffinfo->{'to_id'},
2172 file_name
=>$to->{'file'}),
2174 -title
=>"diff" . ($i+1)},
2177 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
2178 esc_path
($from->{'file'}[$i]));
2180 $line = '--- /dev/null';
2182 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
2187 #assert($line =~ m/^\+\+\+/) if DEBUG;
2188 # no extra formatting for "^+++ /dev/null"
2189 if ($line =~ m!^\+\+\+ "?b/!) {
2190 if ($to->{'href'}) {
2192 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
2193 esc_path
($to->{'file'}));
2196 esc_path
($to->{'file'});
2199 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
2204 # create note for patch simplified by combined diff
2205 sub format_diff_cc_simplified
{
2206 my ($diffinfo, @parents) = @_;
2209 $result .= "<div class=\"diff header\">" .
2211 if (!is_deleted
($diffinfo)) {
2212 $result .= $cgi->a({-href
=> href
(action
=>"blob",
2214 hash
=>$diffinfo->{'to_id'},
2215 file_name
=>$diffinfo->{'to_file'}),
2217 esc_path
($diffinfo->{'to_file'}));
2219 $result .= esc_path
($diffinfo->{'to_file'});
2221 $result .= "</div>\n" . # class="diff header"
2222 "<div class=\"diff nodifferences\">" .
2224 "</div>\n"; # class="diff nodifferences"
2229 sub diff_line_class
{
2230 my ($line, $from, $to) = @_;
2235 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2236 $num_sign = scalar @
{$from->{'href'}};
2239 my @diff_line_classifier = (
2240 { regexp
=> qr/^\@\@{$num_sign} /, class => "chunk_header"},
2241 { regexp
=> qr/^\\/, class => "incomplete" },
2242 { regexp
=> qr/^ {$num_sign}/, class => "ctx" },
2243 # classifier for context must come before classifier add/rem,
2244 # or we would have to use more complicated regexp, for example
2245 # qr/(?= {0,$m}\+)[+ ]{$num_sign}/, where $m = $num_sign - 1;
2246 { regexp
=> qr/^[+ ]{$num_sign}/, class => "add" },
2247 { regexp
=> qr/^[- ]{$num_sign}/, class => "rem" },
2249 for my $clsfy (@diff_line_classifier) {
2250 return $clsfy->{'class'}
2251 if ($line =~ $clsfy->{'regexp'});
2258 # format patch (diff) line (not to be used for diff headers)
2259 sub process_diff_line
{
2261 my ($from, $to) = @_;
2263 my $diff_class = diff_line_class
($line, $from, $to);
2264 my $diff_classes = "diff";
2265 $diff_classes .= " $diff_class" if ($diff_class);
2268 $line = untabify
($line);
2270 if ($from && $to && $line =~ m/^\@{2} /) {
2271 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2272 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2274 $from_lines = 0 unless defined $from_lines;
2275 $to_lines = 0 unless defined $to_lines;
2277 if ($from->{'href'}) {
2278 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
2279 -class=>"list"}, $from_text);
2281 if ($to->{'href'}) {
2282 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2283 -class=>"list"}, $to_text);
2285 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2286 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2287 return $diff_class, "<div class=\"$diff_classes\">$line</div>\n";
2288 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2289 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2290 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2292 @from_text = split(' ', $ranges);
2293 for (my $i = 0; $i < @from_text; ++$i) {
2294 ($from_start[$i], $from_nlines[$i]) =
2295 (split(',', substr($from_text[$i], 1)), 0);
2298 $to_text = pop @from_text;
2299 $to_start = pop @from_start;
2300 $to_nlines = pop @from_nlines;
2302 $line = "<span class=\"chunk_info\">$prefix ";
2303 for (my $i = 0; $i < @from_text; ++$i) {
2304 if ($from->{'href'}[$i]) {
2305 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
2306 -class=>"list"}, $from_text[$i]);
2308 $line .= $from_text[$i];
2312 if ($to->{'href'}) {
2313 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
2314 -class=>"list"}, $to_text);
2318 $line .= " $prefix</span>" .
2319 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
2320 return $diff_class, "<div class=\"$diff_classes\">$line</div>\n";
2322 return $diff_class, "<div class=\"$diff_classes\">" . esc_html
($line, -nbsp
=>1) . "</div>\n";
2325 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2326 # linked. Pass the hash of the tree/commit to snapshot.
2327 sub format_snapshot_links
{
2329 my $num_fmts = @snapshot_fmts;
2330 if ($num_fmts > 1) {
2331 # A parenthesized list of links bearing format names.
2332 # e.g. "snapshot (_tar.gz_ _zip_)"
2333 return "snapshot (" . join(' ', map
2340 }, $known_snapshot_formats{$_}{'display'})
2341 , @snapshot_fmts) . ")";
2342 } elsif ($num_fmts == 1) {
2343 # A single "snapshot" link whose tooltip bears the format name.
2345 my ($fmt) = @snapshot_fmts;
2351 snapshot_format
=>$fmt
2353 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
2355 } else { # $num_fmts == 0
2360 ## ......................................................................
2361 ## functions returning values to be passed, perhaps after some
2362 ## transformation, to other functions; e.g. returning arguments to href()
2364 # returns hash to be passed to href to generate gitweb URL
2365 # in -title key it returns description of link
2367 my $format = shift || 'Atom';
2368 my %res = (action
=> lc($format));
2370 # feed links are possible only for project views
2371 return unless (defined $project);
2372 # some views should link to OPML, or to generic project feed,
2373 # or don't have specific feed yet (so they should use generic)
2374 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
2377 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
2378 # from tag links; this also makes possible to detect branch links
2379 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
2380 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
2383 # find log type for feed description (title)
2385 if (defined $file_name) {
2386 $type = "history of $file_name";
2387 $type .= "/" if ($action eq 'tree');
2388 $type .= " on '$branch'" if (defined $branch);
2390 $type = "log of $branch" if (defined $branch);
2393 $res{-title
} = $type;
2394 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
2395 $res{'file_name'} = $file_name;
2400 ## ----------------------------------------------------------------------
2401 ## git utility subroutines, invoking git commands
2403 # returns path to the core git executable and the --git-dir parameter as list
2405 $number_of_git_cmds++;
2406 return $GIT, '--git-dir='.$git_dir;
2409 # quote the given arguments for passing them to the shell
2410 # quote_command("command", "arg 1", "arg with ' and ! characters")
2411 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2412 # Try to avoid using this function wherever possible.
2415 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
2418 # get HEAD ref of given project as hash
2419 sub git_get_head_hash
{
2420 return git_get_full_hash
(shift, 'HEAD');
2423 sub git_get_full_hash
{
2424 return git_get_hash
(@_);
2427 sub git_get_short_hash
{
2428 return git_get_hash
(@_, '--short=7');
2432 my ($project, $hash, @options) = @_;
2433 my $o_git_dir = $git_dir;
2435 $git_dir = "$projectroot/$project";
2436 if (open my $fd, '-|', git_cmd
(), 'rev-parse',
2437 '--verify', '-q', @options, $hash) {
2439 chomp $retval if defined $retval;
2442 if (defined $o_git_dir) {
2443 $git_dir = $o_git_dir;
2448 # get type of given object
2452 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
2454 close $fd or return;
2459 # repository configuration
2460 our $config_file = '';
2463 # store multiple values for single key as anonymous array reference
2464 # single values stored directly in the hash, not as [ <value> ]
2465 sub hash_set_multi
{
2466 my ($hash, $key, $value) = @_;
2468 if (!exists $hash->{$key}) {
2469 $hash->{$key} = $value;
2470 } elsif (!ref $hash->{$key}) {
2471 $hash->{$key} = [ $hash->{$key}, $value ];
2473 push @
{$hash->{$key}}, $value;
2477 # return hash of git project configuration
2478 # optionally limited to some section, e.g. 'gitweb'
2479 sub git_parse_project_config
{
2480 my $section_regexp = shift;
2485 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
2488 while (my $keyval = <$fh>) {
2490 my ($key, $value) = split(/\n/, $keyval, 2);
2492 hash_set_multi
(\
%config, $key, $value)
2493 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2500 # convert config value to boolean: 'true' or 'false'
2501 # no value, number > 0, 'true' and 'yes' values are true
2502 # rest of values are treated as false (never as error)
2503 sub config_to_bool
{
2506 return 1 if !defined $val; # section.key
2508 # strip leading and trailing whitespace
2512 return (($val =~ /^\d+$/ && $val) || # section.key = 1
2513 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2516 # convert config value to simple decimal number
2517 # an optional value suffix of 'k', 'm', or 'g' will cause the value
2518 # to be multiplied by 1024, 1048576, or 1073741824
2522 # strip leading and trailing whitespace
2526 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2528 # unknown unit is treated as 1
2529 return $num * ($unit eq 'g' ?
1073741824 :
2530 $unit eq 'm' ?
1048576 :
2531 $unit eq 'k' ?
1024 : 1);
2536 # convert config value to array reference, if needed
2537 sub config_to_multi
{
2540 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
2543 sub git_get_project_config
{
2544 my ($key, $type) = @_;
2546 return unless defined $git_dir;
2549 return unless ($key);
2550 # only subsection, if exists, is case sensitive,
2551 # and not lowercased by 'git config -z -l'
2552 if (my ($hi, $mi, $lo) = ($key =~ /^([^.]*)\.(.*)\.([^.]*)$/)) {
2553 $key = join(".", lc($hi), $mi, lc($lo));
2557 $key =~ s/^gitweb\.//;
2558 return if ($key =~ m/\W/);
2561 if (defined $type) {
2564 unless ($type eq 'bool' || $type eq 'int');
2568 if (!defined $config_file ||
2569 $config_file ne "$git_dir/config") {
2570 %config = git_parse_project_config
('gitweb');
2571 $config_file = "$git_dir/config";
2574 # check if config variable (key) exists
2575 return unless exists $config{"gitweb.$key"};
2578 if (!defined $type) {
2579 return $config{"gitweb.$key"};
2580 } elsif ($type eq 'bool') {
2581 # backward compatibility: 'git config --bool' returns true/false
2582 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
2583 } elsif ($type eq 'int') {
2584 return config_to_int
($config{"gitweb.$key"});
2586 return $config{"gitweb.$key"};
2589 # get hash of given path at given ref
2590 sub git_get_hash_by_path
{
2592 my $path = shift || return undef;
2597 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
2598 or die_error
(500, "Open git-ls-tree failed");
2600 close $fd or return undef;
2602 if (!defined $line) {
2603 # there is no tree or hash given by $path at $base
2607 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2608 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2609 if (defined $type && $type ne $2) {
2610 # type doesn't match
2616 # get path of entry with given hash at given tree-ish (ref)
2617 # used to get 'from' filename for combined diff (merge commit) for renames
2618 sub git_get_path_by_hash
{
2619 my $base = shift || return;
2620 my $hash = shift || return;
2624 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
2626 while (my $line = <$fd>) {
2629 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2630 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2631 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2640 ## ......................................................................
2641 ## git utility functions, directly accessing git repository
2643 # get the value of config variable either from file named as the variable
2644 # itself in the repository ($GIT_DIR/$name file), or from gitweb.$name
2645 # configuration variable in the repository config file.
2646 sub git_get_file_or_project_config
{
2647 my ($path, $name) = @_;
2649 $git_dir = "$projectroot/$path";
2650 open my $fd, '<', "$git_dir/$name"
2651 or return git_get_project_config
($name);
2654 if (defined $conf) {
2660 sub git_get_project_description
{
2662 return git_get_file_or_project_config
($path, 'description');
2665 sub git_get_project_category
{
2667 return git_get_file_or_project_config
($path, 'category');
2671 # supported formats:
2672 # * $GIT_DIR/ctags/<tagname> file (in 'ctags' subdirectory)
2673 # - if its contents is a number, use it as tag weight,
2674 # - otherwise add a tag with weight 1
2675 # * $GIT_DIR/ctags file, each line is a tag (with weight 1)
2676 # the same value multiple times increases tag weight
2677 # * `gitweb.ctag' multi-valued repo config variable
2678 sub git_get_project_ctags
{
2679 my $project = shift;
2682 $git_dir = "$projectroot/$project";
2683 if (opendir my $dh, "$git_dir/ctags") {
2684 my @files = grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir($dh);
2685 foreach my $tagfile (@files) {
2686 open my $ct, '<', $tagfile
2692 (my $ctag = $tagfile) =~ s
#.*/##;
2693 if ($val =~ /^\d+$/) {
2694 $ctags->{$ctag} = $val;
2696 $ctags->{$ctag} = 1;
2701 } elsif (open my $fh, '<', "$git_dir/ctags") {
2702 while (my $line = <$fh>) {
2704 $ctags->{$line}++ if $line;
2709 my $taglist = config_to_multi
(git_get_project_config
('ctag'));
2710 foreach my $tag (@
$taglist) {
2718 # return hash, where keys are content tags ('ctags'),
2719 # and values are sum of weights of given tag in every project
2720 sub git_gather_all_ctags
{
2721 my $projects = shift;
2724 foreach my $p (@
$projects) {
2725 foreach my $ct (keys %{$p->{'ctags'}}) {
2726 $ctags->{$ct} += $p->{'ctags'}->{$ct};
2733 sub git_populate_project_tagcloud
{
2736 # First, merge different-cased tags; tags vote on casing
2738 foreach (keys %$ctags) {
2739 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2740 if (not $ctags_lc{lc $_}->{topcount
}
2741 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2742 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2743 $ctags_lc{lc $_}->{topname
} = $_;
2748 my $matched = $cgi->param('by_tag');
2749 if (eval { require HTML
::TagCloud
; 1; }) {
2750 $cloud = HTML
::TagCloud
->new;
2751 foreach my $ctag (sort keys %ctags_lc) {
2752 # Pad the title with spaces so that the cloud looks
2754 my $title = esc_html
($ctags_lc{$ctag}->{topname
});
2755 $title =~ s/ / /g;
2756 $title =~ s/^/ /g;
2757 $title =~ s/$/ /g;
2758 if (defined $matched && $matched eq $ctag) {
2759 $title = qq(<span
class="match">$title</span
>);
2761 $cloud->add($title, href
(project
=>undef, ctag
=>$ctag),
2762 $ctags_lc{$ctag}->{count
});
2766 foreach my $ctag (keys %ctags_lc) {
2767 my $title = esc_html
($ctags_lc{$ctag}->{topname
}, -nbsp
=>1);
2768 if (defined $matched && $matched eq $ctag) {
2769 $title = qq(<span
class="match">$title</span
>);
2771 $cloud->{$ctag}{count
} = $ctags_lc{$ctag}->{count
};
2772 $cloud->{$ctag}{ctag
} =
2773 $cgi->a({-href
=>href
(project
=>undef, ctag
=>$ctag)}, $title);
2779 sub git_show_project_tagcloud
{
2780 my ($cloud, $count) = @_;
2781 if (ref $cloud eq 'HTML::TagCloud') {
2782 return $cloud->html_and_css($count);
2784 my @tags = sort { $cloud->{$a}->{'count'} <=> $cloud->{$b}->{'count'} } keys %$cloud;
2786 '<div id="htmltagcloud"'.($project ?
'' : ' align="center"').'>' .
2788 $cloud->{$_}->{'ctag'}
2789 } splice(@tags, 0, $count)) .
2794 sub git_get_project_url_list
{
2797 $git_dir = "$projectroot/$path";
2798 open my $fd, '<', "$git_dir/cloneurl"
2799 or return wantarray ?
2800 @
{ config_to_multi
(git_get_project_config
('url')) } :
2801 config_to_multi
(git_get_project_config
('url'));
2802 my @git_project_url_list = map { chomp; $_ } <$fd>;
2805 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2808 sub git_get_projects_list
{
2809 my $filter = shift || '';
2812 $filter =~ s/\.git$//;
2814 if (-d
$projects_list) {
2815 # search in directory
2816 my $dir = $projects_list;
2817 # remove the trailing "/"
2819 my $pfxlen = length("$projects_list");
2820 my $pfxdepth = ($projects_list =~ tr!/!!);
2821 # when filtering, search only given subdirectory
2828 follow_fast
=> 1, # follow symbolic links
2829 follow_skip
=> 2, # ignore duplicates
2830 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2833 our $project_maxdepth;
2835 # skip project-list toplevel, if we get it.
2836 return if (m!^[/.]$!);
2837 # only directories can be git repositories
2838 return unless (-d
$_);
2839 # don't traverse too deep (Find is super slow on os x)
2840 # $project_maxdepth excludes depth of $projectroot
2841 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2842 $File::Find
::prune
= 1;
2846 my $path = substr($File::Find
::name
, $pfxlen + 1);
2847 # we check related file in $projectroot
2848 if (check_export_ok
("$projectroot/$path")) {
2849 push @list, { path
=> $path };
2850 $File::Find
::prune
= 1;
2855 } elsif (-f
$projects_list) {
2856 # read from file(url-encoded):
2857 # 'git%2Fgit.git Linus+Torvalds'
2858 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2859 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2860 open my $fd, '<', $projects_list or return;
2862 while (my $line = <$fd>) {
2864 my ($path, $owner) = split ' ', $line;
2865 $path = unescape
($path);
2866 $owner = unescape
($owner);
2867 if (!defined $path) {
2870 # if $filter is rpovided, check if $path begins with $filter
2871 if ($filter && $path !~ m!^\Q$filter\E/!) {
2874 if (check_export_ok
("$projectroot/$path")) {
2877 owner
=> to_utf8
($owner),
2887 # written with help of Tree::Trie module (Perl Artistic License, GPL compatibile)
2888 # as side effects it sets 'forks' field to list of forks for forked projects
2889 sub filter_forks_from_projects_list
{
2890 my $projects = shift;
2892 my %trie; # prefix tree of directories (path components)
2893 # generate trie out of those directories that might contain forks
2894 foreach my $pr (@
$projects) {
2895 my $path = $pr->{'path'};
2896 $path =~ s/\.git$//; # forks of 'repo.git' are in 'repo/' directory
2897 next if ($path =~ m!/$!); # skip non-bare repositories, e.g. 'repo/.git'
2898 next unless ($path); # skip '.git' repository: tests, git-instaweb
2899 next unless (-d
$path); # containing directory exists
2900 $pr->{'forks'} = []; # there can be 0 or more forks of project
2903 my @dirs = split('/', $path);
2904 # walk the trie, until either runs out of components or out of trie
2906 while (scalar @dirs &&
2907 exists($ref->{$dirs[0]})) {
2908 $ref = $ref->{shift @dirs};
2910 # create rest of trie structure from rest of components
2911 foreach my $dir (@dirs) {
2912 $ref = $ref->{$dir} = {};
2914 # create end marker, store $pr as a data
2915 $ref->{''} = $pr if (!exists $ref->{''});
2918 # filter out forks, by finding shortest prefix match for paths
2921 foreach my $pr (@
$projects) {
2925 foreach my $dir (split('/', $pr->{'path'})) {
2926 if (exists $ref->{''}) {
2927 # found [shortest] prefix, is a fork - skip it
2928 push @
{$ref->{''}{'forks'}}, $pr;
2931 if (!exists $ref->{$dir}) {
2932 # not in trie, cannot have prefix, not a fork
2933 push @filtered, $pr;
2936 # If the dir is there, we just walk one step down the trie.
2937 $ref = $ref->{$dir};
2939 # we ran out of trie
2940 # (shouldn't happen: it's either no match, or end marker)
2941 push @filtered, $pr;
2947 # note: fill_project_list_info must be run first,
2948 # for 'descr_long' and 'ctags' to be filled
2949 sub search_projects_list
{
2950 my ($projlist, %opts) = @_;
2951 my $tagfilter = $opts{'tagfilter'};
2952 my $searchtext = $opts{'searchtext'};
2955 unless ($tagfilter || $searchtext);
2959 foreach my $pr (@
$projlist) {
2962 next unless ref($pr->{'ctags'}) eq 'HASH';
2964 grep { lc($_) eq lc($tagfilter) } keys %{$pr->{'ctags'}};
2969 $pr->{'path'} =~ /$searchtext/ ||
2970 $pr->{'descr_long'} =~ /$searchtext/;
2973 push @projects, $pr;
2979 our $gitweb_project_owner = undef;
2980 sub git_get_project_list_from_file
{
2982 return if (defined $gitweb_project_owner);
2984 $gitweb_project_owner = {};
2985 # read from file (url-encoded):
2986 # 'git%2Fgit.git Linus+Torvalds'
2987 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2988 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2989 if (-f
$projects_list) {
2990 open(my $fd, '<', $projects_list);
2991 while (my $line = <$fd>) {
2993 my ($pr, $ow) = split ' ', $line;
2994 $pr = unescape
($pr);
2995 $ow = unescape
($ow);
2996 $gitweb_project_owner->{$pr} = to_utf8
($ow);
3002 sub git_get_project_owner
{
3003 my $project = shift;
3006 return undef unless $project;
3007 $git_dir = "$projectroot/$project";
3009 if (!defined $gitweb_project_owner) {
3010 git_get_project_list_from_file
();
3013 if (exists $gitweb_project_owner->{$project}) {
3014 $owner = $gitweb_project_owner->{$project};
3016 if (!defined $owner){
3017 $owner = git_get_project_config
('owner');
3019 if (!defined $owner) {
3020 $owner = get_file_owner
("$git_dir");
3026 sub git_get_last_activity
{
3030 $git_dir = "$projectroot/$path";
3031 open($fd, "-|", git_cmd
(), 'for-each-ref',
3032 '--format=%(committer)',
3033 '--sort=-committerdate',
3035 'refs/heads') or return;
3036 my $most_recent = <$fd>;
3037 close $fd or return;
3038 if (defined $most_recent &&
3039 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
3041 my $age = time - $timestamp;
3042 return ($age, age_string
($age));
3044 return (undef, undef);
3047 # Implementation note: when a single remote is wanted, we cannot use 'git
3048 # remote show -n' because that command always work (assuming it's a remote URL
3049 # if it's not defined), and we cannot use 'git remote show' because that would
3050 # try to make a network roundtrip. So the only way to find if that particular
3051 # remote is defined is to walk the list provided by 'git remote -v' and stop if
3052 # and when we find what we want.
3053 sub git_get_remotes_list
{
3057 open my $fd, '-|' , git_cmd
(), 'remote', '-v';
3059 while (my $remote = <$fd>) {
3061 $remote =~ s!\t(.*?)\s+\((\w+)\)$!!;
3062 next if $wanted and not $remote eq $wanted;
3063 my ($url, $key) = ($1, $2);
3065 $remotes{$remote} ||= { 'heads' => () };
3066 $remotes{$remote}{$key} = $url;
3068 close $fd or return;
3069 return wantarray ?
%remotes : \
%remotes;
3072 # Takes a hash of remotes as first parameter and fills it by adding the
3073 # available remote heads for each of the indicated remotes.
3074 sub fill_remote_heads
{
3075 my $remotes = shift;
3076 my @heads = map { "remotes/$_" } keys %$remotes;
3077 my @remoteheads = git_get_heads_list
(undef, @heads);
3078 foreach my $remote (keys %$remotes) {
3079 $remotes->{$remote}{'heads'} = [ grep {
3080 $_->{'name'} =~ s!^$remote/!!
3085 sub git_get_references
{
3086 my $type = shift || "";
3088 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
3089 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
3090 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
3091 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
3094 while (my $line = <$fd>) {
3096 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
3097 if (defined $refs{$1}) {
3098 push @
{$refs{$1}}, $2;
3104 close $fd or return;
3108 sub git_get_rev_name_tags
{
3109 my $hash = shift || return undef;
3111 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
3113 my $name_rev = <$fd>;
3116 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
3119 # catches also '$hash undefined' output
3124 ## ----------------------------------------------------------------------
3125 ## parse to hash functions
3129 my $tz = shift || "-0000";
3132 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
3133 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
3134 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
3135 $date{'hour'} = $hour;
3136 $date{'minute'} = $min;
3137 $date{'mday'} = $mday;
3138 $date{'day'} = $days[$wday];
3139 $date{'month'} = $months[$mon];
3140 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
3141 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
3142 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
3143 $mday, $months[$mon], $hour ,$min;
3144 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
3145 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
3147 my ($tz_sign, $tz_hour, $tz_min) =
3148 ($tz =~ m/^([-+])(\d\d)(\d\d)$/);
3149 $tz_sign = ($tz_sign eq '-' ?
-1 : +1);
3150 my $local = $epoch + $tz_sign*((($tz_hour*60) + $tz_min)*60);
3151 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
3152 $date{'hour_local'} = $hour;
3153 $date{'minute_local'} = $min;
3154 $date{'tz_local'} = $tz;
3155 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
3156 1900+$year, $mon+1, $mday,
3157 $hour, $min, $sec, $tz);
3166 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
3167 $tag{'id'} = $tag_id;
3168 while (my $line = <$fd>) {
3170 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
3171 $tag{'object'} = $1;
3172 } elsif ($line =~ m/^type (.+)$/) {
3174 } elsif ($line =~ m/^tag (.+)$/) {
3176 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
3177 $tag{'author'} = $1;
3178 $tag{'author_epoch'} = $2;
3179 $tag{'author_tz'} = $3;
3180 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3181 $tag{'author_name'} = $1;
3182 $tag{'author_email'} = $2;
3184 $tag{'author_name'} = $tag{'author'};
3186 } elsif ($line =~ m/--BEGIN/) {
3187 push @comment, $line;
3189 } elsif ($line eq "") {
3193 push @comment, <$fd>;
3194 $tag{'comment'} = \
@comment;
3195 close $fd or return;
3196 if (!defined $tag{'name'}) {
3202 sub parse_commit_text
{
3203 my ($commit_text, $withparents) = @_;
3204 my @commit_lines = split '\n', $commit_text;
3207 pop @commit_lines; # Remove '\0'
3209 if (! @commit_lines) {
3213 my $header = shift @commit_lines;
3214 if ($header !~ m/^[0-9a-fA-F]{40}/) {
3217 ($co{'id'}, my @parents) = split ' ', $header;
3218 while (my $line = shift @commit_lines) {
3219 last if $line eq "\n";
3220 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
3222 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
3224 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
3225 $co{'author'} = to_utf8
($1);
3226 $co{'author_epoch'} = $2;
3227 $co{'author_tz'} = $3;
3228 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3229 $co{'author_name'} = $1;
3230 $co{'author_email'} = $2;
3232 $co{'author_name'} = $co{'author'};
3234 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
3235 $co{'committer'} = to_utf8
($1);
3236 $co{'committer_epoch'} = $2;
3237 $co{'committer_tz'} = $3;
3238 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
3239 $co{'committer_name'} = $1;
3240 $co{'committer_email'} = $2;
3242 $co{'committer_name'} = $co{'committer'};
3246 if (!defined $co{'tree'}) {
3249 $co{'parents'} = \
@parents;
3250 $co{'parent'} = $parents[0];
3252 foreach my $title (@commit_lines) {
3255 $co{'title'} = chop_str
($title, 80, 5);
3256 # remove leading stuff of merges to make the interesting part visible
3257 if (length($title) > 50) {
3258 $title =~ s/^Automatic //;
3259 $title =~ s/^merge (of|with) /Merge ... /i;
3260 if (length($title) > 50) {
3261 $title =~ s/(http|rsync):\/\///;
3263 if (length($title) > 50) {
3264 $title =~ s/(master|www|rsync)\.//;
3266 if (length($title) > 50) {
3267 $title =~ s/kernel.org:?//;
3269 if (length($title) > 50) {
3270 $title =~ s/\/pub\/scm//;
3273 $co{'title_short'} = chop_str
($title, 50, 5);
3277 if (! defined $co{'title'} || $co{'title'} eq "") {
3278 $co{'title'} = $co{'title_short'} = '(no commit message)';
3280 # remove added spaces
3281 foreach my $line (@commit_lines) {
3284 $co{'comment'} = \
@commit_lines;
3286 my $age = time - $co{'committer_epoch'};
3288 $co{'age_string'} = age_string
($age);
3289 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
3290 if ($age > 60*60*24*7*2) {
3291 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3292 $co{'age_string_age'} = $co{'age_string'};
3294 $co{'age_string_date'} = $co{'age_string'};
3295 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3301 my ($commit_id) = @_;
3306 open my $fd, "-|", git_cmd
(), "rev-list",
3312 or die_error
(500, "Open git-rev-list failed");
3313 %co = parse_commit_text
(<$fd>, 1);
3320 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
3328 open my $fd, "-|", git_cmd
(), "rev-list",
3331 ("--max-count=" . $maxcount),
3332 ("--skip=" . $skip),
3336 ($filename ?
($filename) : ())
3337 or die_error
(500, "Open git-rev-list failed");
3338 while (my $line = <$fd>) {
3339 my %co = parse_commit_text
($line);
3344 return wantarray ?
@cos : \
@cos;
3347 # parse line of git-diff-tree "raw" output
3348 sub parse_difftree_raw_line
{
3352 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3353 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
3354 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
3355 $res{'from_mode'} = $1;
3356 $res{'to_mode'} = $2;
3357 $res{'from_id'} = $3;
3359 $res{'status'} = $5;
3360 $res{'similarity'} = $6;
3361 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
3362 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
3364 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
3367 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3368 # combined diff (for merge commit)
3369 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
3370 $res{'nparents'} = length($1);
3371 $res{'from_mode'} = [ split(' ', $2) ];
3372 $res{'to_mode'} = pop @
{$res{'from_mode'}};
3373 $res{'from_id'} = [ split(' ', $3) ];
3374 $res{'to_id'} = pop @
{$res{'from_id'}};
3375 $res{'status'} = [ split('', $4) ];
3376 $res{'to_file'} = unquote
($5);
3378 # 'c512b523472485aef4fff9e57b229d9d243c967f'
3379 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
3380 $res{'commit'} = $1;
3383 return wantarray ?
%res : \
%res;
3386 # wrapper: return parsed line of git-diff-tree "raw" output
3387 # (the argument might be raw line, or parsed info)
3388 sub parsed_difftree_line
{
3389 my $line_or_ref = shift;
3391 if (ref($line_or_ref) eq "HASH") {
3392 # pre-parsed (or generated by hand)
3393 return $line_or_ref;
3395 return parse_difftree_raw_line
($line_or_ref);
3399 # parse line of git-ls-tree output
3400 sub parse_ls_tree_line
{
3406 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
3407 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40}) +(-|[0-9]+)\t(.+)$/s;
3416 $res{'name'} = unquote
($5);
3419 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
3420 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
3428 $res{'name'} = unquote
($4);
3432 return wantarray ?
%res : \
%res;
3435 # generates _two_ hashes, references to which are passed as 2 and 3 argument
3436 sub parse_from_to_diffinfo
{
3437 my ($diffinfo, $from, $to, @parents) = @_;
3439 if ($diffinfo->{'nparents'}) {
3441 $from->{'file'} = [];
3442 $from->{'href'} = [];
3443 fill_from_file_info
($diffinfo, @parents)
3444 unless exists $diffinfo->{'from_file'};
3445 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
3446 $from->{'file'}[$i] =
3447 defined $diffinfo->{'from_file'}[$i] ?
3448 $diffinfo->{'from_file'}[$i] :
3449 $diffinfo->{'to_file'};
3450 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3451 $from->{'href'}[$i] = href
(action
=>"blob",
3452 hash_base
=>$parents[$i],
3453 hash
=>$diffinfo->{'from_id'}[$i],
3454 file_name
=>$from->{'file'}[$i]);
3456 $from->{'href'}[$i] = undef;
3460 # ordinary (not combined) diff
3461 $from->{'file'} = $diffinfo->{'from_file'};
3462 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3463 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
3464 hash
=>$diffinfo->{'from_id'},
3465 file_name
=>$from->{'file'});
3467 delete $from->{'href'};
3471 $to->{'file'} = $diffinfo->{'to_file'};
3472 if (!is_deleted
($diffinfo)) { # file exists in result
3473 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
3474 hash
=>$diffinfo->{'to_id'},
3475 file_name
=>$to->{'file'});
3477 delete $to->{'href'};
3481 ## ......................................................................
3482 ## parse to array of hashes functions
3484 sub git_get_heads_list
{
3485 my ($limit, @classes) = @_;
3486 @classes = ('heads') unless @classes;
3487 my @patterns = map { "refs/$_" } @classes;
3490 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3491 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
3492 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
3495 while (my $line = <$fd>) {
3499 my ($refinfo, $committerinfo) = split(/\0/, $line);
3500 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3501 my ($committer, $epoch, $tz) =
3502 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
3503 $ref_item{'fullname'} = $name;
3504 $name =~ s!^refs/(?:head|remote)s/!!;
3506 $ref_item{'name'} = $name;
3507 $ref_item{'id'} = $hash;
3508 $ref_item{'title'} = $title || '(no commit message)';
3509 $ref_item{'epoch'} = $epoch;
3511 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3513 $ref_item{'age'} = "unknown";
3516 push @headslist, \
%ref_item;
3520 return wantarray ?
@headslist : \
@headslist;
3523 sub git_get_tags_list
{
3527 open my $fd, '-|', git_cmd
(), 'for-each-ref',
3528 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
3529 '--format=%(objectname) %(objecttype) %(refname) '.
3530 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3533 while (my $line = <$fd>) {
3537 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3538 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3539 my ($creator, $epoch, $tz) =
3540 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
3541 $ref_item{'fullname'} = $name;
3542 $name =~ s!^refs/tags/!!;
3544 $ref_item{'type'} = $type;
3545 $ref_item{'id'} = $id;
3546 $ref_item{'name'} = $name;
3547 if ($type eq "tag") {
3548 $ref_item{'subject'} = $title;
3549 $ref_item{'reftype'} = $reftype;
3550 $ref_item{'refid'} = $refid;
3552 $ref_item{'reftype'} = $type;
3553 $ref_item{'refid'} = $id;
3556 if ($type eq "tag" || $type eq "commit") {
3557 $ref_item{'epoch'} = $epoch;
3559 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
3561 $ref_item{'age'} = "unknown";
3565 push @tagslist, \
%ref_item;
3569 return wantarray ?
@tagslist : \
@tagslist;
3572 ## ----------------------------------------------------------------------
3573 ## filesystem-related functions
3575 sub get_file_owner
{
3578 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3579 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3580 if (!defined $gcos) {
3584 $owner =~ s/[,;].*$//;
3585 return to_utf8
($owner);
3588 # assume that file exists
3590 my $filename = shift;
3592 open my $fd, '<', $filename;
3593 print map { to_utf8
($_) } <$fd>;
3597 ## ......................................................................
3598 ## mimetype related functions
3600 sub mimetype_guess_file
{
3601 my $filename = shift;
3602 my $mimemap = shift;
3603 -r
$mimemap or return undef;
3606 open(my $mh, '<', $mimemap) or return undef;
3608 next if m/^#/; # skip comments
3609 my ($mimetype, @exts) = split(/\s+/);
3610 foreach my $ext (@exts) {
3611 $mimemap{$ext} = $mimetype;
3616 $filename =~ /\.([^.]*)$/;
3617 return $mimemap{$1};
3620 sub mimetype_guess
{
3621 my $filename = shift;
3623 $filename =~ /\./ or return undef;
3625 if ($mimetypes_file) {
3626 my $file = $mimetypes_file;
3627 if ($file !~ m!^/!) { # if it is relative path
3628 # it is relative to project
3629 $file = "$projectroot/$project/$file";
3631 $mime = mimetype_guess_file
($filename, $file);
3633 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
3639 my $filename = shift;
3642 my $mime = mimetype_guess
($filename);
3643 $mime and return $mime;
3647 return $default_blob_plain_mimetype unless $fd;
3650 return 'text/plain';
3651 } elsif (! $filename) {
3652 return 'application/octet-stream';
3653 } elsif ($filename =~ m/\.png$/i) {
3655 } elsif ($filename =~ m/\.gif$/i) {
3657 } elsif ($filename =~ m/\.jpe?g$/i) {
3658 return 'image/jpeg';
3660 return 'application/octet-stream';
3664 sub blob_contenttype
{
3665 my ($fd, $file_name, $type) = @_;
3667 $type ||= blob_mimetype
($fd, $file_name);
3668 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3669 $type .= "; charset=$default_text_plain_charset";
3675 # guess file syntax for syntax highlighting; return undef if no highlighting
3676 # the name of syntax can (in the future) depend on syntax highlighter used
3677 sub guess_file_syntax
{
3678 my ($highlight, $mimetype, $file_name) = @_;
3679 return undef unless ($highlight && defined $file_name);
3680 my $basename = basename
($file_name, '.in');
3681 return $highlight_basename{$basename}
3682 if exists $highlight_basename{$basename};
3684 $basename =~ /\.([^.]*)$/;
3685 my $ext = $1 or return undef;
3686 return $highlight_ext{$ext}
3687 if exists $highlight_ext{$ext};
3692 # run highlighter and return FD of its output,
3693 # or return original FD if no highlighting
3694 sub run_highlighter
{
3695 my ($fd, $highlight, $syntax) = @_;
3696 return $fd unless ($highlight && defined $syntax);
3699 open $fd, quote_command
(git_cmd
(), "cat-file", "blob", $hash)." | ".
3700 quote_command
($highlight_bin).
3701 " --replace-tabs=8 --fragment --syntax $syntax |"
3702 or die_error
(500, "Couldn't open file or run syntax highlighter");
3706 ## ======================================================================
3707 ## functions printing HTML: header, footer, error page
3709 sub get_page_title
{
3710 my $title = to_utf8
($site_name);
3712 return $title unless (defined $project);
3713 $title .= " - " . to_utf8
($project);
3715 return $title unless (defined $action);
3716 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
3718 return $title unless (defined $file_name);
3719 $title .= " - " . esc_path
($file_name);
3720 if ($action eq "tree" && $file_name !~ m
|/$|) {
3727 sub get_content_type_html
{
3728 # require explicit support from the UA if we are to send the page as
3729 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
3730 # we have to do this because MSIE sometimes globs '*/*', pretending to
3731 # support xhtml+xml but choking when it gets what it asked for.
3732 if (defined $cgi->http('HTTP_ACCEPT') &&
3733 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
3734 $cgi->Accept('application/xhtml+xml') != 0) {
3735 return 'application/xhtml+xml';
3741 sub print_feed_meta
{
3742 if (defined $project) {
3743 my %href_params = get_feed_info
();
3744 if (!exists $href_params{'-title'}) {
3745 $href_params{'-title'} = 'log';
3748 foreach my $format (qw(RSS Atom)) {
3749 my $type = lc($format);
3751 '-rel' => 'alternate',
3752 '-title' => esc_attr
("$project - $href_params{'-title'} - $format feed"),
3753 '-type' => "application/$type+xml"
3756 $href_params{'action'} = $type;
3757 $link_attr{'-href'} = href
(%href_params);
3759 "rel=\"$link_attr{'-rel'}\" ".
3760 "title=\"$link_attr{'-title'}\" ".
3761 "href=\"$link_attr{'-href'}\" ".
3762 "type=\"$link_attr{'-type'}\" ".
3765 $href_params{'extra_options'} = '--no-merges';
3766 $link_attr{'-href'} = href
(%href_params);
3767 $link_attr{'-title'} .= ' (no merges)';
3769 "rel=\"$link_attr{'-rel'}\" ".
3770 "title=\"$link_attr{'-title'}\" ".
3771 "href=\"$link_attr{'-href'}\" ".
3772 "type=\"$link_attr{'-type'}\" ".
3777 printf('<link rel="alternate" title="%s projects list" '.
3778 'href="%s" type="text/plain; charset=utf-8" />'."\n",
3779 esc_attr
($site_name), href
(project
=>undef, action
=>"project_index"));
3780 printf('<link rel="alternate" title="%s projects feeds" '.
3781 'href="%s" type="text/x-opml" />'."\n",
3782 esc_attr
($site_name), href
(project
=>undef, action
=>"opml"));
3786 sub print_header_links
{
3789 # print out each stylesheet that exist, providing backwards capability
3790 # for those people who defined $stylesheet in a config file
3791 if (defined $stylesheet) {
3792 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3794 foreach my $stylesheet (@stylesheets) {
3795 next unless $stylesheet;
3796 print '<link rel="stylesheet" type="text/css" href="'.esc_url
($stylesheet).'"/>'."\n";
3800 if ($status eq '200 OK');
3801 if (defined $favicon) {
3802 print qq(<link rel
="shortcut icon" href
=").esc_url($favicon).qq(" type
="image/png" />\n);
3806 sub print_nav_breadcrumbs
{
3809 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
3810 if (defined $project) {
3811 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
3812 if (defined $action) {
3813 my $action_print = $action ;
3814 if (defined $opts{-action_extra
}) {
3815 $action_print = $cgi->a({-href
=> href
(action
=>$action)},
3818 print " / $action_print";
3820 if (defined $opts{-action_extra
}) {
3821 print " / $opts{-action_extra}";
3827 sub print_search_form
{
3828 if (!defined $searchtext) {
3832 if (defined $hash_base) {
3833 $search_hash = $hash_base;
3834 } elsif (defined $hash) {
3835 $search_hash = $hash;
3837 $search_hash = "HEAD";
3839 my $action = $my_uri;
3840 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3841 if ($use_pathinfo) {
3842 $action .= "/".esc_url
($project);
3844 print $cgi->startform(-method
=> "get", -action
=> $action) .
3845 "<div class=\"search\">\n" .
3847 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3848 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3849 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3850 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3851 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3852 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3854 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
3855 "<span title=\"Extended regular expression\">" .
3856 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3857 -checked
=> $search_use_regexp) .
3860 $cgi->end_form() . "\n";
3863 sub git_header_html
{
3864 my $status = shift || "200 OK";
3865 my $expires = shift;
3868 my $title = get_page_title
();
3869 my $content_type = get_content_type_html
();
3870 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
3871 -status
=> $status, -expires
=> $expires)
3872 unless ($opts{'-no_http_header'});
3873 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
3875 <?xml version="1.0" encoding="utf-8"?>
3876 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3877 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
3878 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
3879 <!-- git core binaries version $git_version -->
3881 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
3882 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
3883 <meta name="robots" content="index, nofollow"/>
3884 <title>$title</title>
3886 # the stylesheet, favicon etc urls won't work correctly with path_info
3887 # unless we set the appropriate base URL
3888 if ($ENV{'PATH_INFO'}) {
3889 print "<base href=\"".esc_url
($base_url)."\" />\n";
3891 print_header_links
($status);
3895 if (defined $site_header && -f
$site_header) {
3896 insert_file
($site_header);
3899 print "<div class=\"page_header\">\n";
3900 if (defined $logo) {
3901 print $cgi->a({-href
=> esc_url
($logo_url),
3902 -title
=> $logo_label},
3903 $cgi->img({-src
=> esc_url
($logo),
3904 -width
=> 72, -height
=> 27,
3906 -class => "logo"}));
3908 print_nav_breadcrumbs
(%opts);
3911 my $have_search = gitweb_check_feature
('search');
3912 if (defined $project && $have_search) {
3913 print_search_form
();
3917 sub git_footer_html
{
3918 my $feed_class = 'rss_logo';
3920 print "<div class=\"page_footer\">\n";
3921 if (defined $project) {
3922 my $descr = git_get_project_description
($project);
3923 if (defined $descr) {
3924 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3927 my %href_params = get_feed_info
();
3928 if (!%href_params) {
3929 $feed_class .= ' generic';
3931 $href_params{'-title'} ||= 'log';
3933 foreach my $format (qw(RSS Atom)) {
3934 $href_params{'action'} = lc($format);
3935 print $cgi->a({-href
=> href
(%href_params),
3936 -title
=> "$href_params{'-title'} $format feed",
3937 -class => $feed_class}, $format)."\n";
3941 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3942 -class => $feed_class}, "OPML") . " ";
3943 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3944 -class => $feed_class}, "TXT") . "\n";
3946 print "</div>\n"; # class="page_footer"
3948 if (defined $t0 && gitweb_check_feature
('timed')) {
3949 print "<div id=\"generating_info\">\n";
3950 print 'This page took '.
3951 '<span id="generating_time" class="time_span">'.
3952 tv_interval
($t0, [ gettimeofday
() ]).
3955 '<span id="generating_cmd">'.
3956 $number_of_git_cmds.
3957 '</span> git commands '.
3959 print "</div>\n"; # class="page_footer"
3962 if (defined $site_footer && -f
$site_footer) {
3963 insert_file
($site_footer);
3966 print qq!<script type
="text/javascript" src
="!.esc_url($javascript).qq!"></script
>\n!;
3967 if (defined $action &&
3968 $action eq 'blame_incremental') {
3969 print qq!<script type
="text/javascript">\n!.
3970 qq!startBlame
("!. href(action=>"blame_data
", -replay=>1) .qq!",\n!.
3971 qq! "!. href() .qq!");\n!.
3974 my ($jstimezone, $tz_cookie, $datetime_class) =
3975 gitweb_get_feature
('javascript-timezone');
3977 print qq!<script type
="text/javascript">\n!.
3978 qq!window
.onload
= function
() {\n!;
3979 if (gitweb_check_feature
('javascript-actions')) {
3980 print qq! fixLinks
();\n!;
3982 if ($jstimezone && $tz_cookie && $datetime_class) {
3983 print qq! var tz_cookie
= { name
: '$tz_cookie', expires
: 14, path
: '/' };\n!. # in days
3984 qq! onloadTZSetup
('$jstimezone', tz_cookie
, '$datetime_class');\n!;
3994 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
3995 # Example: die_error(404, 'Hash not found')
3996 # By convention, use the following status codes (as defined in RFC 2616):
3997 # 400: Invalid or missing CGI parameters, or
3998 # requested object exists but has wrong type.
3999 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
4000 # this server or project.
4001 # 404: Requested object/revision/project doesn't exist.
4002 # 500: The server isn't configured properly, or
4003 # an internal error occurred (e.g. failed assertions caused by bugs), or
4004 # an unknown error occurred (e.g. the git binary died unexpectedly).
4005 # 503: The server is currently unavailable (because it is overloaded,
4006 # or down for maintenance). Generally, this is a temporary state.
4008 my $status = shift || 500;
4009 my $error = esc_html
(shift) || "Internal Server Error";
4013 my %http_responses = (
4014 400 => '400 Bad Request',
4015 403 => '403 Forbidden',
4016 404 => '404 Not Found',
4017 500 => '500 Internal Server Error',
4018 503 => '503 Service Unavailable',
4020 git_header_html
($http_responses{$status}, undef, %opts);
4022 <div class="page_body">
4027 if (defined $extra) {
4035 unless ($opts{'-error_handler'});
4038 ## ----------------------------------------------------------------------
4039 ## functions printing or outputting HTML: navigation
4041 sub git_print_page_nav
{
4042 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
4043 $extra = '' if !defined $extra; # pager or formats
4045 my @navs = qw(summary shortlog log commit commitdiff tree);
4047 @navs = grep { $_ ne $suppress } @navs;
4050 my %arg = map { $_ => {action
=>$_} } @navs;
4051 if (defined $head) {
4052 for (qw(commit commitdiff)) {
4053 $arg{$_}{'hash'} = $head;
4055 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
4056 for (qw(shortlog log)) {
4057 $arg{$_}{'hash'} = $head;
4062 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
4063 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
4065 my @actions = gitweb_get_feature
('actions');
4068 'n' => $project, # project name
4069 'f' => $git_dir, # project path within filesystem
4070 'h' => $treehead || '', # current hash ('h' parameter)
4071 'b' => $treebase || '', # hash base ('hb' parameter)
4074 my ($label, $link, $pos) = splice(@actions,0,3);
4076 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
4078 $link =~ s/%([%nfhb])/$repl{$1}/g;
4079 $arg{$label}{'_href'} = $link;
4082 print "<div class=\"page_nav\">\n" .
4084 map { $_ eq $current ?
4085 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
4087 print "<br/>\n$extra<br/>\n" .
4091 # returns a submenu for the nagivation of the refs views (tags, heads,
4092 # remotes) with the current view disabled and the remotes view only
4093 # available if the feature is enabled
4094 sub format_ref_views
{
4096 my @ref_views = qw{tags heads
};
4097 push @ref_views, 'remotes' if gitweb_check_feature
('remote_heads');
4098 return join " | ", map {
4099 $_ eq $current ?
$_ :
4100 $cgi->a({-href
=> href
(action
=>$_)}, $_)
4104 sub format_paging_nav
{
4105 my ($action, $page, $has_next_link) = @_;
4111 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)}, "first") .
4113 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
4114 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
4116 $paging_nav .= "first ⋅ prev";
4119 if ($has_next_link) {
4120 $paging_nav .= " ⋅ " .
4121 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
4122 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
4124 $paging_nav .= " ⋅ next";
4130 ## ......................................................................
4131 ## functions printing or outputting HTML: div
4133 sub git_print_header_div
{
4134 my ($action, $title, $hash, $hash_base) = @_;
4137 $args{'action'} = $action;
4138 $args{'hash'} = $hash if $hash;
4139 $args{'hash_base'} = $hash_base if $hash_base;
4141 print "<div class=\"header\">\n" .
4142 $cgi->a({-href
=> href
(%args), -class => "title"},
4143 $title ?
$title : $action) .
4147 sub format_repo_url
{
4148 my ($name, $url) = @_;
4149 return "<tr class=\"metadata_url\"><td>$name</td><td>$url</td></tr>\n";
4152 # Group output by placing it in a DIV element and adding a header.
4153 # Options for start_div() can be provided by passing a hash reference as the
4154 # first parameter to the function.
4155 # Options to git_print_header_div() can be provided by passing an array
4156 # reference. This must follow the options to start_div if they are present.
4157 # The content can be a scalar, which is output as-is, a scalar reference, which
4158 # is output after html escaping, an IO handle passed either as *handle or
4159 # *handle{IO}, or a function reference. In the latter case all following
4160 # parameters will be taken as argument to the content function call.
4161 sub git_print_section
{
4162 my ($div_args, $header_args, $content);
4164 if (ref($arg) eq 'HASH') {
4168 if (ref($arg) eq 'ARRAY') {
4169 $header_args = $arg;
4174 print $cgi->start_div($div_args);
4175 git_print_header_div
(@
$header_args);
4177 if (ref($content) eq 'CODE') {
4179 } elsif (ref($content) eq 'SCALAR') {
4180 print esc_html
($$content);
4181 } elsif (ref($content) eq 'GLOB' or ref($content) eq 'IO::Handle') {
4183 } elsif (!ref($content) && defined($content)) {
4187 print $cgi->end_div;
4190 sub format_timestamp_html
{
4192 my $strtime = $date->{'rfc2822'};
4194 my (undef, undef, $datetime_class) =
4195 gitweb_get_feature
('javascript-timezone');
4196 if ($datetime_class) {
4197 $strtime = qq!<span
class="$datetime_class">$strtime</span
>!;
4200 my $localtime_format = '(%02d:%02d %s)';
4201 if ($date->{'hour_local'} < 6) {
4202 $localtime_format = '(<span class="atnight">%02d:%02d</span> %s)';
4205 sprintf($localtime_format,
4206 $date->{'hour_local'}, $date->{'minute_local'}, $date->{'tz_local'});
4211 # Outputs the author name and date in long form
4212 sub git_print_authorship
{
4215 my $tag = $opts{-tag
} || 'div';
4216 my $author = $co->{'author_name'};
4218 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
4219 print "<$tag class=\"author_date\">" .
4220 format_search_author
($author, "author", esc_html
($author)) .
4221 " [".format_timestamp_html
(\
%ad)."]".
4222 git_get_avatar
($co->{'author_email'}, -pad_before
=> 1) .
4226 # Outputs table rows containing the full author or committer information,
4227 # in the format expected for 'commit' view (& similar).
4228 # Parameters are a commit hash reference, followed by the list of people
4229 # to output information for. If the list is empty it defaults to both
4230 # author and committer.
4231 sub git_print_authorship_rows
{
4233 # too bad we can't use @people = @_ || ('author', 'committer')
4235 @people = ('author', 'committer') unless @people;
4236 foreach my $who (@people) {
4237 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
4238 print "<tr><td>$who</td><td>" .
4239 format_search_author
($co->{"${who}_name"}, $who,
4240 esc_html
($co->{"${who}_name"})) . " " .
4241 format_search_author
($co->{"${who}_email"}, $who,
4242 esc_html
("<" . $co->{"${who}_email"} . ">")) .
4243 "</td><td rowspan=\"2\">" .
4244 git_get_avatar
($co->{"${who}_email"}, -size
=> 'double') .
4248 format_timestamp_html
(\
%wd) .
4254 sub git_print_page_path
{
4260 print "<div class=\"page_path\">";
4261 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
4262 -title
=> 'tree root'}, to_utf8
("[$project]"));
4264 if (defined $name) {
4265 my @dirname = split '/', $name;
4266 my $basename = pop @dirname;
4269 foreach my $dir (@dirname) {
4270 $fullname .= ($fullname ?
'/' : '') . $dir;
4271 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
4273 -title
=> $fullname}, esc_path
($dir));
4276 if (defined $type && $type eq 'blob') {
4277 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
4279 -title
=> $name}, esc_path
($basename));
4280 } elsif (defined $type && $type eq 'tree') {
4281 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
4283 -title
=> $name}, esc_path
($basename));
4286 print esc_path
($basename);
4289 print "<br/></div>\n";
4296 if ($opts{'-remove_title'}) {
4297 # remove title, i.e. first line of log
4300 # remove leading empty lines
4301 while (defined $log->[0] && $log->[0] eq "") {
4308 foreach my $line (@
$log) {
4309 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
4312 if (! $opts{'-remove_signoff'}) {
4313 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
4316 # remove signoff lines
4323 # print only one empty line
4324 # do not print empty line after signoff
4326 next if ($empty || $signoff);
4332 print format_log_line_html
($line) . "<br/>\n";
4335 if ($opts{'-final_empty_line'}) {
4336 # end with single empty line
4337 print "<br/>\n" unless $empty;
4341 # return link target (what link points to)
4342 sub git_get_link_target
{
4347 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4351 $link_target = <$fd>;
4356 return $link_target;
4359 # given link target, and the directory (basedir) the link is in,
4360 # return target of link relative to top directory (top tree);
4361 # return undef if it is not possible (including absolute links).
4362 sub normalize_link_target
{
4363 my ($link_target, $basedir) = @_;
4365 # absolute symlinks (beginning with '/') cannot be normalized
4366 return if (substr($link_target, 0, 1) eq '/');
4368 # normalize link target to path from top (root) tree (dir)
4371 $path = $basedir . '/' . $link_target;
4373 # we are in top (root) tree (dir)
4374 $path = $link_target;
4377 # remove //, /./, and /../
4379 foreach my $part (split('/', $path)) {
4380 # discard '.' and ''
4381 next if (!$part || $part eq '.');
4383 if ($part eq '..') {
4387 # link leads outside repository (outside top dir)
4391 push @path_parts, $part;
4394 $path = join('/', @path_parts);
4399 # print tree entry (row of git_tree), but without encompassing <tr> element
4400 sub git_print_tree_entry
{
4401 my ($t, $basedir, $hash_base, $have_blame) = @_;
4404 $base_key{'hash_base'} = $hash_base if defined $hash_base;
4406 # The format of a table row is: mode list link. Where mode is
4407 # the mode of the entry, list is the name of the entry, an href,
4408 # and link is the action links of the entry.
4410 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
4411 if (exists $t->{'size'}) {
4412 print "<td class=\"size\">$t->{'size'}</td>\n";
4414 if ($t->{'type'} eq "blob") {
4415 print "<td class=\"list\">" .
4416 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4417 file_name
=>"$basedir$t->{'name'}", %base_key),
4418 -class => "list"}, esc_path
($t->{'name'}));
4419 if (S_ISLNK
(oct $t->{'mode'})) {
4420 my $link_target = git_get_link_target
($t->{'hash'});
4422 my $norm_target = normalize_link_target
($link_target, $basedir);
4423 if (defined $norm_target) {
4425 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
4426 file_name
=>$norm_target),
4427 -title
=> $norm_target}, esc_path
($link_target));
4429 print " -> " . esc_path
($link_target);
4434 print "<td class=\"link\">";
4435 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
4436 file_name
=>"$basedir$t->{'name'}", %base_key)},
4440 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
4441 file_name
=>"$basedir$t->{'name'}", %base_key)},
4444 if (defined $hash_base) {
4446 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4447 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
4451 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
4452 file_name
=>"$basedir$t->{'name'}")},
4456 } elsif ($t->{'type'} eq "tree") {
4457 print "<td class=\"list\">";
4458 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4459 file_name
=>"$basedir$t->{'name'}",
4461 esc_path
($t->{'name'}));
4463 print "<td class=\"link\">";
4464 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
4465 file_name
=>"$basedir$t->{'name'}",
4468 if (defined $hash_base) {
4470 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
4471 file_name
=>"$basedir$t->{'name'}")},
4476 # unknown object: we can only present history for it
4477 # (this includes 'commit' object, i.e. submodule support)
4478 print "<td class=\"list\">" .
4479 esc_path
($t->{'name'}) .
4481 print "<td class=\"link\">";
4482 if (defined $hash_base) {
4483 print $cgi->a({-href
=> href
(action
=>"history",
4484 hash_base
=>$hash_base,
4485 file_name
=>"$basedir$t->{'name'}")},
4492 ## ......................................................................
4493 ## functions printing large fragments of HTML
4495 # get pre-image filenames for merge (combined) diff
4496 sub fill_from_file_info
{
4497 my ($diff, @parents) = @_;
4499 $diff->{'from_file'} = [ ];
4500 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4501 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4502 if ($diff->{'status'}[$i] eq 'R' ||
4503 $diff->{'status'}[$i] eq 'C') {
4504 $diff->{'from_file'}[$i] =
4505 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
4512 # is current raw difftree line of file deletion
4514 my $diffinfo = shift;
4516 return $diffinfo->{'to_id'} eq ('0' x
40);
4519 # does patch correspond to [previous] difftree raw line
4520 # $diffinfo - hashref of parsed raw diff format
4521 # $patchinfo - hashref of parsed patch diff format
4522 # (the same keys as in $diffinfo)
4523 sub is_patch_split
{
4524 my ($diffinfo, $patchinfo) = @_;
4526 return defined $diffinfo && defined $patchinfo
4527 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4531 sub git_difftree_body
{
4532 my ($difftree, $hash, @parents) = @_;
4533 my ($parent) = $parents[0];
4534 my $have_blame = gitweb_check_feature
('blame');
4535 print "<div class=\"list_head\">\n";
4536 if ($#{$difftree} > 10) {
4537 print(($#{$difftree} + 1) . " files changed:\n");
4541 print "<table class=\"" .
4542 (@parents > 1 ?
"combined " : "") .
4545 # header only for combined diff in 'commitdiff' view
4546 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
4549 print "<thead><tr>\n" .
4550 "<th></th><th></th>\n"; # filename, patchN link
4551 for (my $i = 0; $i < @parents; $i++) {
4552 my $par = $parents[$i];
4554 $cgi->a({-href
=> href
(action
=>"commitdiff",
4555 hash
=>$hash, hash_parent
=>$par),
4556 -title
=> 'commitdiff to parent number ' .
4557 ($i+1) . ': ' . substr($par,0,7)},
4561 print "</tr></thead>\n<tbody>\n";
4566 foreach my $line (@
{$difftree}) {
4567 my $diff = parsed_difftree_line
($line);
4570 print "<tr class=\"dark\">\n";
4572 print "<tr class=\"light\">\n";
4576 if (exists $diff->{'nparents'}) { # combined diff
4578 fill_from_file_info
($diff, @parents)
4579 unless exists $diff->{'from_file'};
4581 if (!is_deleted
($diff)) {
4582 # file exists in the result (child) commit
4584 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4585 file_name
=>$diff->{'to_file'},
4587 -class => "list"}, esc_path
($diff->{'to_file'})) .
4591 esc_path
($diff->{'to_file'}) .
4595 if ($action eq 'commitdiff') {
4598 print "<td class=\"link\">" .
4599 $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4605 my $has_history = 0;
4606 my $not_deleted = 0;
4607 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4608 my $hash_parent = $parents[$i];
4609 my $from_hash = $diff->{'from_id'}[$i];
4610 my $from_path = $diff->{'from_file'}[$i];
4611 my $status = $diff->{'status'}[$i];
4613 $has_history ||= ($status ne 'A');
4614 $not_deleted ||= ($status ne 'D');
4616 if ($status eq 'A') {
4617 print "<td class=\"link\" align=\"right\"> | </td>\n";
4618 } elsif ($status eq 'D') {
4619 print "<td class=\"link\">" .
4620 $cgi->a({-href
=> href
(action
=>"blob",
4623 file_name
=>$from_path)},
4627 if ($diff->{'to_id'} eq $from_hash) {
4628 print "<td class=\"link nochange\">";
4630 print "<td class=\"link\">";
4632 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4633 hash
=>$diff->{'to_id'},
4634 hash_parent
=>$from_hash,
4636 hash_parent_base
=>$hash_parent,
4637 file_name
=>$diff->{'to_file'},
4638 file_parent
=>$from_path)},
4644 print "<td class=\"link\">";
4646 print $cgi->a({-href
=> href
(action
=>"blob",
4647 hash
=>$diff->{'to_id'},
4648 file_name
=>$diff->{'to_file'},
4651 print " | " if ($has_history);
4654 print $cgi->a({-href
=> href
(action
=>"history",
4655 file_name
=>$diff->{'to_file'},
4662 next; # instead of 'else' clause, to avoid extra indent
4664 # else ordinary diff
4666 my ($to_mode_oct, $to_mode_str, $to_file_type);
4667 my ($from_mode_oct, $from_mode_str, $from_file_type);
4668 if ($diff->{'to_mode'} ne ('0' x
6)) {
4669 $to_mode_oct = oct $diff->{'to_mode'};
4670 if (S_ISREG
($to_mode_oct)) { # only for regular file
4671 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4673 $to_file_type = file_type
($diff->{'to_mode'});
4675 if ($diff->{'from_mode'} ne ('0' x
6)) {
4676 $from_mode_oct = oct $diff->{'from_mode'};
4677 if (S_ISREG
($from_mode_oct)) { # only for regular file
4678 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4680 $from_file_type = file_type
($diff->{'from_mode'});
4683 if ($diff->{'status'} eq "A") { # created
4684 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4685 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4686 $mode_chng .= "]</span>";
4688 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4689 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4690 -class => "list"}, esc_path
($diff->{'file'}));
4692 print "<td>$mode_chng</td>\n";
4693 print "<td class=\"link\">";
4694 if ($action eq 'commitdiff') {
4697 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4701 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4702 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4706 } elsif ($diff->{'status'} eq "D") { # deleted
4707 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4709 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4710 hash_base
=>$parent, file_name
=>$diff->{'file'}),
4711 -class => "list"}, esc_path
($diff->{'file'}));
4713 print "<td>$mode_chng</td>\n";
4714 print "<td class=\"link\">";
4715 if ($action eq 'commitdiff') {
4718 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4722 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
4723 hash_base
=>$parent, file_name
=>$diff->{'file'})},
4726 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
4727 file_name
=>$diff->{'file'})},
4730 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
4731 file_name
=>$diff->{'file'})},
4735 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4736 my $mode_chnge = "";
4737 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4738 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4739 if ($from_file_type ne $to_file_type) {
4740 $mode_chnge .= " from $from_file_type to $to_file_type";
4742 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4743 if ($from_mode_str && $to_mode_str) {
4744 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4745 } elsif ($to_mode_str) {
4746 $mode_chnge .= " mode: $to_mode_str";
4749 $mode_chnge .= "]</span>\n";
4752 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4753 hash_base
=>$hash, file_name
=>$diff->{'file'}),
4754 -class => "list"}, esc_path
($diff->{'file'}));
4756 print "<td>$mode_chnge</td>\n";
4757 print "<td class=\"link\">";
4758 if ($action eq 'commitdiff') {
4761 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4764 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4765 # "commit" view and modified file (not onlu mode changed)
4766 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4767 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4768 hash_base
=>$hash, hash_parent_base
=>$parent,
4769 file_name
=>$diff->{'file'})},
4773 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4774 hash_base
=>$hash, file_name
=>$diff->{'file'})},
4777 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4778 file_name
=>$diff->{'file'})},
4781 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4782 file_name
=>$diff->{'file'})},
4786 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4787 my %status_name = ('R' => 'moved', 'C' => 'copied');
4788 my $nstatus = $status_name{$diff->{'status'}};
4790 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4791 # mode also for directories, so we cannot use $to_mode_str
4792 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4795 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
4796 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
4797 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
4798 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4799 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
4800 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
4801 -class => "list"}, esc_path
($diff->{'from_file'})) .
4802 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4803 "<td class=\"link\">";
4804 if ($action eq 'commitdiff') {
4807 print $cgi->a({-href
=> href
(-anchor
=>"patch$patchno")},
4810 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4811 # "commit" view and modified file (not only pure rename or copy)
4812 print $cgi->a({-href
=> href
(action
=>"blobdiff",
4813 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
4814 hash_base
=>$hash, hash_parent_base
=>$parent,
4815 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
4819 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
4820 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
4823 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
4824 file_name
=>$diff->{'to_file'})},
4827 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
4828 file_name
=>$diff->{'to_file'})},
4832 } # we should not encounter Unmerged (U) or Unknown (X) status
4835 print "</tbody>" if $has_header;
4839 sub format_diff_chunk
{
4842 my $first_class = $chunk[0]->[0];
4843 my @partial = map { $_->[1] } grep { $_->[0] eq $first_class } @chunk;
4845 if (scalar @partial < scalar @chunk) {
4846 return join '', ("<div class='chunk'><div class='old'>",
4849 "<div class='new'>",
4852 } @chunk[scalar @partial..scalar @chunk-1]),
4855 return join '', ("<div class='chunk'><div class='",
4856 ($first_class eq 'add' ?
'new' : 'old'),
4863 sub git_patchset_body
{
4864 my ($fd, $is_inline, $difftree, $hash, @hash_parents) = @_;
4865 my ($hash_parent) = $hash_parents[0];
4867 my $is_combined = (@hash_parents > 1);
4869 my $patch_number = 0;
4875 print "<div class=\"patchset\">\n";
4877 # skip to first patch
4878 while ($patch_line = <$fd>) {
4881 last if ($patch_line =~ m/^diff /);
4885 while ($patch_line) {
4887 # parse "git diff" header line
4888 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
4889 # $1 is from_name, which we do not use
4890 $to_name = unquote
($2);
4891 $to_name =~ s!^b/!!;
4892 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
4893 # $1 is 'cc' or 'combined', which we do not use
4894 $to_name = unquote
($2);
4899 # check if current patch belong to current raw line
4900 # and parse raw git-diff line if needed
4901 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
4902 # this is continuation of a split patch
4903 print "<div class=\"patch cont\">\n";
4905 # advance raw git-diff output if needed
4906 $patch_idx++ if defined $diffinfo;
4908 # read and prepare patch information
4909 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4911 # compact combined diff output can have some patches skipped
4912 # find which patch (using pathname of result) we are at now;
4914 while ($to_name ne $diffinfo->{'to_file'}) {
4915 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4916 format_diff_cc_simplified
($diffinfo, @hash_parents) .
4917 "</div>\n"; # class="patch"
4922 last if $patch_idx > $#$difftree;
4923 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
4927 # modifies %from, %to hashes
4928 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
4930 # this is first patch for raw difftree line with $patch_idx index
4931 # we index @$difftree array from 0, but number patches from 1
4932 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
4936 #assert($patch_line =~ m/^diff /) if DEBUG;
4937 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
4939 # print "git diff" header
4940 print format_git_diff_header_line
($patch_line, $diffinfo,
4943 # print extended diff header
4944 print "<div class=\"diff extended_header\">\n";
4946 while ($patch_line = <$fd>) {
4949 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
4951 print format_extended_diff_header_line
($patch_line, $diffinfo,
4954 print "</div>\n"; # class="diff extended_header"
4956 # from-file/to-file diff header
4957 if (! $patch_line) {
4958 print "</div>\n"; # class="patch"
4961 next PATCH
if ($patch_line =~ m/^diff /);
4962 #assert($patch_line =~ m/^---/) if DEBUG;
4964 my $last_patch_line = $patch_line;
4965 $patch_line = <$fd>;
4967 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
4969 print format_diff_from_to_header
($last_patch_line, $patch_line,
4970 $diffinfo, \
%from, \
%to,
4976 while ($patch_line = <$fd>) {
4979 next PATCH
if ($patch_line =~ m/^diff /);
4981 my ($class, $line) = process_diff_line
($patch_line, \
%from, \
%to);
4984 } elsif ($class eq 'add' || $class eq 'rem') {
4985 push @chunk, [ $class, $line ];
4988 print format_diff_chunk
(@chunk);
4990 } elsif ($class eq 'chunk_header') {
4993 print '<div class="chunk"><div class="old">',
4995 '</div><div class="new">',
5003 print "</div>\n"; # class="patch"
5006 # for compact combined (--cc) format, with chunk and patch simplification
5007 # the patchset might be empty, but there might be unprocessed raw lines
5008 for (++$patch_idx if $patch_number > 0;
5009 $patch_idx < @
$difftree;
5011 # read and prepare patch information
5012 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
5014 # generate anchor for "patch" links in difftree / whatchanged part
5015 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5016 format_diff_cc_simplified
($diffinfo, @hash_parents) .
5017 "</div>\n"; # class="patch"
5022 if ($patch_number == 0) {
5023 if (@hash_parents > 1) {
5024 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
5026 print "<div class=\"diff nodifferences\">No differences found</div>\n";
5030 print "</div>\n"; # class="patchset"
5033 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5035 # fills project list info (age, description, owner, category, forks)
5036 # for each project in the list, removing invalid projects from
5038 # NOTE: modifies $projlist, but does not remove entries from it
5039 sub fill_project_list_info
{
5040 my $projlist = shift;
5043 my $show_ctags = gitweb_check_feature
('ctags');
5045 foreach my $pr (@
$projlist) {
5046 my (@activity) = git_get_last_activity
($pr->{'path'});
5047 unless (@activity) {
5050 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
5051 if (!defined $pr->{'descr'}) {
5052 my $descr = git_get_project_description
($pr->{'path'}) || "";
5053 $descr = to_utf8
($descr);
5054 $pr->{'descr_long'} = $descr;
5055 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
5057 if (!defined $pr->{'owner'}) {
5058 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
5061 $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
5063 if ($projects_list_group_categories && !defined $pr->{'category'}) {
5064 my $cat = git_get_project_category
($pr->{'path'}) ||
5065 $project_list_default_category;
5066 $pr->{'category'} = to_utf8
($cat);
5069 push @projects, $pr;
5075 sub sort_projects_list
{
5076 my ($projlist, $order) = @_;
5080 project
=> { key
=> 'path', type
=> 'str' },
5081 descr
=> { key
=> 'descr_long', type
=> 'str' },
5082 owner
=> { key
=> 'owner', type
=> 'str' },
5083 age
=> { key
=> 'age', type
=> 'num' }
5085 my $oi = $order_info{$order};
5086 return @
$projlist unless defined $oi;
5087 if ($oi->{'type'} eq 'str') {
5088 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @
$projlist;
5090 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @
$projlist;
5096 # returns a hash of categories, containing the list of project
5097 # belonging to each category
5098 sub build_projlist_by_category
{
5099 my ($projlist, $from, $to) = @_;
5102 $from = 0 unless defined $from;
5103 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5105 for (my $i = $from; $i <= $to; $i++) {
5106 my $pr = $projlist->[$i];
5107 push @
{$categories{ $pr->{'category'} }}, $pr;
5110 return wantarray ?
%categories : \
%categories;
5113 # print 'sort by' <th> element, generating 'sort by $name' replay link
5114 # if that order is not selected
5116 print format_sort_th
(@_);
5119 sub format_sort_th
{
5120 my ($name, $order, $header) = @_;
5122 $header ||= ucfirst($name);
5124 if ($order eq $name) {
5125 $sort_th .= "<th>$header</th>\n";
5127 $sort_th .= "<th>" .
5128 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
5129 -class => "header"}, $header) .
5136 sub git_project_list_rows
{
5137 my ($projlist, $from, $to, $check_forks) = @_;
5139 $from = 0 unless defined $from;
5140 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5143 for (my $i = $from; $i <= $to; $i++) {
5144 my $pr = $projlist->[$i];
5147 print "<tr class=\"dark\">\n";
5149 print "<tr class=\"light\">\n";
5155 if ($pr->{'forks'}) {
5156 my $nforks = scalar @
{$pr->{'forks'}};
5158 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks"),
5159 -title
=> "$nforks forks"}, "+");
5161 print $cgi->span({-title
=> "$nforks forks"}, "+");
5166 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5167 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
5168 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
5169 -class => "list", -title
=> $pr->{'descr_long'}},
5170 esc_html
($pr->{'descr'})) . "</td>\n" .
5171 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
5172 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
5173 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
5174 "<td class=\"link\">" .
5175 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
5176 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
5177 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
5178 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
5179 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
5185 sub git_project_list_body
{
5186 # actually uses global variable $project
5187 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
5188 my @projects = @
$projlist;
5190 my $check_forks = gitweb_check_feature
('forks');
5191 my $show_ctags = gitweb_check_feature
('ctags');
5192 my $tagfilter = $show_ctags ?
$cgi->param('by_tag') : undef;
5193 $check_forks = undef
5194 if ($tagfilter || $searchtext);
5196 # filtering out forks before filling info allows to do less work
5197 @projects = filter_forks_from_projects_list
(\
@projects)
5199 @projects = fill_project_list_info
(\
@projects);
5200 # searching projects require filling to be run before it
5201 @projects = search_projects_list
(\
@projects,
5202 'searchtext' => $searchtext,
5203 'tagfilter' => $tagfilter)
5204 if ($tagfilter || $searchtext);
5206 $order ||= $default_projects_order;
5207 $from = 0 unless defined $from;
5208 $to = $#projects if (!defined $to || $#projects < $to);
5213 "<b>No such projects found</b><br />\n".
5214 "Click ".$cgi->a({-href
=>href
(project
=>undef)},"here")." to view all projects<br />\n".
5215 "</center>\n<br />\n";
5219 @projects = sort_projects_list
(\
@projects, $order);
5222 my $ctags = git_gather_all_ctags
(\
@projects);
5223 my $cloud = git_populate_project_tagcloud
($ctags);
5224 print git_show_project_tagcloud
($cloud, 64);
5227 print "<table class=\"project_list\">\n";
5228 unless ($no_header) {
5231 print "<th></th>\n";
5233 print_sort_th
('project', $order, 'Project');
5234 print_sort_th
('descr', $order, 'Description');
5235 print_sort_th
('owner', $order, 'Owner');
5236 print_sort_th
('age', $order, 'Last Change');
5237 print "<th></th>\n" . # for links
5241 if ($projects_list_group_categories) {
5242 # only display categories with projects in the $from-$to window
5243 @projects = sort {$a->{'category'} cmp $b->{'category'}} @projects[$from..$to];
5244 my %categories = build_projlist_by_category
(\
@projects, $from, $to);
5245 foreach my $cat (sort keys %categories) {
5246 unless ($cat eq "") {
5249 print "<td></td>\n";
5251 print "<td class=\"category\" colspan=\"5\">".esc_html
($cat)."</td>\n";
5255 git_project_list_rows
($categories{$cat}, undef, undef, $check_forks);
5258 git_project_list_rows
(\
@projects, $from, $to, $check_forks);
5261 if (defined $extra) {
5264 print "<td></td>\n";
5266 print "<td colspan=\"5\">$extra</td>\n" .
5273 # uses global variable $project
5274 my ($commitlist, $from, $to, $refs, $extra) = @_;
5276 $from = 0 unless defined $from;
5277 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5279 for (my $i = 0; $i <= $to; $i++) {
5280 my %co = %{$commitlist->[$i]};
5282 my $commit = $co{'id'};
5283 my $ref = format_ref_marker
($refs, $commit);
5284 git_print_header_div
('commit',
5285 "<span class=\"age\">$co{'age_string'}</span>" .
5286 esc_html
($co{'title'}) . $ref,
5288 print "<div class=\"title_text\">\n" .
5289 "<div class=\"log_link\">\n" .
5290 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
5292 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
5294 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
5297 git_print_authorship
(\
%co, -tag
=> 'span');
5298 print "<br/>\n</div>\n";
5300 print "<div class=\"log_body\">\n";
5301 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
5305 print "<div class=\"page_nav\">\n";
5311 sub git_shortlog_body
{
5312 # uses global variable $project
5313 my ($commitlist, $from, $to, $refs, $extra) = @_;
5315 $from = 0 unless defined $from;
5316 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5318 print "<table class=\"shortlog\">\n";
5320 for (my $i = $from; $i <= $to; $i++) {
5321 my %co = %{$commitlist->[$i]};
5322 my $commit = $co{'id'};
5323 my $ref = format_ref_marker
($refs, $commit);
5325 print "<tr class=\"dark\">\n";
5327 print "<tr class=\"light\">\n";
5330 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
5331 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5332 format_author_html
('td', \
%co, 10) . "<td>";
5333 print format_subject_html
($co{'title'}, $co{'title_short'},
5334 href
(action
=>"commit", hash
=>$commit), $ref);
5336 "<td class=\"link\">" .
5337 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
5338 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
5339 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
5340 my $snapshot_links = format_snapshot_links
($commit);
5341 if (defined $snapshot_links) {
5342 print " | " . $snapshot_links;
5347 if (defined $extra) {
5349 "<td colspan=\"4\">$extra</td>\n" .
5355 sub git_history_body
{
5356 # Warning: assumes constant type (blob or tree) during history
5357 my ($commitlist, $from, $to, $refs, $extra,
5358 $file_name, $file_hash, $ftype) = @_;
5360 $from = 0 unless defined $from;
5361 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
5363 print "<table class=\"history\">\n";
5365 for (my $i = $from; $i <= $to; $i++) {
5366 my %co = %{$commitlist->[$i]};
5370 my $commit = $co{'id'};
5372 my $ref = format_ref_marker
($refs, $commit);
5375 print "<tr class=\"dark\">\n";
5377 print "<tr class=\"light\">\n";
5380 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5381 # shortlog: format_author_html('td', \%co, 10)
5382 format_author_html
('td', \
%co, 15, 3) . "<td>";
5383 # originally git_history used chop_str($co{'title'}, 50)
5384 print format_subject_html
($co{'title'}, $co{'title_short'},
5385 href
(action
=>"commit", hash
=>$commit), $ref);
5387 "<td class=\"link\">" .
5388 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
5389 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
5391 if ($ftype eq 'blob') {
5392 my $blob_current = $file_hash;
5393 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
5394 if (defined $blob_current && defined $blob_parent &&
5395 $blob_current ne $blob_parent) {
5397 $cgi->a({-href
=> href
(action
=>"blobdiff",
5398 hash
=>$blob_current, hash_parent
=>$blob_parent,
5399 hash_base
=>$hash_base, hash_parent_base
=>$commit,
5400 file_name
=>$file_name)},
5407 if (defined $extra) {
5409 "<td colspan=\"4\">$extra</td>\n" .
5416 # uses global variable $project
5417 my ($taglist, $from, $to, $extra) = @_;
5418 $from = 0 unless defined $from;
5419 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
5421 print "<table class=\"tags\">\n";
5423 for (my $i = $from; $i <= $to; $i++) {
5424 my $entry = $taglist->[$i];
5426 my $comment = $tag{'subject'};
5428 if (defined $comment) {
5429 $comment_short = chop_str
($comment, 30, 5);
5432 print "<tr class=\"dark\">\n";
5434 print "<tr class=\"light\">\n";
5437 if (defined $tag{'age'}) {
5438 print "<td><i>$tag{'age'}</i></td>\n";
5440 print "<td></td>\n";
5443 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
5444 -class => "list name"}, esc_html
($tag{'name'})) .
5447 if (defined $comment) {
5448 print format_subject_html
($comment, $comment_short,
5449 href
(action
=>"tag", hash
=>$tag{'id'}));
5452 "<td class=\"selflink\">";
5453 if ($tag{'type'} eq "tag") {
5454 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
5459 "<td class=\"link\">" . " | " .
5460 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
5461 if ($tag{'reftype'} eq "commit") {
5462 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
5463 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
5464 } elsif ($tag{'reftype'} eq "blob") {
5465 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
5470 if (defined $extra) {
5472 "<td colspan=\"5\">$extra</td>\n" .
5478 sub git_heads_body
{
5479 # uses global variable $project
5480 my ($headlist, $head, $from, $to, $extra) = @_;
5481 $from = 0 unless defined $from;
5482 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
5484 print "<table class=\"heads\">\n";
5486 for (my $i = $from; $i <= $to; $i++) {
5487 my $entry = $headlist->[$i];
5489 my $curr = $ref{'id'} eq $head;
5491 print "<tr class=\"dark\">\n";
5493 print "<tr class=\"light\">\n";
5496 print "<td><i>$ref{'age'}</i></td>\n" .
5497 ($curr ?
"<td class=\"current_head\">" : "<td>") .
5498 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
5499 -class => "list name"},esc_html
($ref{'name'})) .
5501 "<td class=\"link\">" .
5502 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
5503 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
5504 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'fullname'})}, "tree") .
5508 if (defined $extra) {
5510 "<td colspan=\"3\">$extra</td>\n" .
5516 # Display a single remote block
5517 sub git_remote_block
{
5518 my ($remote, $rdata, $limit, $head) = @_;
5520 my $heads = $rdata->{'heads'};
5521 my $fetch = $rdata->{'fetch'};
5522 my $push = $rdata->{'push'};
5524 my $urls_table = "<table class=\"projects_list\">\n" ;
5526 if (defined $fetch) {
5527 if ($fetch eq $push) {
5528 $urls_table .= format_repo_url
("URL", $fetch);
5530 $urls_table .= format_repo_url
("Fetch URL", $fetch);
5531 $urls_table .= format_repo_url
("Push URL", $push) if defined $push;
5533 } elsif (defined $push) {
5534 $urls_table .= format_repo_url
("Push URL", $push);
5536 $urls_table .= format_repo_url
("", "No remote URL");
5539 $urls_table .= "</table>\n";
5542 if (defined $limit && $limit < @
$heads) {
5543 $dots = $cgi->a({-href
=> href
(action
=>"remotes", hash
=>$remote)}, "...");
5547 git_heads_body
($heads, $head, 0, $limit, $dots);
5550 # Display a list of remote names with the respective fetch and push URLs
5551 sub git_remotes_list
{
5552 my ($remotedata, $limit) = @_;
5553 print "<table class=\"heads\">\n";
5555 my @remotes = sort keys %$remotedata;
5557 my $limited = $limit && $limit < @remotes;
5559 $#remotes = $limit - 1 if $limited;
5561 while (my $remote = shift @remotes) {
5562 my $rdata = $remotedata->{$remote};
5563 my $fetch = $rdata->{'fetch'};
5564 my $push = $rdata->{'push'};
5566 print "<tr class=\"dark\">\n";
5568 print "<tr class=\"light\">\n";
5572 $cgi->a({-href
=> href
(action
=>'remotes', hash
=>$remote),
5573 -class=> "list name"},esc_html
($remote)) .
5575 print "<td class=\"link\">" .
5576 (defined $fetch ?
$cgi->a({-href
=> $fetch}, "fetch") : "fetch") .
5578 (defined $push ?
$cgi->a({-href
=> $push}, "push") : "push") .
5586 "<td colspan=\"3\">" .
5587 $cgi->a({-href
=> href
(action
=>"remotes")}, "...") .
5588 "</td>\n" . "</tr>\n";
5594 # Display remote heads grouped by remote, unless there are too many
5595 # remotes, in which case we only display the remote names
5596 sub git_remotes_body
{
5597 my ($remotedata, $limit, $head) = @_;
5598 if ($limit and $limit < keys %$remotedata) {
5599 git_remotes_list
($remotedata, $limit);
5601 fill_remote_heads
($remotedata);
5602 while (my ($remote, $rdata) = each %$remotedata) {
5603 git_print_section
({-class=>"remote", -id
=>$remote},
5604 ["remotes", $remote, $remote], sub {
5605 git_remote_block
($remote, $rdata, $limit, $head);
5611 sub git_search_message
{
5615 if ($searchtype eq 'commit') {
5616 $greptype = "--grep=";
5617 } elsif ($searchtype eq 'author') {
5618 $greptype = "--author=";
5619 } elsif ($searchtype eq 'committer') {
5620 $greptype = "--committer=";
5622 $greptype .= $searchtext;
5623 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5624 $greptype, '--regexp-ignore-case',
5625 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5627 my $paging_nav = '';
5630 $cgi->a({-href
=> href
(-replay
=>1, page
=>undef)},
5633 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5634 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5636 $paging_nav .= "first ⋅ prev";
5639 if ($#commitlist >= 100) {
5641 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5642 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5643 $paging_nav .= " ⋅ $next_link";
5645 $paging_nav .= " ⋅ next";
5650 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5651 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5652 if ($page == 0 && !@commitlist) {
5653 print "<p>No match.</p>\n";
5655 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5661 sub git_search_changes
{
5665 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5666 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5667 ($search_use_regexp ?
'--pickaxe-regex' : ())
5668 or die_error
(500, "Open git-log failed");
5672 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5673 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5675 print "<table class=\"pickaxe search\">\n";
5679 while (my $line = <$fd>) {
5683 my %set = parse_difftree_raw_line
($line);
5684 if (defined $set{'commit'}) {
5685 # finish previous commit
5688 "<td class=\"link\">" .
5689 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5692 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5693 hash_base
=>$co{'id'})},
5700 print "<tr class=\"dark\">\n";
5702 print "<tr class=\"light\">\n";
5705 %co = parse_commit
($set{'commit'});
5706 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5707 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5708 "<td><i>$author</i></td>\n" .
5710 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5711 -class => "list subject"},
5712 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5713 } elsif (defined $set{'to_id'}) {
5714 next if ($set{'to_id'} =~ m/^0{40}$/);
5716 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5717 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5719 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5725 # finish last commit (warning: repetition!)
5728 "<td class=\"link\">" .
5729 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})},
5732 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'},
5733 hash_base
=>$co{'id'})},
5744 sub git_search_files
{
5748 open my $fd, "-|", git_cmd
(), 'grep', '-n',
5749 $search_use_regexp ?
('-E', '-i') : '-F',
5750 $searchtext, $co{'tree'}
5751 or die_error
(500, "Open git-grep failed");
5755 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5756 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5758 print "<table class=\"grep_search\">\n";
5762 while (my $line = <$fd>) {
5764 my ($file, $lno, $ltext, $binary);
5765 last if ($matches++ > 1000);
5766 if ($line =~ /^Binary file (.+) matches$/) {
5770 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5772 if ($file ne $lastfile) {
5773 $lastfile and print "</td></tr>\n";
5775 print "<tr class=\"dark\">\n";
5777 print "<tr class=\"light\">\n";
5779 print "<td class=\"list\">".
5780 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5781 file_name
=>"$file"),
5782 -class => "list"}, esc_path
($file));
5783 print "</td><td>\n";
5787 print "<div class=\"binary\">Binary file</div>\n";
5789 $ltext = untabify
($ltext);
5790 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5791 $ltext = esc_html
($1, -nbsp
=>1);
5792 $ltext .= '<span class="match">';
5793 $ltext .= esc_html
($2, -nbsp
=>1);
5794 $ltext .= '</span>';
5795 $ltext .= esc_html
($3, -nbsp
=>1);
5797 $ltext = esc_html
($ltext, -nbsp
=>1);
5799 print "<div class=\"pre\">" .
5800 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5801 file_name
=>"$file").'#l'.$lno,
5802 -class => "linenr"}, sprintf('%4i', $lno))
5803 . ' ' . $ltext . "</div>\n";
5807 print "</td></tr>\n";
5808 if ($matches > 1000) {
5809 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5812 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5821 sub git_search_grep_body
{
5822 my ($commitlist, $from, $to, $extra) = @_;
5823 $from = 0 unless defined $from;
5824 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5826 print "<table class=\"commit_search\">\n";
5828 for (my $i = $from; $i <= $to; $i++) {
5829 my %co = %{$commitlist->[$i]};
5833 my $commit = $co{'id'};
5835 print "<tr class=\"dark\">\n";
5837 print "<tr class=\"light\">\n";
5840 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5841 format_author_html
('td', \
%co, 15, 5) .
5843 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5844 -class => "list subject"},
5845 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5846 my $comment = $co{'comment'};
5847 foreach my $line (@
$comment) {
5848 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5849 my ($lead, $match, $trail) = ($1, $2, $3);
5850 $match = chop_str
($match, 70, 5, 'center');
5851 my $contextlen = int((80 - length($match))/2);
5852 $contextlen = 30 if ($contextlen > 30);
5853 $lead = chop_str
($lead, $contextlen, 10, 'left');
5854 $trail = chop_str
($trail, $contextlen, 10, 'right');
5856 $lead = esc_html
($lead);
5857 $match = esc_html
($match);
5858 $trail = esc_html
($trail);
5860 print "$lead<span class=\"match\">$match</span>$trail<br />";
5864 "<td class=\"link\">" .
5865 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5867 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
5869 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5873 if (defined $extra) {
5875 "<td colspan=\"3\">$extra</td>\n" .
5881 ## ======================================================================
5882 ## ======================================================================
5885 sub git_project_list
{
5886 my $order = $input_params{'order'};
5887 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5888 die_error
(400, "Unknown order parameter");
5891 my @list = git_get_projects_list
();
5893 die_error
(404, "No projects found");
5897 if (defined $home_text && -f
$home_text) {
5898 print "<div class=\"index_include\">\n";
5899 insert_file
($home_text);
5902 print $cgi->startform(-method
=> "get") .
5903 "<p class=\"projsearch\">Search:\n" .
5904 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
5906 $cgi->end_form() . "\n";
5907 git_project_list_body
(\
@list, $order);
5912 my $order = $input_params{'order'};
5913 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5914 die_error
(400, "Unknown order parameter");
5917 my @list = git_get_projects_list
($project);
5919 die_error
(404, "No forks found");
5923 git_print_page_nav
('','');
5924 git_print_header_div
('summary', "$project forks");
5925 git_project_list_body
(\
@list, $order);
5929 sub git_project_index
{
5930 my @projects = git_get_projects_list
();
5932 die_error
(404, "No projects found");
5936 -type
=> 'text/plain',
5937 -charset
=> 'utf-8',
5938 -content_disposition
=> 'inline; filename="index.aux"');
5940 foreach my $pr (@projects) {
5941 if (!exists $pr->{'owner'}) {
5942 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
5945 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
5946 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
5947 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5948 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
5952 print "$path $owner\n";
5957 my $descr = git_get_project_description
($project) || "none";
5958 my %co = parse_commit
("HEAD");
5959 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
5960 my $head = $co{'id'};
5961 my $remote_heads = gitweb_check_feature
('remote_heads');
5963 my $owner = git_get_project_owner
($project);
5965 my $refs = git_get_references
();
5966 # These get_*_list functions return one more to allow us to see if
5967 # there are more ...
5968 my @taglist = git_get_tags_list
(16);
5969 my @headlist = git_get_heads_list
(16);
5970 my %remotedata = $remote_heads ? git_get_remotes_list
() : ();
5972 my $check_forks = gitweb_check_feature
('forks');
5975 # find forks of a project
5976 @forklist = git_get_projects_list
($project);
5977 # filter out forks of forks
5978 @forklist = filter_forks_from_projects_list
(\
@forklist)
5983 git_print_page_nav
('summary','', $head);
5985 print "<div class=\"title\"> </div>\n";
5986 print "<table class=\"projects_list\">\n" .
5987 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
5988 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
5989 if (defined $cd{'rfc2822'}) {
5990 print "<tr id=\"metadata_lchange\"><td>last change</td>" .
5991 "<td>".format_timestamp_html
(\
%cd)."</td></tr>\n";
5994 # use per project git URL list in $projectroot/$project/cloneurl
5995 # or make project git URL from git base URL and project name
5996 my $url_tag = "URL";
5997 my @url_list = git_get_project_url_list
($project);
5998 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
5999 foreach my $git_url (@url_list) {
6000 next unless $git_url;
6001 print format_repo_url
($url_tag, $git_url);
6006 my $show_ctags = gitweb_check_feature
('ctags');
6008 my $ctags = git_get_project_ctags
($project);
6010 # without ability to add tags, don't show if there are none
6011 my $cloud = git_populate_project_tagcloud
($ctags);
6012 print "<tr id=\"metadata_ctags\">" .
6013 "<td>content tags</td>" .
6014 "<td>".git_show_project_tagcloud
($cloud, 48)."</td>" .
6021 # If XSS prevention is on, we don't include README.html.
6022 # TODO: Allow a readme in some safe format.
6023 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
6024 print "<div class=\"title\">readme</div>\n" .
6025 "<div class=\"readme\">\n";
6026 insert_file
("$projectroot/$project/README.html");
6027 print "\n</div>\n"; # class="readme"
6030 # we need to request one more than 16 (0..15) to check if
6032 my @commitlist = $head ? parse_commits
($head, 17) : ();
6034 git_print_header_div
('shortlog');
6035 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
6036 $#commitlist <= 15 ?
undef :
6037 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
6041 git_print_header_div
('tags');
6042 git_tags_body
(\
@taglist, 0, 15,
6043 $#taglist <= 15 ?
undef :
6044 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
6048 git_print_header_div
('heads');
6049 git_heads_body
(\
@headlist, $head, 0, 15,
6050 $#headlist <= 15 ?
undef :
6051 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
6055 git_print_header_div
('remotes');
6056 git_remotes_body
(\
%remotedata, 15, $head);
6060 git_print_header_div
('forks');
6061 git_project_list_body
(\
@forklist, 'age', 0, 15,
6062 $#forklist <= 15 ?
undef :
6063 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
6071 my %tag = parse_tag
($hash);
6074 die_error
(404, "Unknown tag object");
6077 my $head = git_get_head_hash
($project);
6079 git_print_page_nav
('','', $head,undef,$head);
6080 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
6081 print "<div class=\"title_text\">\n" .
6082 "<table class=\"object_header\">\n" .
6084 "<td>object</td>\n" .
6085 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6086 $tag{'object'}) . "</td>\n" .
6087 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
6088 $tag{'type'}) . "</td>\n" .
6090 if (defined($tag{'author'})) {
6091 git_print_authorship_rows
(\
%tag, 'author');
6093 print "</table>\n\n" .
6095 print "<div class=\"page_body\">";
6096 my $comment = $tag{'comment'};
6097 foreach my $line (@
$comment) {
6099 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
6105 sub git_blame_common
{
6106 my $format = shift || 'porcelain';
6107 if ($format eq 'porcelain' && $cgi->param('js')) {
6108 $format = 'incremental';
6109 $action = 'blame_incremental'; # for page title etc
6113 gitweb_check_feature
('blame')
6114 or die_error
(403, "Blame view not allowed");
6117 die_error
(400, "No file name given") unless $file_name;
6118 $hash_base ||= git_get_head_hash
($project);
6119 die_error
(404, "Couldn't find base commit") unless $hash_base;
6120 my %co = parse_commit
($hash_base)
6121 or die_error
(404, "Commit not found");
6123 if (!defined $hash) {
6124 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
6125 or die_error
(404, "Error looking up file");
6127 $ftype = git_get_type
($hash);
6128 if ($ftype !~ "blob") {
6129 die_error
(400, "Object is not a blob");
6134 if ($format eq 'incremental') {
6135 # get file contents (as base)
6136 open $fd, "-|", git_cmd
(), 'cat-file', 'blob', $hash
6137 or die_error
(500, "Open git-cat-file failed");
6138 } elsif ($format eq 'data') {
6139 # run git-blame --incremental
6140 open $fd, "-|", git_cmd
(), "blame", "--incremental",
6141 $hash_base, "--", $file_name
6142 or die_error
(500, "Open git-blame --incremental failed");
6144 # run git-blame --porcelain
6145 open $fd, "-|", git_cmd
(), "blame", '-p',
6146 $hash_base, '--', $file_name
6147 or die_error
(500, "Open git-blame --porcelain failed");
6150 # incremental blame data returns early
6151 if ($format eq 'data') {
6153 -type
=>"text/plain", -charset
=> "utf-8",
6154 -status
=> "200 OK");
6155 local $| = 1; # output autoflush
6158 or print "ERROR $!\n";
6161 if (defined $t0 && gitweb_check_feature
('timed')) {
6163 tv_interval
($t0, [ gettimeofday
() ]).
6164 ' '.$number_of_git_cmds;
6174 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
6177 if ($format eq 'incremental') {
6179 $cgi->a({-href
=> href
(action
=>"blame", javascript
=>0, -replay
=>1)},
6180 "blame") . " (non-incremental)";
6183 $cgi->a({-href
=> href
(action
=>"blame_incremental", -replay
=>1)},
6184 "blame") . " (incremental)";
6188 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6191 $cgi->a({-href
=> href
(action
=>$action, file_name
=>$file_name)},
6193 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6194 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6195 git_print_page_path
($file_name, $ftype, $hash_base);
6198 if ($format eq 'incremental') {
6199 print "<noscript>\n<div class=\"error\"><center><b>\n".
6200 "This page requires JavaScript to run.\n Use ".
6201 $cgi->a({-href
=> href
(action
=>'blame',javascript
=>0,-replay
=>1)},
6204 "</b></center></div>\n</noscript>\n";
6206 print qq!<div id
="progress_bar" style
="width: 100%; background-color: yellow"></div
>\n!;
6209 print qq!<div
class="page_body">\n!;
6210 print qq!<div id
="progress_info">... / ...</div
>\n!
6211 if ($format eq 'incremental');
6212 print qq!<table id
="blame_table" class="blame" width
="100%">\n!.
6213 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
6215 qq!<tr
><th
>Commit
</th><th>Line</th
><th
>Data
</th></tr
>\n!.
6219 my @rev_color = qw(light dark);
6220 my $num_colors = scalar(@rev_color);
6221 my $current_color = 0;
6223 if ($format eq 'incremental') {
6224 my $color_class = $rev_color[$current_color];
6229 while (my $line = <$fd>) {
6233 print qq!<tr id
="l$linenr" class="$color_class">!.
6234 qq!<td
class="sha1"><a href
=""> </a></td
>!.
6235 qq!<td
class="linenr">!.
6236 qq!<a
class="linenr" href
="">$linenr</a></td
>!;
6237 print qq!<td
class="pre">! . esc_html
($line) . "</td>\n";
6241 } else { # porcelain, i.e. ordinary blame
6242 my %metainfo = (); # saves information about commits
6246 while (my $line = <$fd>) {
6248 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
6249 # no <lines in group> for subsequent lines in group of lines
6250 my ($full_rev, $orig_lineno, $lineno, $group_size) =
6251 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
6252 if (!exists $metainfo{$full_rev}) {
6253 $metainfo{$full_rev} = { 'nprevious' => 0 };
6255 my $meta = $metainfo{$full_rev};
6257 while ($data = <$fd>) {
6259 last if ($data =~ s/^\t//); # contents of line
6260 if ($data =~ /^(\S+)(?: (.*))?$/) {
6261 $meta->{$1} = $2 unless exists $meta->{$1};
6263 if ($data =~ /^previous /) {
6264 $meta->{'nprevious'}++;
6267 my $short_rev = substr($full_rev, 0, 8);
6268 my $author = $meta->{'author'};
6270 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
6271 my $date = $date{'iso-tz'};
6273 $current_color = ($current_color + 1) % $num_colors;
6275 my $tr_class = $rev_color[$current_color];
6276 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
6277 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
6278 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
6279 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
6281 print "<td class=\"sha1\"";
6282 print " title=\"". esc_html
($author) . ", $date\"";
6283 print " rowspan=\"$group_size\"" if ($group_size > 1);
6285 print $cgi->a({-href
=> href
(action
=>"commit",
6287 file_name
=>$file_name)},
6288 esc_html
($short_rev));
6289 if ($group_size >= 2) {
6290 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
6291 if (@author_initials) {
6293 esc_html
(join('', @author_initials));
6299 # 'previous' <sha1 of parent commit> <filename at commit>
6300 if (exists $meta->{'previous'} &&
6301 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
6302 $meta->{'parent'} = $1;
6303 $meta->{'file_parent'} = unquote
($2);
6306 exists($meta->{'parent'}) ?
6307 $meta->{'parent'} : $full_rev;
6308 my $linenr_filename =
6309 exists($meta->{'file_parent'}) ?
6310 $meta->{'file_parent'} : unquote
($meta->{'filename'});
6311 my $blamed = href
(action
=> 'blame',
6312 file_name
=> $linenr_filename,
6313 hash_base
=> $linenr_commit);
6314 print "<td class=\"linenr\">";
6315 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
6316 -class => "linenr" },
6319 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
6327 "</table>\n"; # class="blame"
6328 print "</div>\n"; # class="blame_body"
6330 or print "Reading blob failed\n";
6339 sub git_blame_incremental
{
6340 git_blame_common
('incremental');
6343 sub git_blame_data
{
6344 git_blame_common
('data');
6348 my $head = git_get_head_hash
($project);
6350 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('tags'));
6351 git_print_header_div
('summary', $project);
6353 my @tagslist = git_get_tags_list
();
6355 git_tags_body
(\
@tagslist);
6361 my $head = git_get_head_hash
($project);
6363 git_print_page_nav
('','', $head,undef,$head,format_ref_views
('heads'));
6364 git_print_header_div
('summary', $project);
6366 my @headslist = git_get_heads_list
();
6368 git_heads_body
(\
@headslist, $head);
6373 # used both for single remote view and for list of all the remotes
6375 gitweb_check_feature
('remote_heads')
6376 or die_error
(403, "Remote heads view is disabled");
6378 my $head = git_get_head_hash
($project);
6379 my $remote = $input_params{'hash'};
6381 my $remotedata = git_get_remotes_list
($remote);
6382 die_error
(500, "Unable to get remote information") unless defined $remotedata;
6384 unless (%$remotedata) {
6385 die_error
(404, defined $remote ?
6386 "Remote $remote not found" :
6387 "No remotes found");
6390 git_header_html
(undef, undef, -action_extra
=> $remote);
6391 git_print_page_nav
('', '', $head, undef, $head,
6392 format_ref_views
($remote ?
'' : 'remotes'));
6394 fill_remote_heads
($remotedata);
6395 if (defined $remote) {
6396 git_print_header_div
('remotes', "$remote remote for $project");
6397 git_remote_block
($remote, $remotedata->{$remote}, undef, $head);
6399 git_print_header_div
('summary', "$project remotes");
6400 git_remotes_body
($remotedata, undef, $head);
6406 sub git_blob_plain
{
6410 if (!defined $hash) {
6411 if (defined $file_name) {
6412 my $base = $hash_base || git_get_head_hash
($project);
6413 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6414 or die_error
(404, "Cannot find file");
6416 die_error
(400, "No file name defined");
6418 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6419 # blobs defined by non-textual hash id's can be cached
6423 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6424 or die_error
(500, "Open git-cat-file blob '$hash' failed");
6426 # content-type (can include charset)
6427 $type = blob_contenttype
($fd, $file_name, $type);
6429 # "save as" filename, even when no $file_name is given
6430 my $save_as = "$hash";
6431 if (defined $file_name) {
6432 $save_as = $file_name;
6433 } elsif ($type =~ m/^text\//) {
6437 # With XSS prevention on, blobs of all types except a few known safe
6438 # ones are served with "Content-Disposition: attachment" to make sure
6439 # they don't run in our security domain. For certain image types,
6440 # blob view writes an <img> tag referring to blob_plain view, and we
6441 # want to be sure not to break that by serving the image as an
6442 # attachment (though Firefox 3 doesn't seem to care).
6443 my $sandbox = $prevent_xss &&
6444 $type !~ m!^(?:text/[a-z]+|image/(?:gif|png|jpeg))(?:[ ;]|$)!;
6446 # serve text/* as text/plain
6448 ($type =~ m!^text/[a-z]+\b(.*)$! ||
6449 ($type =~ m!^[a-z]+/[a-z]\+xml\b(.*)$! && -T
$fd))) {
6451 $rest = defined $rest ?
$rest : '';
6452 $type = "text/plain$rest";
6457 -expires
=> $expires,
6458 -content_disposition
=>
6459 ($sandbox ?
'attachment' : 'inline')
6460 . '; filename="' . $save_as . '"');
6462 binmode STDOUT
, ':raw';
6464 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6471 if (!defined $hash) {
6472 if (defined $file_name) {
6473 my $base = $hash_base || git_get_head_hash
($project);
6474 $hash = git_get_hash_by_path
($base, $file_name, "blob")
6475 or die_error
(404, "Cannot find file");
6477 die_error
(400, "No file name defined");
6479 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6480 # blobs defined by non-textual hash id's can be cached
6484 my $have_blame = gitweb_check_feature
('blame');
6485 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
6486 or die_error
(500, "Couldn't cat $file_name, $hash");
6487 my $mimetype = blob_mimetype
($fd, $file_name);
6488 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
6489 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
6491 return git_blob_plain
($mimetype);
6493 # we can have blame only for text/* mimetype
6494 $have_blame &&= ($mimetype =~ m!^text/!);
6496 my $highlight = gitweb_check_feature
('highlight');
6497 my $syntax = guess_file_syntax
($highlight, $mimetype, $file_name);
6498 $fd = run_highlighter
($fd, $highlight, $syntax)
6501 git_header_html
(undef, $expires);
6502 my $formats_nav = '';
6503 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6504 if (defined $file_name) {
6507 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
6512 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6515 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6518 $cgi->a({-href
=> href
(action
=>"blob",
6519 hash_base
=>"HEAD", file_name
=>$file_name)},
6523 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
6526 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6527 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
6529 print "<div class=\"page_nav\">\n" .
6530 "<br/><br/></div>\n" .
6531 "<div class=\"title\">".esc_html
($hash)."</div>\n";
6533 git_print_page_path
($file_name, "blob", $hash_base);
6534 print "<div class=\"page_body\">\n";
6535 if ($mimetype =~ m!^image/!) {
6536 print qq!<img type
="!.esc_attr($mimetype).qq!"!;
6538 print qq! alt
="!.esc_attr($file_name).qq!" title
="!.esc_attr($file_name).qq!"!;
6541 href(action=>"blob_plain
", hash=>$hash,
6542 hash_base=>$hash_base, file_name=>$file_name) .
6546 while (my $line = <$fd>) {
6549 $line = untabify
($line);
6550 printf qq!<div
class="pre"><a id
="l%i" href
="%s#l%i" class="linenr">%4i</a> %s</div
>\n!,
6551 $nr, esc_attr
(href
(-replay
=> 1)), $nr, $nr,
6552 $syntax ? sanitize
($line) : esc_html
($line, -nbsp
=>1);
6556 or print "Reading blob failed.\n";
6562 if (!defined $hash_base) {
6563 $hash_base = "HEAD";
6565 if (!defined $hash) {
6566 if (defined $file_name) {
6567 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
6572 die_error
(404, "No such tree") unless defined($hash);
6574 my $show_sizes = gitweb_check_feature
('show-sizes');
6575 my $have_blame = gitweb_check_feature
('blame');
6580 open my $fd, "-|", git_cmd
(), "ls-tree", '-z',
6581 ($show_sizes ?
'-l' : ()), @extra_options, $hash
6582 or die_error
(500, "Open git-ls-tree failed");
6583 @entries = map { chomp; $_ } <$fd>;
6585 or die_error
(404, "Reading tree failed");
6588 my $refs = git_get_references
();
6589 my $ref = format_ref_marker
($refs, $hash_base);
6592 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
6594 if (defined $file_name) {
6596 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
6598 $cgi->a({-href
=> href
(action
=>"tree",
6599 hash_base
=>"HEAD", file_name
=>$file_name)},
6602 my $snapshot_links = format_snapshot_links
($hash);
6603 if (defined $snapshot_links) {
6604 # FIXME: Should be available when we have no hash base as well.
6605 push @views_nav, $snapshot_links;
6607 git_print_page_nav
('tree','', $hash_base, undef, undef,
6608 join(' | ', @views_nav));
6609 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
6612 print "<div class=\"page_nav\">\n";
6613 print "<br/><br/></div>\n";
6614 print "<div class=\"title\">".esc_html
($hash)."</div>\n";
6616 if (defined $file_name) {
6617 $basedir = $file_name;
6618 if ($basedir ne '' && substr($basedir, -1) ne '/') {
6621 git_print_page_path
($file_name, 'tree', $hash_base);
6623 print "<div class=\"page_body\">\n";
6624 print "<table class=\"tree\">\n";
6626 # '..' (top directory) link if possible
6627 if (defined $hash_base &&
6628 defined $file_name && $file_name =~ m![^/]+$!) {
6630 print "<tr class=\"dark\">\n";
6632 print "<tr class=\"light\">\n";
6636 my $up = $file_name;
6637 $up =~ s!/?[^/]+$!!;
6638 undef $up unless $up;
6639 # based on git_print_tree_entry
6640 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
6641 print '<td class="size"> </td>'."\n" if $show_sizes;
6642 print '<td class="list">';
6643 print $cgi->a({-href
=> href
(action
=>"tree",
6644 hash_base
=>$hash_base,
6648 print "<td class=\"link\"></td>\n";
6652 foreach my $line (@entries) {
6653 my %t = parse_ls_tree_line
($line, -z
=> 1, -l
=> $show_sizes);
6656 print "<tr class=\"dark\">\n";
6658 print "<tr class=\"light\">\n";
6662 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
6666 print "</table>\n" .
6672 my ($project, $hash) = @_;
6674 # path/to/project.git -> project
6675 # path/to/project/.git -> project
6676 my $name = to_utf8
($project);
6677 $name =~ s
,([^/])/*\
.git
$,$1,;
6678 $name = basename
($name);
6680 $name =~ s/[[:cntrl:]]/?/g;
6683 if ($hash =~ /^[0-9a-fA-F]+$/) {
6684 # shorten SHA-1 hash
6685 my $full_hash = git_get_full_hash
($project, $hash);
6686 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
6687 $ver = git_get_short_hash
($project, $hash);
6689 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
6690 # tags don't need shortened SHA-1 hash
6693 # branches and other need shortened SHA-1 hash
6694 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
6697 $ver .= '-' . git_get_short_hash
($project, $hash);
6699 # in case of hierarchical branch names
6702 # name = project-version_string
6703 $name = "$name-$ver";
6705 return wantarray ?
($name, $name) : $name;
6709 my $format = $input_params{'snapshot_format'};
6710 if (!@snapshot_fmts) {
6711 die_error
(403, "Snapshots not allowed");
6713 # default to first supported snapshot format
6714 $format ||= $snapshot_fmts[0];
6715 if ($format !~ m/^[a-z0-9]+$/) {
6716 die_error
(400, "Invalid snapshot format parameter");
6717 } elsif (!exists($known_snapshot_formats{$format})) {
6718 die_error
(400, "Unknown snapshot format");
6719 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
6720 die_error
(403, "Snapshot format not allowed");
6721 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
6722 die_error
(403, "Unsupported snapshot format");
6725 my $type = git_get_type
("$hash^{}");
6727 die_error
(404, 'Object does not exist');
6728 } elsif ($type eq 'blob') {
6729 die_error
(400, 'Object is not a tree-ish');
6732 my ($name, $prefix) = snapshot_name
($project, $hash);
6733 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
6734 my $cmd = quote_command
(
6735 git_cmd
(), 'archive',
6736 "--format=$known_snapshot_formats{$format}{'format'}",
6737 "--prefix=$prefix/", $hash);
6738 if (exists $known_snapshot_formats{$format}{'compressor'}) {
6739 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
6742 $filename =~ s/(["\\])/\\$1/g;
6744 -type
=> $known_snapshot_formats{$format}{'type'},
6745 -content_disposition
=> 'inline; filename="' . $filename . '"',
6746 -status
=> '200 OK');
6748 open my $fd, "-|", $cmd
6749 or die_error
(500, "Execute git-archive failed");
6750 binmode STDOUT
, ':raw';
6752 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
6756 sub git_log_generic
{
6757 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
6759 my $head = git_get_head_hash
($project);
6760 if (!defined $base) {
6763 if (!defined $page) {
6766 my $refs = git_get_references
();
6768 my $commit_hash = $base;
6769 if (defined $parent) {
6770 $commit_hash = "$parent..$base";
6773 parse_commits
($commit_hash, 101, (100 * $page),
6774 defined $file_name ?
($file_name, "--full-history") : ());
6777 if (!defined $file_hash && defined $file_name) {
6778 # some commits could have deleted file in question,
6779 # and not have it in tree, but one of them has to have it
6780 for (my $i = 0; $i < @commitlist; $i++) {
6781 $file_hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
6782 last if defined $file_hash;
6785 if (defined $file_hash) {
6786 $ftype = git_get_type
($file_hash);
6788 if (defined $file_name && !defined $ftype) {
6789 die_error
(500, "Unknown type of object");
6792 if (defined $file_name) {
6793 %co = parse_commit
($base)
6794 or die_error
(404, "Unknown commit object");
6798 my $paging_nav = format_paging_nav
($fmt_name, $page, $#commitlist >= 100);
6800 if ($#commitlist >= 100) {
6802 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6803 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
6805 my $patch_max = gitweb_get_feature
('patches');
6806 if ($patch_max && !defined $file_name) {
6807 if ($patch_max < 0 || @commitlist <= $patch_max) {
6808 $paging_nav .= " ⋅ " .
6809 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
6815 git_print_page_nav
($fmt_name,'', $hash,$hash,$hash, $paging_nav);
6816 if (defined $file_name) {
6817 git_print_header_div
('commit', esc_html
($co{'title'}), $base);
6819 git_print_header_div
('summary', $project)
6821 git_print_page_path
($file_name, $ftype, $hash_base)
6822 if (defined $file_name);
6824 $body_subr->(\
@commitlist, 0, 99, $refs, $next_link,
6825 $file_name, $file_hash, $ftype);
6831 git_log_generic
('log', \
&git_log_body
,
6832 $hash, $hash_parent);
6836 $hash ||= $hash_base || "HEAD";
6837 my %co = parse_commit
($hash)
6838 or die_error
(404, "Unknown commit object");
6840 my $parent = $co{'parent'};
6841 my $parents = $co{'parents'}; # listref
6843 # we need to prepare $formats_nav before any parameter munging
6845 if (!defined $parent) {
6847 $formats_nav .= '(initial)';
6848 } elsif (@
$parents == 1) {
6849 # single parent commit
6852 $cgi->a({-href
=> href
(action
=>"commit",
6854 esc_html
(substr($parent, 0, 7))) .
6861 $cgi->a({-href
=> href
(action
=>"commit",
6863 esc_html
(substr($_, 0, 7)));
6867 if (gitweb_check_feature
('patches') && @
$parents <= 1) {
6868 $formats_nav .= " | " .
6869 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
6873 if (!defined $parent) {
6877 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
6879 (@
$parents <= 1 ?
$parent : '-c'),
6881 or die_error
(500, "Open git-diff-tree failed");
6882 @difftree = map { chomp; $_ } <$fd>;
6883 close $fd or die_error
(404, "Reading git-diff-tree failed");
6885 # non-textual hash id's can be cached
6887 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6890 my $refs = git_get_references
();
6891 my $ref = format_ref_marker
($refs, $co{'id'});
6893 git_header_html
(undef, $expires);
6894 git_print_page_nav
('commit', '',
6895 $hash, $co{'tree'}, $hash,
6898 if (defined $co{'parent'}) {
6899 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
6901 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
6903 print "<div class=\"title_text\">\n" .
6904 "<table class=\"object_header\">\n";
6905 git_print_authorship_rows
(\
%co);
6906 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
6909 "<td class=\"sha1\">" .
6910 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
6911 class => "list"}, $co{'tree'}) .
6913 "<td class=\"link\">" .
6914 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
6916 my $snapshot_links = format_snapshot_links
($hash);
6917 if (defined $snapshot_links) {
6918 print " | " . $snapshot_links;
6923 foreach my $par (@
$parents) {
6926 "<td class=\"sha1\">" .
6927 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
6928 class => "list"}, $par) .
6930 "<td class=\"link\">" .
6931 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
6933 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
6940 print "<div class=\"page_body\">\n";
6941 git_print_log
($co{'comment'});
6944 git_difftree_body
(\
@difftree, $hash, @
$parents);
6950 # object is defined by:
6951 # - hash or hash_base alone
6952 # - hash_base and file_name
6955 # - hash or hash_base alone
6956 if ($hash || ($hash_base && !defined $file_name)) {
6957 my $object_id = $hash || $hash_base;
6959 open my $fd, "-|", quote_command
(
6960 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
6961 or die_error
(404, "Object does not exist");
6965 or die_error
(404, "Object does not exist");
6967 # - hash_base and file_name
6968 } elsif ($hash_base && defined $file_name) {
6969 $file_name =~ s
,/+$,,;
6971 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
6972 or die_error
(404, "Base object does not exist");
6974 # here errors should not hapen
6975 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
6976 or die_error
(500, "Open git-ls-tree failed");
6980 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
6981 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
6982 die_error
(404, "File or directory for given base does not exist");
6987 die_error
(400, "Not enough information to find object");
6990 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
6991 hash
=>$hash, hash_base
=>$hash_base,
6992 file_name
=>$file_name),
6993 -status
=> '302 Found');
6997 my $format = shift || 'html';
7004 # preparing $fd and %diffinfo for git_patchset_body
7006 if (defined $hash_base && defined $hash_parent_base) {
7007 if (defined $file_name) {
7009 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7010 $hash_parent_base, $hash_base,
7011 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7012 or die_error
(500, "Open git-diff-tree failed");
7013 @difftree = map { chomp; $_ } <$fd>;
7015 or die_error
(404, "Reading git-diff-tree failed");
7017 or die_error
(404, "Blob diff not found");
7019 } elsif (defined $hash &&
7020 $hash =~ /[0-9a-fA-F]{40}/) {
7021 # try to find filename from $hash
7023 # read filtered raw output
7024 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7025 $hash_parent_base, $hash_base, "--"
7026 or die_error
(500, "Open git-diff-tree failed");
7028 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
7030 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
7031 map { chomp; $_ } <$fd>;
7033 or die_error
(404, "Reading git-diff-tree failed");
7035 or die_error
(404, "Blob diff not found");
7038 die_error
(400, "Missing one of the blob diff parameters");
7041 if (@difftree > 1) {
7042 die_error
(400, "Ambiguous blob diff specification");
7045 %diffinfo = parse_difftree_raw_line
($difftree[0]);
7046 $file_parent ||= $diffinfo{'from_file'} || $file_name;
7047 $file_name ||= $diffinfo{'to_file'};
7049 $hash_parent ||= $diffinfo{'from_id'};
7050 $hash ||= $diffinfo{'to_id'};
7052 # non-textual hash id's can be cached
7053 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
7054 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
7059 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7060 '-p', ($format eq 'html' ?
"--full-index" : ()),
7061 $hash_parent_base, $hash_base,
7062 "--", (defined $file_parent ?
$file_parent : ()), $file_name
7063 or die_error
(500, "Open git-diff-tree failed");
7066 # old/legacy style URI -- not generated anymore since 1.4.3.
7068 die_error
('404 Not Found', "Missing one of the blob diff parameters")
7072 if ($format eq 'html') {
7074 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
7076 git_header_html
(undef, $expires);
7077 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
7078 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
7079 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
7081 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
7082 print "<div class=\"title\">".esc_html
("$hash vs $hash_parent")."</div>\n";
7084 if (defined $file_name) {
7085 git_print_page_path
($file_name, "blob", $hash_base);
7087 print "<div class=\"page_path\"></div>\n";
7090 } elsif ($format eq 'plain') {
7092 -type
=> 'text/plain',
7093 -charset
=> 'utf-8',
7094 -expires
=> $expires,
7095 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
7097 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7100 die_error
(400, "Unknown blobdiff format");
7104 if ($format eq 'html') {
7105 print "<div class=\"page_body\">\n";
7107 git_patchset_body
($fd, $input_params{diff_style
} eq 'inline',
7108 [ \
%diffinfo ], $hash_base, $hash_parent_base);
7111 print "</div>\n"; # class="page_body"
7115 while (my $line = <$fd>) {
7116 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
7117 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
7121 last if $line =~ m!^\+\+\+!;
7129 sub git_blobdiff_plain
{
7130 git_blobdiff
('plain');
7136 my %pairs = (inline
=> 'inline', 'sidebyside' => 'side by side');
7137 join '', ($cgi->start_form({ method
=> 'get' }),
7143 $cgi->hidden('hpb'),
7144 $cgi->popup_menu('ds', [keys %pairs], $style, \
%pairs),
7145 $cgi->submit('change'),
7149 sub git_commitdiff
{
7151 my $format = $params{-format
} || 'html';
7153 my ($patch_max) = gitweb_get_feature
('patches');
7154 if ($format eq 'patch') {
7155 die_error
(403, "Patch view not allowed") unless $patch_max;
7158 $hash ||= $hash_base || "HEAD";
7159 my %co = parse_commit
($hash)
7160 or die_error
(404, "Unknown commit object");
7162 # choose format for commitdiff for merge
7163 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
7164 $hash_parent = '--cc';
7166 # we need to prepare $formats_nav before almost any parameter munging
7168 if ($format eq 'html') {
7170 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
7172 if ($patch_max && @
{$co{'parents'}} <= 1) {
7173 $formats_nav .= " | " .
7174 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
7178 if (defined $hash_parent &&
7179 $hash_parent ne '-c' && $hash_parent ne '--cc') {
7180 # commitdiff with two commits given
7181 my $hash_parent_short = $hash_parent;
7182 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
7183 $hash_parent_short = substr($hash_parent, 0, 7);
7187 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
7188 if ($co{'parents'}[$i] eq $hash_parent) {
7189 $formats_nav .= ' parent ' . ($i+1);
7193 $formats_nav .= ': ' .
7194 $cgi->a({-href
=> href
(action
=>"commitdiff",
7195 hash
=>$hash_parent)},
7196 esc_html
($hash_parent_short)) .
7198 } elsif (!$co{'parent'}) {
7200 $formats_nav .= ' (initial)';
7201 } elsif (scalar @
{$co{'parents'}} == 1) {
7202 # single parent commit
7205 $cgi->a({-href
=> href
(action
=>"commitdiff",
7206 hash
=>$co{'parent'})},
7207 esc_html
(substr($co{'parent'}, 0, 7))) .
7211 if ($hash_parent eq '--cc') {
7212 $formats_nav .= ' | ' .
7213 $cgi->a({-href
=> href
(action
=>"commitdiff",
7214 hash
=>$hash, hash_parent
=>'-c')},
7216 } else { # $hash_parent eq '-c'
7217 $formats_nav .= ' | ' .
7218 $cgi->a({-href
=> href
(action
=>"commitdiff",
7219 hash
=>$hash, hash_parent
=>'--cc')},
7225 $cgi->a({-href
=> href
(action
=>"commitdiff",
7227 esc_html
(substr($_, 0, 7)));
7228 } @
{$co{'parents'}} ) .
7233 my $hash_parent_param = $hash_parent;
7234 if (!defined $hash_parent_param) {
7235 # --cc for multiple parents, --root for parentless
7236 $hash_parent_param =
7237 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
7243 if ($format eq 'html') {
7244 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7245 "--no-commit-id", "--patch-with-raw", "--full-index",
7246 $hash_parent_param, $hash, "--"
7247 or die_error
(500, "Open git-diff-tree failed");
7249 while (my $line = <$fd>) {
7251 # empty line ends raw part of diff-tree output
7253 push @difftree, scalar parse_difftree_raw_line
($line);
7256 } elsif ($format eq 'plain') {
7257 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7258 '-p', $hash_parent_param, $hash, "--"
7259 or die_error
(500, "Open git-diff-tree failed");
7260 } elsif ($format eq 'patch') {
7261 # For commit ranges, we limit the output to the number of
7262 # patches specified in the 'patches' feature.
7263 # For single commits, we limit the output to a single patch,
7264 # diverging from the git-format-patch default.
7265 my @commit_spec = ();
7267 if ($patch_max > 0) {
7268 push @commit_spec, "-$patch_max";
7270 push @commit_spec, '-n', "$hash_parent..$hash";
7272 if ($params{-single
}) {
7273 push @commit_spec, '-1';
7275 if ($patch_max > 0) {
7276 push @commit_spec, "-$patch_max";
7278 push @commit_spec, "-n";
7280 push @commit_spec, '--root', $hash;
7282 open $fd, "-|", git_cmd
(), "format-patch", @diff_opts,
7283 '--encoding=utf8', '--stdout', @commit_spec
7284 or die_error
(500, "Open git-format-patch failed");
7286 die_error
(400, "Unknown commitdiff format");
7289 # non-textual hash id's can be cached
7291 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
7295 # write commit message
7296 if ($format eq 'html') {
7297 my $refs = git_get_references
();
7298 my $ref = format_ref_marker
($refs, $co{'id'});
7300 git_header_html
(undef, $expires);
7301 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash,
7302 $formats_nav . diff_nav
($input_params{diff_style
}));
7303 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
7304 print "<div class=\"title_text\">\n" .
7305 "<table class=\"object_header\">\n";
7306 git_print_authorship_rows
(\
%co);
7309 print "<div class=\"page_body\">\n";
7310 if (@
{$co{'comment'}} > 1) {
7311 print "<div class=\"log\">\n";
7312 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
7313 print "</div>\n"; # class="log"
7316 } elsif ($format eq 'plain') {
7317 my $refs = git_get_references
("tags");
7318 my $tagname = git_get_rev_name_tags
($hash);
7319 my $filename = basename
($project) . "-$hash.patch";
7322 -type
=> 'text/plain',
7323 -charset
=> 'utf-8',
7324 -expires
=> $expires,
7325 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7326 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7327 print "From: " . to_utf8
($co{'author'}) . "\n";
7328 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
7329 print "Subject: " . to_utf8
($co{'title'}) . "\n";
7331 print "X-Git-Tag: $tagname\n" if $tagname;
7332 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7334 foreach my $line (@
{$co{'comment'}}) {
7335 print to_utf8
($line) . "\n";
7338 } elsif ($format eq 'patch') {
7339 my $filename = basename
($project) . "-$hash.patch";
7342 -type
=> 'text/plain',
7343 -charset
=> 'utf-8',
7344 -expires
=> $expires,
7345 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
7349 if ($format eq 'html') {
7350 my $use_parents = !defined $hash_parent ||
7351 $hash_parent eq '-c' || $hash_parent eq '--cc';
7352 git_difftree_body
(\
@difftree, $hash,
7353 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7356 git_patchset_body
($fd, $input_params{diff_style
} eq 'inline',
7358 $use_parents ? @
{$co{'parents'}} : $hash_parent);
7360 print "</div>\n"; # class="page_body"
7363 } elsif ($format eq 'plain') {
7367 or print "Reading git-diff-tree failed\n";
7368 } elsif ($format eq 'patch') {
7372 or print "Reading git-format-patch failed\n";
7376 sub git_commitdiff_plain
{
7377 git_commitdiff
(-format
=> 'plain');
7380 # format-patch-style patches
7382 git_commitdiff
(-format
=> 'patch', -single
=> 1);
7386 git_commitdiff
(-format
=> 'patch');
7390 git_log_generic
('history', \
&git_history_body
,
7391 $hash_base, $hash_parent_base,
7396 $searchtype ||= 'commit';
7398 # check if appropriate features are enabled
7399 gitweb_check_feature
('search')
7400 or die_error
(403, "Search is disabled");
7401 if ($searchtype eq 'pickaxe') {
7402 # pickaxe may take all resources of your box and run for several minutes
7403 # with every query - so decide by yourself how public you make this feature
7404 gitweb_check_feature
('pickaxe')
7405 or die_error
(403, "Pickaxe search is disabled");
7407 if ($searchtype eq 'grep') {
7408 # grep search might be potentially CPU-intensive, too
7409 gitweb_check_feature
('grep')
7410 or die_error
(403, "Grep search is disabled");
7413 if (!defined $searchtext) {
7414 die_error
(400, "Text field is empty");
7416 if (!defined $hash) {
7417 $hash = git_get_head_hash
($project);
7419 my %co = parse_commit
($hash);
7421 die_error
(404, "Unknown commit object");
7423 if (!defined $page) {
7427 if ($searchtype eq 'commit' ||
7428 $searchtype eq 'author' ||
7429 $searchtype eq 'committer') {
7430 git_search_message
(%co);
7431 } elsif ($searchtype eq 'pickaxe') {
7432 git_search_changes
(%co);
7433 } elsif ($searchtype eq 'grep') {
7434 git_search_files
(%co);
7436 die_error
(400, "Unknown search type");
7440 sub git_search_help
{
7442 git_print_page_nav
('','', $hash,$hash,$hash);
7444 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
7445 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
7446 the pattern entered is recognized as the POSIX extended
7447 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
7450 <dt><b>commit</b></dt>
7451 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
7453 my $have_grep = gitweb_check_feature
('grep');
7456 <dt><b>grep</b></dt>
7457 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
7458 a different one) are searched for the given pattern. On large trees, this search can take
7459 a while and put some strain on the server, so please use it with some consideration. Note that
7460 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
7461 case-sensitive.</dd>
7465 <dt><b>author</b></dt>
7466 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
7467 <dt><b>committer</b></dt>
7468 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
7470 my $have_pickaxe = gitweb_check_feature
('pickaxe');
7471 if ($have_pickaxe) {
7473 <dt><b>pickaxe</b></dt>
7474 <dd>All commits that caused the string to appear or disappear from any file (changes that
7475 added, removed or "modified" the string) will be listed. This search can take a while and
7476 takes a lot of strain on the server, so please use it wisely. Note that since you may be
7477 interested even in changes just changing the case as well, this search is case sensitive.</dd>
7485 git_log_generic
('shortlog', \
&git_shortlog_body
,
7486 $hash, $hash_parent);
7489 ## ......................................................................
7490 ## feeds (RSS, Atom; OPML)
7493 my $format = shift || 'atom';
7494 my $have_blame = gitweb_check_feature
('blame');
7496 # Atom: http://www.atomenabled.org/developers/syndication/
7497 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
7498 if ($format ne 'rss' && $format ne 'atom') {
7499 die_error
(400, "Unknown web feed format");
7502 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
7503 my $head = $hash || 'HEAD';
7504 my @commitlist = parse_commits
($head, 150, 0, $file_name);
7508 my $content_type = "application/$format+xml";
7509 if (defined $cgi->http('HTTP_ACCEPT') &&
7510 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
7511 # browser (feed reader) prefers text/xml
7512 $content_type = 'text/xml';
7514 if (defined($commitlist[0])) {
7515 %latest_commit = %{$commitlist[0]};
7516 my $latest_epoch = $latest_commit{'committer_epoch'};
7517 %latest_date = parse_date
($latest_epoch, $latest_commit{'comitter_tz'});
7518 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
7519 if (defined $if_modified) {
7521 if (eval { require HTTP
::Date
; 1; }) {
7522 $since = HTTP
::Date
::str2time
($if_modified);
7523 } elsif (eval { require Time
::ParseDate
; 1; }) {
7524 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
7526 if (defined $since && $latest_epoch <= $since) {
7528 -type
=> $content_type,
7529 -charset
=> 'utf-8',
7530 -last_modified
=> $latest_date{'rfc2822'},
7531 -status
=> '304 Not Modified');
7536 -type
=> $content_type,
7537 -charset
=> 'utf-8',
7538 -last_modified
=> $latest_date{'rfc2822'});
7541 -type
=> $content_type,
7542 -charset
=> 'utf-8');
7545 # Optimization: skip generating the body if client asks only
7546 # for Last-Modified date.
7547 return if ($cgi->request_method() eq 'HEAD');
7550 my $title = "$site_name - $project/$action";
7551 my $feed_type = 'log';
7552 if (defined $hash) {
7553 $title .= " - '$hash'";
7554 $feed_type = 'branch log';
7555 if (defined $file_name) {
7556 $title .= " :: $file_name";
7557 $feed_type = 'history';
7559 } elsif (defined $file_name) {
7560 $title .= " - $file_name";
7561 $feed_type = 'history';
7563 $title .= " $feed_type";
7564 my $descr = git_get_project_description
($project);
7565 if (defined $descr) {
7566 $descr = esc_html
($descr);
7568 $descr = "$project " .
7569 ($format eq 'rss' ?
'RSS' : 'Atom') .
7572 my $owner = git_get_project_owner
($project);
7573 $owner = esc_html
($owner);
7577 if (defined $file_name) {
7578 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
7579 } elsif (defined $hash) {
7580 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
7582 $alt_url = href
(-full
=>1, action
=>"summary");
7584 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
7585 if ($format eq 'rss') {
7587 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
7590 print "<title>$title</title>\n" .
7591 "<link>$alt_url</link>\n" .
7592 "<description>$descr</description>\n" .
7593 "<language>en</language>\n" .
7594 # project owner is responsible for 'editorial' content
7595 "<managingEditor>$owner</managingEditor>\n";
7596 if (defined $logo || defined $favicon) {
7597 # prefer the logo to the favicon, since RSS
7598 # doesn't allow both
7599 my $img = esc_url
($logo || $favicon);
7601 "<url>$img</url>\n" .
7602 "<title>$title</title>\n" .
7603 "<link>$alt_url</link>\n" .
7607 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
7608 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
7610 print "<generator>gitweb v.$version/$git_version</generator>\n";
7611 } elsif ($format eq 'atom') {
7613 <feed xmlns="http://www.w3.org/2005/Atom">
7615 print "<title>$title</title>\n" .
7616 "<subtitle>$descr</subtitle>\n" .
7617 '<link rel="alternate" type="text/html" href="' .
7618 $alt_url . '" />' . "\n" .
7619 '<link rel="self" type="' . $content_type . '" href="' .
7620 $cgi->self_url() . '" />' . "\n" .
7621 "<id>" . href
(-full
=>1) . "</id>\n" .
7622 # use project owner for feed author
7623 "<author><name>$owner</name></author>\n";
7624 if (defined $favicon) {
7625 print "<icon>" . esc_url
($favicon) . "</icon>\n";
7627 if (defined $logo) {
7628 # not twice as wide as tall: 72 x 27 pixels
7629 print "<logo>" . esc_url
($logo) . "</logo>\n";
7631 if (! %latest_date) {
7632 # dummy date to keep the feed valid until commits trickle in:
7633 print "<updated>1970-01-01T00:00:00Z</updated>\n";
7635 print "<updated>$latest_date{'iso-8601'}</updated>\n";
7637 print "<generator version='$version/$git_version'>gitweb</generator>\n";
7641 for (my $i = 0; $i <= $#commitlist; $i++) {
7642 my %co = %{$commitlist[$i]};
7643 my $commit = $co{'id'};
7644 # we read 150, we always show 30 and the ones more recent than 48 hours
7645 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
7648 my %cd = parse_date
($co{'author_epoch'}, $co{'author_tz'});
7650 # get list of changed files
7651 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
7652 $co{'parent'} || "--root",
7653 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
7655 my @difftree = map { chomp; $_ } <$fd>;
7659 # print element (entry, item)
7660 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
7661 if ($format eq 'rss') {
7663 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
7664 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
7665 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
7666 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
7667 "<link>$co_url</link>\n" .
7668 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
7669 "<content:encoded>" .
7671 } elsif ($format eq 'atom') {
7673 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
7674 "<updated>$cd{'iso-8601'}</updated>\n" .
7676 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
7677 if ($co{'author_email'}) {
7678 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
7680 print "</author>\n" .
7681 # use committer for contributor
7683 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
7684 if ($co{'committer_email'}) {
7685 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
7687 print "</contributor>\n" .
7688 "<published>$cd{'iso-8601'}</published>\n" .
7689 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
7690 "<id>$co_url</id>\n" .
7691 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
7692 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
7694 my $comment = $co{'comment'};
7696 foreach my $line (@
$comment) {
7697 $line = esc_html
($line);
7700 print "</pre><ul>\n";
7701 foreach my $difftree_line (@difftree) {
7702 my %difftree = parse_difftree_raw_line
($difftree_line);
7703 next if !$difftree{'from_id'};
7705 my $file = $difftree{'file'} || $difftree{'to_file'};
7709 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
7710 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
7711 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
7712 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
7713 -title
=> "diff"}, 'D');
7715 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
7716 file_name
=>$file, hash_base
=>$commit),
7717 -title
=> "blame"}, 'B');
7719 # if this is not a feed of a file history
7720 if (!defined $file_name || $file_name ne $file) {
7721 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
7722 file_name
=>$file, hash
=>$commit),
7723 -title
=> "history"}, 'H');
7725 $file = esc_path
($file);
7729 if ($format eq 'rss') {
7730 print "</ul>]]>\n" .
7731 "</content:encoded>\n" .
7733 } elsif ($format eq 'atom') {
7734 print "</ul>\n</div>\n" .
7741 if ($format eq 'rss') {
7742 print "</channel>\n</rss>\n";
7743 } elsif ($format eq 'atom') {
7757 my @list = git_get_projects_list
();
7759 die_error
(404, "No projects found");
7763 -type
=> 'text/xml',
7764 -charset
=> 'utf-8',
7765 -content_disposition
=> 'inline; filename="opml.xml"');
7768 <?xml version="1.0" encoding="utf-8"?>
7769 <opml version="1.0">
7771 <title>$site_name OPML Export</title>
7774 <outline text="git RSS feeds">
7777 foreach my $pr (@list) {
7779 my $head = git_get_head_hash
($proj{'path'});
7780 if (!defined $head) {
7783 $git_dir = "$projectroot/$proj{'path'}";
7784 my %co = parse_commit
($head);
7789 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
7790 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
7791 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
7792 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";