![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
1 #!/usr/bin/perl
3 # gitweb - simple web interface to track changes in git repositories
4 #
5 # (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
6 # (C) 2005, Christian Gierke
7 #
8 # This program is licensed under the GPLv2
10 use 5.008;
11 use strict;
12 use warnings;
13 use CGI qw(:standard :escapeHTML -nosticky);
14 use CGI::Util qw(unescape);
15 use CGI::Carp qw(fatalsToBrowser set_message);
16 use Encode;
17 use Fcntl ':mode';
18 use File::Find qw();
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;
26 BEGIN {
27 CGI->compile() if $ENV{'MOD_PERL'};
28 }
30 our $version = "++GIT_VERSION++";
32 our ($my_url, $my_uri, $base_url, $path_info, $home_link);
33 sub evaluate_uri {
34 our $cgi;
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
46 # later on.
47 #
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
52 # as base URL.
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"};
56 if ($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'};
61 }
62 }
64 # target of the home link on top of all pages
65 our $home_link = $my_uri || "/";
66 }
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++";
95 # URI of stylesheets
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 # default order of projects list
119 # valid values are none, project, descr, owner, and age
120 our $default_projects_order = "project";
122 # show repository only if this file exists
123 # (only effective if this variable evaluates to true)
124 our $export_ok = "++GITWEB_EXPORT_OK++";
126 # show repository only if this subroutine returns true
127 # when given the path to the project, for example:
128 # sub { return -e "$_[0]/git-daemon-export-ok"; }
129 our $export_auth_hook = undef;
131 # only allow viewing of repositories also shown on the overview page
132 our $strict_export = "++GITWEB_STRICT_EXPORT++";
134 # list of git base URLs used for URL to where fetch project from,
135 # i.e. full URL is "$git_base_url/$project"
136 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
138 # default blob_plain mimetype and default charset for text/plain blob
139 our $default_blob_plain_mimetype = 'text/plain';
140 our $default_text_plain_charset = undef;
142 # file to use for guessing MIME types before trying /etc/mime.types
143 # (relative to the current git repository)
144 our $mimetypes_file = undef;
146 # assume this charset if line contains non-UTF-8 characters;
147 # it should be valid encoding (see Encoding::Supported(3pm) for list),
148 # for which encoding all byte sequences are valid, for example
149 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
150 # could be even 'utf-8' for the old behavior)
151 our $fallback_encoding = 'latin1';
153 # rename detection options for git-diff and git-diff-tree
154 # - default is '-M', with the cost proportional to
155 # (number of removed files) * (number of new files).
156 # - more costly is '-C' (which implies '-M'), with the cost proportional to
157 # (number of changed files + number of removed files) * (number of new files)
158 # - even more costly is '-C', '--find-copies-harder' with cost
159 # (number of files in the original tree) * (number of new files)
160 # - one might want to include '-B' option, e.g. '-B', '-M'
161 our @diff_opts = ('-M'); # taken from git_commit
163 # Disables features that would allow repository owners to inject script into
164 # the gitweb domain.
165 our $prevent_xss = 0;
167 # Path to the highlight executable to use (must be the one from
168 # http://www.andre-simon.de due to assumptions about parameters and output).
169 # Useful if highlight is not installed on your webserver's PATH.
170 # [Default: highlight]
171 our $highlight_bin = "++HIGHLIGHT_BIN++";
173 # information about snapshot formats that gitweb is capable of serving
174 our %known_snapshot_formats = (
175 # name => {
176 # 'display' => display name,
177 # 'type' => mime type,
178 # 'suffix' => filename suffix,
179 # 'format' => --format for git-archive,
180 # 'compressor' => [compressor command and arguments]
181 # (array reference, optional)
182 # 'disabled' => boolean (optional)}
183 #
184 'tgz' => {
185 'display' => 'tar.gz',
186 'type' => 'application/x-gzip',
187 'suffix' => '.tar.gz',
188 'format' => 'tar',
189 'compressor' => ['gzip', '-n']},
191 'tbz2' => {
192 'display' => 'tar.bz2',
193 'type' => 'application/x-bzip2',
194 'suffix' => '.tar.bz2',
195 'format' => 'tar',
196 'compressor' => ['bzip2']},
198 'txz' => {
199 'display' => 'tar.xz',
200 'type' => 'application/x-xz',
201 'suffix' => '.tar.xz',
202 'format' => 'tar',
203 'compressor' => ['xz'],
204 'disabled' => 1},
206 'zip' => {
207 'display' => 'zip',
208 'type' => 'application/x-zip',
209 'suffix' => '.zip',
210 'format' => 'zip'},
211 );
213 # Aliases so we understand old gitweb.snapshot values in repository
214 # configuration.
215 our %known_snapshot_format_aliases = (
216 'gzip' => 'tgz',
217 'bzip2' => 'tbz2',
218 'xz' => 'txz',
220 # backward compatibility: legacy gitweb config support
221 'x-gzip' => undef, 'gz' => undef,
222 'x-bzip2' => undef, 'bz2' => undef,
223 'x-zip' => undef, '' => undef,
224 );
226 # Pixel sizes for icons and avatars. If the default font sizes or lineheights
227 # are changed, it may be appropriate to change these values too via
228 # $GITWEB_CONFIG.
229 our %avatar_size = (
230 'default' => 16,
231 'double' => 32
232 );
234 # Used to set the maximum load that we will still respond to gitweb queries.
235 # If server load exceed this value then return "503 server busy" error.
236 # If gitweb cannot determined server load, it is taken to be 0.
237 # Leave it undefined (or set to 'undef') to turn off load checking.
238 our $maxload = 300;
240 # configuration for 'highlight' (http://www.andre-simon.de/)
241 # match by basename
242 our %highlight_basename = (
243 #'Program' => 'py',
244 #'Library' => 'py',
245 'SConstruct' => 'py', # SCons equivalent of Makefile
246 'Makefile' => 'make',
247 );
248 # match by extension
249 our %highlight_ext = (
250 # main extensions, defining name of syntax;
251 # see files in /usr/share/highlight/langDefs/ directory
252 map { $_ => $_ }
253 qw(py c cpp rb java css php sh pl js tex bib xml awk bat ini spec tcl sql make),
254 # alternate extensions, see /etc/highlight/filetypes.conf
255 'h' => 'c',
256 map { $_ => 'sh' } qw(bash zsh ksh),
257 map { $_ => 'cpp' } qw(cxx c++ cc),
258 map { $_ => 'php' } qw(php3 php4 php5 phps),
259 map { $_ => 'pl' } qw(perl pm), # perhaps also 'cgi'
260 map { $_ => 'make'} qw(mak mk),
261 map { $_ => 'xml' } qw(xhtml html htm),
262 );
264 # You define site-wide feature defaults here; override them with
265 # $GITWEB_CONFIG as necessary.
266 our %feature = (
267 # feature => {
268 # 'sub' => feature-sub (subroutine),
269 # 'override' => allow-override (boolean),
270 # 'default' => [ default options...] (array reference)}
271 #
272 # if feature is overridable (it means that allow-override has true value),
273 # then feature-sub will be called with default options as parameters;
274 # return value of feature-sub indicates if to enable specified feature
275 #
276 # if there is no 'sub' key (no feature-sub), then feature cannot be
277 # overridden
278 #
279 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
280 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
281 # is enabled
283 # Enable the 'blame' blob view, showing the last commit that modified
284 # each line in the file. This can be very CPU-intensive.
286 # To enable system wide have in $GITWEB_CONFIG
287 # $feature{'blame'}{'default'} = [1];
288 # To have project specific config enable override in $GITWEB_CONFIG
289 # $feature{'blame'}{'override'} = 1;
290 # and in project config gitweb.blame = 0|1;
291 'blame' => {
292 'sub' => sub { feature_bool('blame', @_) },
293 'override' => 0,
294 'default' => [0]},
296 # Enable the 'snapshot' link, providing a compressed archive of any
297 # tree. This can potentially generate high traffic if you have large
298 # project.
300 # Value is a list of formats defined in %known_snapshot_formats that
301 # you wish to offer.
302 # To disable system wide have in $GITWEB_CONFIG
303 # $feature{'snapshot'}{'default'} = [];
304 # To have project specific config enable override in $GITWEB_CONFIG
305 # $feature{'snapshot'}{'override'} = 1;
306 # and in project config, a comma-separated list of formats or "none"
307 # to disable. Example: gitweb.snapshot = tbz2,zip;
308 'snapshot' => {
309 'sub' => \&feature_snapshot,
310 'override' => 0,
311 'default' => ['tgz']},
313 # Enable text search, which will list the commits which match author,
314 # committer or commit text to a given string. Enabled by default.
315 # Project specific override is not supported.
316 'search' => {
317 'override' => 0,
318 'default' => [1]},
320 # Enable grep search, which will list the files in currently selected
321 # tree containing the given string. Enabled by default. This can be
322 # potentially CPU-intensive, of course.
323 # Note that you need to have 'search' feature enabled too.
325 # To enable system wide have in $GITWEB_CONFIG
326 # $feature{'grep'}{'default'} = [1];
327 # To have project specific config enable override in $GITWEB_CONFIG
328 # $feature{'grep'}{'override'} = 1;
329 # and in project config gitweb.grep = 0|1;
330 'grep' => {
331 'sub' => sub { feature_bool('grep', @_) },
332 'override' => 0,
333 'default' => [1]},
335 # Enable the pickaxe search, which will list the commits that modified
336 # a given string in a file. This can be practical and quite faster
337 # alternative to 'blame', but still potentially CPU-intensive.
338 # Note that you need to have 'search' feature enabled too.
340 # To enable system wide have in $GITWEB_CONFIG
341 # $feature{'pickaxe'}{'default'} = [1];
342 # To have project specific config enable override in $GITWEB_CONFIG
343 # $feature{'pickaxe'}{'override'} = 1;
344 # and in project config gitweb.pickaxe = 0|1;
345 'pickaxe' => {
346 'sub' => sub { feature_bool('pickaxe', @_) },
347 'override' => 0,
348 'default' => [1]},
350 # Enable showing size of blobs in a 'tree' view, in a separate
351 # column, similar to what 'ls -l' does. This cost a bit of IO.
353 # To disable system wide have in $GITWEB_CONFIG
354 # $feature{'show-sizes'}{'default'} = [0];
355 # To have project specific config enable override in $GITWEB_CONFIG
356 # $feature{'show-sizes'}{'override'} = 1;
357 # and in project config gitweb.showsizes = 0|1;
358 'show-sizes' => {
359 'sub' => sub { feature_bool('showsizes', @_) },
360 'override' => 0,
361 'default' => [1]},
363 # Make gitweb use an alternative format of the URLs which can be
364 # more readable and natural-looking: project name is embedded
365 # directly in the path and the query string contains other
366 # auxiliary information. All gitweb installations recognize
367 # URL in either format; this configures in which formats gitweb
368 # generates links.
370 # To enable system wide have in $GITWEB_CONFIG
371 # $feature{'pathinfo'}{'default'} = [1];
372 # Project specific override is not supported.
374 # Note that you will need to change the default location of CSS,
375 # favicon, logo and possibly other files to an absolute URL. Also,
376 # if gitweb.cgi serves as your indexfile, you will need to force
377 # $my_uri to contain the script name in your $GITWEB_CONFIG.
378 'pathinfo' => {
379 'override' => 0,
380 'default' => [0]},
382 # Make gitweb consider projects in project root subdirectories
383 # to be forks of existing projects. Given project $projname.git,
384 # projects matching $projname/*.git will not be shown in the main
385 # projects list, instead a '+' mark will be added to $projname
386 # there and a 'forks' view will be enabled for the project, listing
387 # all the forks. If project list is taken from a file, forks have
388 # to be listed after the main project.
390 # To enable system wide have in $GITWEB_CONFIG
391 # $feature{'forks'}{'default'} = [1];
392 # Project specific override is not supported.
393 'forks' => {
394 'override' => 0,
395 'default' => [0]},
397 # Insert custom links to the action bar of all project pages.
398 # This enables you mainly to link to third-party scripts integrating
399 # into gitweb; e.g. git-browser for graphical history representation
400 # or custom web-based repository administration interface.
402 # The 'default' value consists of a list of triplets in the form
403 # (label, link, position) where position is the label after which
404 # to insert the link and link is a format string where %n expands
405 # to the project name, %f to the project path within the filesystem,
406 # %h to the current hash (h gitweb parameter) and %b to the current
407 # hash base (hb gitweb parameter); %% expands to %.
409 # To enable system wide have in $GITWEB_CONFIG e.g.
410 # $feature{'actions'}{'default'} = [('graphiclog',
411 # '/git-browser/by-commit.html?r=%n', 'summary')];
412 # Project specific override is not supported.
413 'actions' => {
414 'override' => 0,
415 'default' => []},
417 # Allow gitweb scan project content tags described in ctags/
418 # of project repository, and display the popular Web 2.0-ish
419 # "tag cloud" near the project list. Note that this is something
420 # COMPLETELY different from the normal Git tags.
422 # gitweb by itself can show existing tags, but it does not handle
423 # tagging itself; you need an external application for that.
424 # For an example script, check Girocco's cgi/tagproj.cgi.
425 # You may want to install the HTML::TagCloud Perl module to get
426 # a pretty tag cloud instead of just a list of tags.
428 # To enable system wide have in $GITWEB_CONFIG
429 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
430 # Project specific override is not supported.
431 'ctags' => {
432 'override' => 0,
433 'default' => [0]},
435 # The maximum number of patches in a patchset generated in patch
436 # view. Set this to 0 or undef to disable patch view, or to a
437 # negative number to remove any limit.
439 # To disable system wide have in $GITWEB_CONFIG
440 # $feature{'patches'}{'default'} = [0];
441 # To have project specific config enable override in $GITWEB_CONFIG
442 # $feature{'patches'}{'override'} = 1;
443 # and in project config gitweb.patches = 0|n;
444 # where n is the maximum number of patches allowed in a patchset.
445 'patches' => {
446 'sub' => \&feature_patches,
447 'override' => 0,
448 'default' => [16]},
450 # Avatar support. When this feature is enabled, views such as
451 # shortlog or commit will display an avatar associated with
452 # the email of the committer(s) and/or author(s).
454 # Currently available providers are gravatar and picon.
455 # If an unknown provider is specified, the feature is disabled.
457 # Gravatar depends on Digest::MD5.
458 # Picon currently relies on the indiana.edu database.
460 # To enable system wide have in $GITWEB_CONFIG
461 # $feature{'avatar'}{'default'} = ['<provider>'];
462 # where <provider> is either gravatar or picon.
463 # To have project specific config enable override in $GITWEB_CONFIG
464 # $feature{'avatar'}{'override'} = 1;
465 # and in project config gitweb.avatar = <provider>;
466 'avatar' => {
467 'sub' => \&feature_avatar,
468 'override' => 0,
469 'default' => ['']},
471 # Enable displaying how much time and how many git commands
472 # it took to generate and display page. Disabled by default.
473 # Project specific override is not supported.
474 'timed' => {
475 'override' => 0,
476 'default' => [0]},
478 # Enable turning some links into links to actions which require
479 # JavaScript to run (like 'blame_incremental'). Not enabled by
480 # default. Project specific override is currently not supported.
481 'javascript-actions' => {
482 'override' => 0,
483 'default' => [0]},
485 # Syntax highlighting support. This is based on Daniel Svensson's
486 # and Sham Chukoury's work in gitweb-xmms2.git.
487 # It requires the 'highlight' program present in $PATH,
488 # and therefore is disabled by default.
490 # To enable system wide have in $GITWEB_CONFIG
491 # $feature{'highlight'}{'default'} = [1];
493 'highlight' => {
494 'sub' => sub { feature_bool('highlight', @_) },
495 'override' => 0,
496 'default' => [0]},
498 # Enable displaying of remote heads in the heads list
500 # To enable system wide have in $GITWEB_CONFIG
501 # $feature{'remote_heads'}{'default'} = [1];
502 # To have project specific config enable override in $GITWEB_CONFIG
503 # $feature{'remote_heads'}{'override'} = 1;
504 # and in project config gitweb.remote_heads = 0|1;
505 'remote_heads' => {
506 'sub' => sub { feature_bool('remote_heads', @_) },
507 'override' => 0,
508 'default' => [0]},
509 );
511 sub gitweb_get_feature {
512 my ($name) = @_;
513 return unless exists $feature{$name};
514 my ($sub, $override, @defaults) = (
515 $feature{$name}{'sub'},
516 $feature{$name}{'override'},
517 @{$feature{$name}{'default'}});
518 # project specific override is possible only if we have project
519 our $git_dir; # global variable, declared later
520 if (!$override || !defined $git_dir) {
521 return @defaults;
522 }
523 if (!defined $sub) {
524 warn "feature $name is not overridable";
525 return @defaults;
526 }
527 return $sub->(@defaults);
528 }
530 # A wrapper to check if a given feature is enabled.
531 # With this, you can say
532 #
533 # my $bool_feat = gitweb_check_feature('bool_feat');
534 # gitweb_check_feature('bool_feat') or somecode;
535 #
536 # instead of
537 #
538 # my ($bool_feat) = gitweb_get_feature('bool_feat');
539 # (gitweb_get_feature('bool_feat'))[0] or somecode;
540 #
541 sub gitweb_check_feature {
542 return (gitweb_get_feature(@_))[0];
543 }
546 sub feature_bool {
547 my $key = shift;
548 my ($val) = git_get_project_config($key, '--bool');
550 if (!defined $val) {
551 return ($_[0]);
552 } elsif ($val eq 'true') {
553 return (1);
554 } elsif ($val eq 'false') {
555 return (0);
556 }
557 }
559 sub feature_snapshot {
560 my (@fmts) = @_;
562 my ($val) = git_get_project_config('snapshot');
564 if ($val) {
565 @fmts = ($val eq 'none' ? () : split /\s*[,\s]\s*/, $val);
566 }
568 return @fmts;
569 }
571 sub feature_patches {
572 my @val = (git_get_project_config('patches', '--int'));
574 if (@val) {
575 return @val;
576 }
578 return ($_[0]);
579 }
581 sub feature_avatar {
582 my @val = (git_get_project_config('avatar'));
584 return @val ? @val : @_;
585 }
587 # checking HEAD file with -e is fragile if the repository was
588 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
589 # and then pruned.
590 sub check_head_link {
591 my ($dir) = @_;
592 my $headfile = "$dir/HEAD";
593 return ((-e $headfile) ||
594 (-l $headfile && readlink($headfile) =~ /^refs\/heads\//));
595 }
597 sub check_export_ok {
598 my ($dir) = @_;
599 return (check_head_link($dir) &&
600 (!$export_ok || -e "$dir/$export_ok") &&
601 (!$export_auth_hook || $export_auth_hook->($dir)));
602 }
604 # process alternate names for backward compatibility
605 # filter out unsupported (unknown) snapshot formats
606 sub filter_snapshot_fmts {
607 my @fmts = @_;
609 @fmts = map {
610 exists $known_snapshot_format_aliases{$_} ?
611 $known_snapshot_format_aliases{$_} : $_} @fmts;
612 @fmts = grep {
613 exists $known_snapshot_formats{$_} &&
614 !$known_snapshot_formats{$_}{'disabled'}} @fmts;
615 }
617 # If it is set to code reference, it is code that it is to be run once per
618 # request, allowing updating configurations that change with each request,
619 # while running other code in config file only once.
620 #
621 # Otherwise, if it is false then gitweb would process config file only once;
622 # if it is true then gitweb config would be run for each request.
623 our $per_request_config = 1;
625 our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM);
626 sub evaluate_gitweb_config {
627 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
628 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
629 # die if there are errors parsing config file
630 if (-e $GITWEB_CONFIG) {
631 do $GITWEB_CONFIG;
632 die $@ if $@;
633 } elsif (-e $GITWEB_CONFIG_SYSTEM) {
634 do $GITWEB_CONFIG_SYSTEM;
635 die $@ if $@;
636 }
637 }
639 # Get loadavg of system, to compare against $maxload.
640 # Currently it requires '/proc/loadavg' present to get loadavg;
641 # if it is not present it returns 0, which means no load checking.
642 sub get_loadavg {
643 if( -e '/proc/loadavg' ){
644 open my $fd, '<', '/proc/loadavg'
645 or return 0;
646 my @load = split(/\s+/, scalar <$fd>);
647 close $fd;
649 # The first three columns measure CPU and IO utilization of the last one,
650 # five, and 10 minute periods. The fourth column shows the number of
651 # currently running processes and the total number of processes in the m/n
652 # format. The last column displays the last process ID used.
653 return $load[0] || 0;
654 }
655 # additional checks for load average should go here for things that don't export
656 # /proc/loadavg
658 return 0;
659 }
661 # version of the core git binary
662 our $git_version;
663 sub evaluate_git_version {
664 our $git_version = qx("$GIT" --version) =~ m/git version (.*)$/ ? $1 : "unknown";
665 $number_of_git_cmds++;
666 }
668 sub check_loadavg {
669 if (defined $maxload && get_loadavg() > $maxload) {
670 die_error(503, "The load average on the server is too high");
671 }
672 }
674 # ======================================================================
675 # input validation and dispatch
677 # input parameters can be collected from a variety of sources (presently, CGI
678 # and PATH_INFO), so we define an %input_params hash that collects them all
679 # together during validation: this allows subsequent uses (e.g. href()) to be
680 # agnostic of the parameter origin
682 our %input_params = ();
684 # input parameters are stored with the long parameter name as key. This will
685 # also be used in the href subroutine to convert parameters to their CGI
686 # equivalent, and since the href() usage is the most frequent one, we store
687 # the name -> CGI key mapping here, instead of the reverse.
688 #
689 # XXX: Warning: If you touch this, check the search form for updating,
690 # too.
692 our @cgi_param_mapping = (
693 project => "p",
694 action => "a",
695 file_name => "f",
696 file_parent => "fp",
697 hash => "h",
698 hash_parent => "hp",
699 hash_base => "hb",
700 hash_parent_base => "hpb",
701 page => "pg",
702 order => "o",
703 searchtext => "s",
704 searchtype => "st",
705 snapshot_format => "sf",
706 extra_options => "opt",
707 search_use_regexp => "sr",
708 # this must be last entry (for manipulation from JavaScript)
709 javascript => "js"
710 );
711 our %cgi_param_mapping = @cgi_param_mapping;
713 # we will also need to know the possible actions, for validation
714 our %actions = (
715 "blame" => \&git_blame,
716 "blame_incremental" => \&git_blame_incremental,
717 "blame_data" => \&git_blame_data,
718 "blobdiff" => \&git_blobdiff,
719 "blobdiff_plain" => \&git_blobdiff_plain,
720 "blob" => \&git_blob,
721 "blob_plain" => \&git_blob_plain,
722 "commitdiff" => \&git_commitdiff,
723 "commitdiff_plain" => \&git_commitdiff_plain,
724 "commit" => \&git_commit,
725 "forks" => \&git_forks,
726 "heads" => \&git_heads,
727 "history" => \&git_history,
728 "log" => \&git_log,
729 "patch" => \&git_patch,
730 "patches" => \&git_patches,
731 "remotes" => \&git_remotes,
732 "rss" => \&git_rss,
733 "atom" => \&git_atom,
734 "search" => \&git_search,
735 "search_help" => \&git_search_help,
736 "shortlog" => \&git_shortlog,
737 "summary" => \&git_summary,
738 "tag" => \&git_tag,
739 "tags" => \&git_tags,
740 "tree" => \&git_tree,
741 "snapshot" => \&git_snapshot,
742 "object" => \&git_object,
743 # those below don't need $project
744 "opml" => \&git_opml,
745 "project_list" => \&git_project_list,
746 "project_index" => \&git_project_index,
747 );
749 # finally, we have the hash of allowed extra_options for the commands that
750 # allow them
751 our %allowed_options = (
752 "--no-merges" => [ qw(rss atom log shortlog history) ],
753 );
755 # fill %input_params with the CGI parameters. All values except for 'opt'
756 # should be single values, but opt can be an array. We should probably
757 # build an array of parameters that can be multi-valued, but since for the time
758 # being it's only this one, we just single it out
759 sub evaluate_query_params {
760 our $cgi;
762 while (my ($name, $symbol) = each %cgi_param_mapping) {
763 if ($symbol eq 'opt') {
764 $input_params{$name} = [ $cgi->param($symbol) ];
765 } else {
766 $input_params{$name} = $cgi->param($symbol);
767 }
768 }
769 }
771 # now read PATH_INFO and update the parameter list for missing parameters
772 sub evaluate_path_info {
773 return if defined $input_params{'project'};
774 return if !$path_info;
775 $path_info =~ s,^/+,,;
776 return if !$path_info;
778 # find which part of PATH_INFO is project
779 my $project = $path_info;
780 $project =~ s,/+$,,;
781 while ($project && !check_head_link("$projectroot/$project")) {
782 $project =~ s,/*[^/]*$,,;
783 }
784 return unless $project;
785 $input_params{'project'} = $project;
787 # do not change any parameters if an action is given using the query string
788 return if $input_params{'action'};
789 $path_info =~ s,^\Q$project\E/*,,;
791 # next, check if we have an action
792 my $action = $path_info;
793 $action =~ s,/.*$,,;
794 if (exists $actions{$action}) {
795 $path_info =~ s,^$action/*,,;
796 $input_params{'action'} = $action;
797 }
799 # list of actions that want hash_base instead of hash, but can have no
800 # pathname (f) parameter
801 my @wants_base = (
802 'tree',
803 'history',
804 );
806 # we want to catch, among others
807 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
808 my ($parentrefname, $parentpathname, $refname, $pathname) =
809 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?([^:]+?)?(?::(.+))?$/);
811 # first, analyze the 'current' part
812 if (defined $pathname) {
813 # we got "branch:filename" or "branch:dir/"
814 # we could use git_get_type(branch:pathname), but:
815 # - it needs $git_dir
816 # - it does a git() call
817 # - the convention of terminating directories with a slash
818 # makes it superfluous
819 # - embedding the action in the PATH_INFO would make it even
820 # more superfluous
821 $pathname =~ s,^/+,,;
822 if (!$pathname || substr($pathname, -1) eq "/") {
823 $input_params{'action'} ||= "tree";
824 $pathname =~ s,/$,,;
825 } else {
826 # the default action depends on whether we had parent info
827 # or not
828 if ($parentrefname) {
829 $input_params{'action'} ||= "blobdiff_plain";
830 } else {
831 $input_params{'action'} ||= "blob_plain";
832 }
833 }
834 $input_params{'hash_base'} ||= $refname;
835 $input_params{'file_name'} ||= $pathname;
836 } elsif (defined $refname) {
837 # we got "branch". In this case we have to choose if we have to
838 # set hash or hash_base.
839 #
840 # Most of the actions without a pathname only want hash to be
841 # set, except for the ones specified in @wants_base that want
842 # hash_base instead. It should also be noted that hand-crafted
843 # links having 'history' as an action and no pathname or hash
844 # set will fail, but that happens regardless of PATH_INFO.
845 if (defined $parentrefname) {
846 # if there is parent let the default be 'shortlog' action
847 # (for http://git.example.com/repo.git/A..B links); if there
848 # is no parent, dispatch will detect type of object and set
849 # action appropriately if required (if action is not set)
850 $input_params{'action'} ||= "shortlog";
851 }
852 if ($input_params{'action'} &&
853 grep { $_ eq $input_params{'action'} } @wants_base) {
854 $input_params{'hash_base'} ||= $refname;
855 } else {
856 $input_params{'hash'} ||= $refname;
857 }
858 }
860 # next, handle the 'parent' part, if present
861 if (defined $parentrefname) {
862 # a missing pathspec defaults to the 'current' filename, allowing e.g.
863 # someproject/blobdiff/oldrev..newrev:/filename
864 if ($parentpathname) {
865 $parentpathname =~ s,^/+,,;
866 $parentpathname =~ s,/$,,;
867 $input_params{'file_parent'} ||= $parentpathname;
868 } else {
869 $input_params{'file_parent'} ||= $input_params{'file_name'};
870 }
871 # we assume that hash_parent_base is wanted if a path was specified,
872 # or if the action wants hash_base instead of hash
873 if (defined $input_params{'file_parent'} ||
874 grep { $_ eq $input_params{'action'} } @wants_base) {
875 $input_params{'hash_parent_base'} ||= $parentrefname;
876 } else {
877 $input_params{'hash_parent'} ||= $parentrefname;
878 }
879 }
881 # for the snapshot action, we allow URLs in the form
882 # $project/snapshot/$hash.ext
883 # where .ext determines the snapshot and gets removed from the
884 # passed $refname to provide the $hash.
885 #
886 # To be able to tell that $refname includes the format extension, we
887 # require the following two conditions to be satisfied:
888 # - the hash input parameter MUST have been set from the $refname part
889 # of the URL (i.e. they must be equal)
890 # - the snapshot format MUST NOT have been defined already (e.g. from
891 # CGI parameter sf)
892 # It's also useless to try any matching unless $refname has a dot,
893 # so we check for that too
894 if (defined $input_params{'action'} &&
895 $input_params{'action'} eq 'snapshot' &&
896 defined $refname && index($refname, '.') != -1 &&
897 $refname eq $input_params{'hash'} &&
898 !defined $input_params{'snapshot_format'}) {
899 # We loop over the known snapshot formats, checking for
900 # extensions. Allowed extensions are both the defined suffix
901 # (which includes the initial dot already) and the snapshot
902 # format key itself, with a prepended dot
903 while (my ($fmt, $opt) = each %known_snapshot_formats) {
904 my $hash = $refname;
905 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
906 next;
907 }
908 my $sfx = $1;
909 # a valid suffix was found, so set the snapshot format
910 # and reset the hash parameter
911 $input_params{'snapshot_format'} = $fmt;
912 $input_params{'hash'} = $hash;
913 # we also set the format suffix to the one requested
914 # in the URL: this way a request for e.g. .tgz returns
915 # a .tgz instead of a .tar.gz
916 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
917 last;
918 }
919 }
920 }
922 our ($action, $project, $file_name, $file_parent, $hash, $hash_parent, $hash_base,
923 $hash_parent_base, @extra_options, $page, $searchtype, $search_use_regexp,
924 $searchtext, $search_regexp);
925 sub evaluate_and_validate_params {
926 our $action = $input_params{'action'};
927 if (defined $action) {
928 if (!validate_action($action)) {
929 die_error(400, "Invalid action parameter");
930 }
931 }
933 # parameters which are pathnames
934 our $project = $input_params{'project'};
935 if (defined $project) {
936 if (!validate_project($project)) {
937 undef $project;
938 die_error(404, "No such project");
939 }
940 }
942 our $file_name = $input_params{'file_name'};
943 if (defined $file_name) {
944 if (!validate_pathname($file_name)) {
945 die_error(400, "Invalid file parameter");
946 }
947 }
949 our $file_parent = $input_params{'file_parent'};
950 if (defined $file_parent) {
951 if (!validate_pathname($file_parent)) {
952 die_error(400, "Invalid file parent parameter");
953 }
954 }
956 # parameters which are refnames
957 our $hash = $input_params{'hash'};
958 if (defined $hash) {
959 if (!validate_refname($hash)) {
960 die_error(400, "Invalid hash parameter");
961 }
962 }
964 our $hash_parent = $input_params{'hash_parent'};
965 if (defined $hash_parent) {
966 if (!validate_refname($hash_parent)) {
967 die_error(400, "Invalid hash parent parameter");
968 }
969 }
971 our $hash_base = $input_params{'hash_base'};
972 if (defined $hash_base) {
973 if (!validate_refname($hash_base)) {
974 die_error(400, "Invalid hash base parameter");
975 }
976 }
978 our @extra_options = @{$input_params{'extra_options'}};
979 # @extra_options is always defined, since it can only be (currently) set from
980 # CGI, and $cgi->param() returns the empty array in array context if the param
981 # is not set
982 foreach my $opt (@extra_options) {
983 if (not exists $allowed_options{$opt}) {
984 die_error(400, "Invalid option parameter");
985 }
986 if (not grep(/^$action$/, @{$allowed_options{$opt}})) {
987 die_error(400, "Invalid option parameter for this action");
988 }
989 }
991 our $hash_parent_base = $input_params{'hash_parent_base'};
992 if (defined $hash_parent_base) {
993 if (!validate_refname($hash_parent_base)) {
994 die_error(400, "Invalid hash parent base parameter");
995 }
996 }
998 # other parameters
999 our $page = $input_params{'page'};
1000 if (defined $page) {
1001 if ($page =~ m/[^0-9]/) {
1002 die_error(400, "Invalid page parameter");
1003 }
1004 }
1006 our $searchtype = $input_params{'searchtype'};
1007 if (defined $searchtype) {
1008 if ($searchtype =~ m/[^a-z]/) {
1009 die_error(400, "Invalid searchtype parameter");
1010 }
1011 }
1013 our $search_use_regexp = $input_params{'search_use_regexp'};
1015 our $searchtext = $input_params{'searchtext'};
1016 our $search_regexp;
1017 if (defined $searchtext) {
1018 if (length($searchtext) < 2) {
1019 die_error(403, "At least two characters are required for search parameter");
1020 }
1021 $search_regexp = $search_use_regexp ? $searchtext : quotemeta $searchtext;
1022 }
1023 }
1025 # path to the current git repository
1026 our $git_dir;
1027 sub evaluate_git_dir {
1028 our $git_dir = "$projectroot/$project" if $project;
1029 }
1031 our (@snapshot_fmts, $git_avatar);
1032 sub configure_gitweb_features {
1033 # list of supported snapshot formats
1034 our @snapshot_fmts = gitweb_get_feature('snapshot');
1035 @snapshot_fmts = filter_snapshot_fmts(@snapshot_fmts);
1037 # check that the avatar feature is set to a known provider name,
1038 # and for each provider check if the dependencies are satisfied.
1039 # if the provider name is invalid or the dependencies are not met,
1040 # reset $git_avatar to the empty string.
1041 our ($git_avatar) = gitweb_get_feature('avatar');
1042 if ($git_avatar eq 'gravatar') {
1043 $git_avatar = '' unless (eval { require Digest::MD5; 1; });
1044 } elsif ($git_avatar eq 'picon') {
1045 # no dependencies
1046 } else {
1047 $git_avatar = '';
1048 }
1049 }
1051 # custom error handler: 'die <message>' is Internal Server Error
1052 sub handle_errors_html {
1053 my $msg = shift; # it is already HTML escaped
1055 # to avoid infinite loop where error occurs in die_error,
1056 # change handler to default handler, disabling handle_errors_html
1057 set_message("Error occured when inside die_error:\n$msg");
1059 # you cannot jump out of die_error when called as error handler;
1060 # the subroutine set via CGI::Carp::set_message is called _after_
1061 # HTTP headers are already written, so it cannot write them itself
1062 die_error(undef, undef, $msg, -error_handler => 1, -no_http_header => 1);
1063 }
1064 set_message(\&handle_errors_html);
1066 # dispatch
1067 sub dispatch {
1068 if (!defined $action) {
1069 if (defined $hash) {
1070 $action = git_get_type($hash);
1071 } elsif (defined $hash_base && defined $file_name) {
1072 $action = git_get_type("$hash_base:$file_name");
1073 } elsif (defined $project) {
1074 $action = 'summary';
1075 } else {
1076 $action = 'project_list';
1077 }
1078 }
1079 if (!defined($actions{$action})) {
1080 die_error(400, "Unknown action");
1081 }
1082 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1083 !$project) {
1084 die_error(400, "Project needed");
1085 }
1086 $actions{$action}->();
1087 }
1089 sub reset_timer {
1090 our $t0 = [ gettimeofday() ]
1091 if defined $t0;
1092 our $number_of_git_cmds = 0;
1093 }
1095 our $first_request = 1;
1096 sub run_request {
1097 reset_timer();
1099 evaluate_uri();
1100 if ($first_request) {
1101 evaluate_gitweb_config();
1102 evaluate_git_version();
1103 }
1104 if ($per_request_config) {
1105 if (ref($per_request_config) eq 'CODE') {
1106 $per_request_config->();
1107 } elsif (!$first_request) {
1108 evaluate_gitweb_config();
1109 }
1110 }
1111 check_loadavg();
1113 # $projectroot and $projects_list might be set in gitweb config file
1114 $projects_list ||= $projectroot;
1116 evaluate_query_params();
1117 evaluate_path_info();
1118 evaluate_and_validate_params();
1119 evaluate_git_dir();
1121 configure_gitweb_features();
1123 dispatch();
1124 }
1126 our $is_last_request = sub { 1 };
1127 our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1128 our $CGI = 'CGI';
1129 our $cgi;
1130 sub configure_as_fcgi {
1131 require CGI::Fast;
1132 our $CGI = 'CGI::Fast';
1134 my $request_number = 0;
1135 # let each child service 100 requests
1136 our $is_last_request = sub { ++$request_number > 100 };
1137 }
1138 sub evaluate_argv {
1139 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__;
1140 configure_as_fcgi()
1141 if $script_name =~ /\.fcgi$/;
1143 return unless (@ARGV);
1145 require Getopt::Long;
1146 Getopt::Long::GetOptions(
1147 'fastcgi|fcgi|f' => \&configure_as_fcgi,
1148 'nproc|n=i' => sub {
1149 my ($arg, $val) = @_;
1150 return unless eval { require FCGI::ProcManager; 1; };
1151 my $proc_manager = FCGI::ProcManager->new({
1152 n_processes => $val,
1153 });
1154 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1155 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1156 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1157 },
1158 );
1159 }
1161 sub run {
1162 evaluate_argv();
1164 $first_request = 1;
1165 $pre_listen_hook->()
1166 if $pre_listen_hook;
1168 REQUEST:
1169 while ($cgi = $CGI->new()) {
1170 $pre_dispatch_hook->()
1171 if $pre_dispatch_hook;
1173 run_request();
1175 $post_dispatch_hook->()
1176 if $post_dispatch_hook;
1177 $first_request = 0;
1179 last REQUEST if ($is_last_request->());
1180 }
1182 DONE_GITWEB:
1183 1;
1184 }
1186 run();
1188 if (defined caller) {
1189 # wrapped in a subroutine processing requests,
1190 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1191 return;
1192 } else {
1193 # pure CGI script, serving single request
1194 exit;
1195 }
1197 ## ======================================================================
1198 ## action links
1200 # possible values of extra options
1201 # -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1202 # -replay => 1 - start from a current view (replay with modifications)
1203 # -path_info => 0|1 - don't use/use path_info URL (if possible)
1204 # -anchor => ANCHOR - add #ANCHOR to end of URL, implies -replay if used alone
1205 sub href {
1206 my %params = @_;
1207 # default is to use -absolute url() i.e. $my_uri
1208 my $href = $params{-full} ? $my_url : $my_uri;
1210 # implicit -replay, must be first of implicit params
1211 $params{-replay} = 1 if (keys %params == 1 && $params{-anchor});
1213 $params{'project'} = $project unless exists $params{'project'};
1215 if ($params{-replay}) {
1216 while (my ($name, $symbol) = each %cgi_param_mapping) {
1217 if (!exists $params{$name}) {
1218 $params{$name} = $input_params{$name};
1219 }
1220 }
1221 }
1223 my $use_pathinfo = gitweb_check_feature('pathinfo');
1224 if (defined $params{'project'} &&
1225 (exists $params{-path_info} ? $params{-path_info} : $use_pathinfo)) {
1226 # try to put as many parameters as possible in PATH_INFO:
1227 # - project name
1228 # - action
1229 # - hash_parent or hash_parent_base:/file_parent
1230 # - hash or hash_base:/filename
1231 # - the snapshot_format as an appropriate suffix
1233 # When the script is the root DirectoryIndex for the domain,
1234 # $href here would be something like http://gitweb.example.com/
1235 # Thus, we strip any trailing / from $href, to spare us double
1236 # slashes in the final URL
1237 $href =~ s,/$,,;
1239 # Then add the project name, if present
1240 $href .= "/".esc_path_info($params{'project'});
1241 delete $params{'project'};
1243 # since we destructively absorb parameters, we keep this
1244 # boolean that remembers if we're handling a snapshot
1245 my $is_snapshot = $params{'action'} eq 'snapshot';
1247 # Summary just uses the project path URL, any other action is
1248 # added to the URL
1249 if (defined $params{'action'}) {
1250 $href .= "/".esc_path_info($params{'action'})
1251 unless $params{'action'} eq 'summary';
1252 delete $params{'action'};
1253 }
1255 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1256 # stripping nonexistent or useless pieces
1257 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1258 || $params{'hash_parent'} || $params{'hash'});
1259 if (defined $params{'hash_base'}) {
1260 if (defined $params{'hash_parent_base'}) {
1261 $href .= esc_path_info($params{'hash_parent_base'});
1262 # skip the file_parent if it's the same as the file_name
1263 if (defined $params{'file_parent'}) {
1264 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1265 delete $params{'file_parent'};
1266 } elsif ($params{'file_parent'} !~ /\.\./) {
1267 $href .= ":/".esc_path_info($params{'file_parent'});
1268 delete $params{'file_parent'};
1269 }
1270 }
1271 $href .= "..";
1272 delete $params{'hash_parent'};
1273 delete $params{'hash_parent_base'};
1274 } elsif (defined $params{'hash_parent'}) {
1275 $href .= esc_path_info($params{'hash_parent'}). "..";
1276 delete $params{'hash_parent'};
1277 }
1279 $href .= esc_path_info($params{'hash_base'});
1280 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
1281 $href .= ":/".esc_path_info($params{'file_name'});
1282 delete $params{'file_name'};
1283 }
1284 delete $params{'hash'};
1285 delete $params{'hash_base'};
1286 } elsif (defined $params{'hash'}) {
1287 $href .= esc_path_info($params{'hash'});
1288 delete $params{'hash'};
1289 }
1291 # If the action was a snapshot, we can absorb the
1292 # snapshot_format parameter too
1293 if ($is_snapshot) {
1294 my $fmt = $params{'snapshot_format'};
1295 # snapshot_format should always be defined when href()
1296 # is called, but just in case some code forgets, we
1297 # fall back to the default
1298 $fmt ||= $snapshot_fmts[0];
1299 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1300 delete $params{'snapshot_format'};
1301 }
1302 }
1304 # now encode the parameters explicitly
1305 my @result = ();
1306 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1307 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
1308 if (defined $params{$name}) {
1309 if (ref($params{$name}) eq "ARRAY") {
1310 foreach my $par (@{$params{$name}}) {
1311 push @result, $symbol . "=" . esc_param($par);
1312 }
1313 } else {
1314 push @result, $symbol . "=" . esc_param($params{$name});
1315 }
1316 }
1317 }
1318 $href .= "?" . join(';', @result) if scalar @result;
1320 # final transformation: trailing spaces must be escaped (URI-encoded)
1321 $href =~ s/(\s+)$/CGI::escape($1)/e;
1323 if ($params{-anchor}) {
1324 $href .= "#".esc_param($params{-anchor});
1325 }
1327 return $href;
1328 }
1331 ## ======================================================================
1332 ## validation, quoting/unquoting and escaping
1334 sub validate_action {
1335 my $input = shift || return undef;
1336 return undef unless exists $actions{$input};
1337 return $input;
1338 }
1340 sub validate_project {
1341 my $input = shift || return undef;
1342 if (!validate_pathname($input) ||
1343 !(-d "$projectroot/$input") ||
1344 !check_export_ok("$projectroot/$input") ||
1345 ($strict_export && !project_in_list($input))) {
1346 return undef;
1347 } else {
1348 return $input;
1349 }
1350 }
1352 sub validate_pathname {
1353 my $input = shift || return undef;
1355 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
1356 # at the beginning, at the end, and between slashes.
1357 # also this catches doubled slashes
1358 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1359 return undef;
1360 }
1361 # no null characters
1362 if ($input =~ m!\0!) {
1363 return undef;
1364 }
1365 return $input;
1366 }
1368 sub validate_refname {
1369 my $input = shift || return undef;
1371 # textual hashes are O.K.
1372 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
1373 return $input;
1374 }
1375 # it must be correct pathname
1376 $input = validate_pathname($input)
1377 or return undef;
1378 # restrictions on ref name according to git-check-ref-format
1379 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1380 return undef;
1381 }
1382 return $input;
1383 }
1385 # decode sequences of octets in utf8 into Perl's internal form,
1386 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1387 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1388 sub to_utf8 {
1389 my $str = shift;
1390 return undef unless defined $str;
1391 if (utf8::valid($str)) {
1392 utf8::decode($str);
1393 return $str;
1394 } else {
1395 return decode($fallback_encoding, $str, Encode::FB_DEFAULT);
1396 }
1397 }
1399 # quote unsafe chars, but keep the slash, even when it's not
1400 # correct, but quoted slashes look too horrible in bookmarks
1401 sub esc_param {
1402 my $str = shift;
1403 return undef unless defined $str;
1404 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI::escape($1)/eg;
1405 $str =~ s/ /\+/g;
1406 return $str;
1407 }
1409 # the quoting rules for path_info fragment are slightly different
1410 sub esc_path_info {
1411 my $str = shift;
1412 return undef unless defined $str;
1414 # path_info doesn't treat '+' as space (specially), but '?' must be escaped
1415 $str =~ s/([^A-Za-z0-9\-_.~();\/;:@&= +]+)/CGI::escape($1)/eg;
1417 return $str;
1418 }
1420 # quote unsafe chars in whole URL, so some characters cannot be quoted
1421 sub esc_url {
1422 my $str = shift;
1423 return undef unless defined $str;
1424 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI::escape($1)/eg;
1425 $str =~ s/ /\+/g;
1426 return $str;
1427 }
1429 # quote unsafe characters in HTML attributes
1430 sub esc_attr {
1432 # for XHTML conformance escaping '"' to '"' is not enough
1433 return esc_html(@_);
1434 }
1436 # replace invalid utf8 character with SUBSTITUTION sequence
1437 sub esc_html {
1438 my $str = shift;
1439 my %opts = @_;
1441 return undef unless defined $str;
1443 $str = to_utf8($str);
1444 $str = $cgi->escapeHTML($str);
1445 if ($opts{'-nbsp'}) {
1446 $str =~ s/ / /g;
1447 }
1448 $str =~ s|([[:cntrl:]])|(($1 ne "\t") ? quot_cec($1) : $1)|eg;
1449 return $str;
1450 }
1452 # quote control characters and escape filename to HTML
1453 sub esc_path {
1454 my $str = shift;
1455 my %opts = @_;
1457 return undef unless defined $str;
1459 $str = to_utf8($str);
1460 $str = $cgi->escapeHTML($str);
1461 if ($opts{'-nbsp'}) {
1462 $str =~ s/ / /g;
1463 }
1464 $str =~ s|([[:cntrl:]])|quot_cec($1)|eg;
1465 return $str;
1466 }
1468 # Make control characters "printable", using character escape codes (CEC)
1469 sub quot_cec {
1470 my $cntrl = shift;
1471 my %opts = @_;
1472 my %es = ( # character escape codes, aka escape sequences
1473 "\t" => '\t', # tab (HT)
1474 "\n" => '\n', # line feed (LF)
1475 "\r" => '\r', # carrige return (CR)
1476 "\f" => '\f', # form feed (FF)
1477 "\b" => '\b', # backspace (BS)
1478 "\a" => '\a', # alarm (bell) (BEL)
1479 "\e" => '\e', # escape (ESC)
1480 "\013" => '\v', # vertical tab (VT)
1481 "\000" => '\0', # nul character (NUL)
1482 );
1483 my $chr = ( (exists $es{$cntrl})
1484 ? $es{$cntrl}
1485 : sprintf('\%2x', ord($cntrl)) );
1486 if ($opts{-nohtml}) {
1487 return $chr;
1488 } else {
1489 return "<span class=\"cntrl\">$chr</span>";
1490 }
1491 }
1493 # Alternatively use unicode control pictures codepoints,
1494 # Unicode "printable representation" (PR)
1495 sub quot_upr {
1496 my $cntrl = shift;
1497 my %opts = @_;
1499 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1500 if ($opts{-nohtml}) {
1501 return $chr;
1502 } else {
1503 return "<span class=\"cntrl\">$chr</span>";
1504 }
1505 }
1507 # git may return quoted and escaped filenames
1508 sub unquote {
1509 my $str = shift;
1511 sub unq {
1512 my $seq = shift;
1513 my %es = ( # character escape codes, aka escape sequences
1514 't' => "\t", # tab (HT, TAB)
1515 'n' => "\n", # newline (NL)
1516 'r' => "\r", # return (CR)
1517 'f' => "\f", # form feed (FF)
1518 'b' => "\b", # backspace (BS)
1519 'a' => "\a", # alarm (bell) (BEL)
1520 'e' => "\e", # escape (ESC)
1521 'v' => "\013", # vertical tab (VT)
1522 );
1524 if ($seq =~ m/^[0-7]{1,3}$/) {
1525 # octal char sequence
1526 return chr(oct($seq));
1527 } elsif (exists $es{$seq}) {
1528 # C escape sequence, aka character escape code
1529 return $es{$seq};
1530 }
1531 # quoted ordinary character
1532 return $seq;
1533 }
1535 if ($str =~ m/^"(.*)"$/) {
1536 # needs unquoting
1537 $str = $1;
1538 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1539 }
1540 return $str;
1541 }
1543 # escape tabs (convert tabs to spaces)
1544 sub untabify {
1545 my $line = shift;
1547 while ((my $pos = index($line, "\t")) != -1) {
1548 if (my $count = (8 - ($pos % 8))) {
1549 my $spaces = ' ' x $count;
1550 $line =~ s/\t/$spaces/;
1551 }
1552 }
1554 return $line;
1555 }
1557 sub project_in_list {
1558 my $project = shift;
1559 my @list = git_get_projects_list();
1560 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1561 }
1563 ## ----------------------------------------------------------------------
1564 ## HTML aware string manipulation
1566 # Try to chop given string on a word boundary between position
1567 # $len and $len+$add_len. If there is no word boundary there,
1568 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1569 # (marking chopped part) would be longer than given string.
1570 sub chop_str {
1571 my $str = shift;
1572 my $len = shift;
1573 my $add_len = shift || 10;
1574 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1576 # Make sure perl knows it is utf8 encoded so we don't
1577 # cut in the middle of a utf8 multibyte char.
1578 $str = to_utf8($str);
1580 # allow only $len chars, but don't cut a word if it would fit in $add_len
1581 # if it doesn't fit, cut it if it's still longer than the dots we would add
1582 # remove chopped character entities entirely
1584 # when chopping in the middle, distribute $len into left and right part
1585 # return early if chopping wouldn't make string shorter
1586 if ($where eq 'center') {
1587 return $str if ($len + 5 >= length($str)); # filler is length 5
1588 $len = int($len/2);
1589 } else {
1590 return $str if ($len + 4 >= length($str)); # filler is length 4
1591 }
1593 # regexps: ending and beginning with word part up to $add_len
1594 my $endre = qr/.{$len}\w{0,$add_len}/;
1595 my $begre = qr/\w{0,$add_len}.{$len}/;
1597 if ($where eq 'left') {
1598 $str =~ m/^(.*?)($begre)$/;
1599 my ($lead, $body) = ($1, $2);
1600 if (length($lead) > 4) {
1601 $lead = " ...";
1602 }
1603 return "$lead$body";
1605 } elsif ($where eq 'center') {
1606 $str =~ m/^($endre)(.*)$/;
1607 my ($left, $str) = ($1, $2);
1608 $str =~ m/^(.*?)($begre)$/;
1609 my ($mid, $right) = ($1, $2);
1610 if (length($mid) > 5) {
1611 $mid = " ... ";
1612 }
1613 return "$left$mid$right";
1615 } else {
1616 $str =~ m/^($endre)(.*)$/;
1617 my $body = $1;
1618 my $tail = $2;
1619 if (length($tail) > 4) {
1620 $tail = "... ";
1621 }
1622 return "$body$tail";
1623 }
1624 }
1626 # takes the same arguments as chop_str, but also wraps a <span> around the
1627 # result with a title attribute if it does get chopped. Additionally, the
1628 # string is HTML-escaped.
1629 sub chop_and_escape_str {
1630 my ($str) = @_;
1632 my $chopped = chop_str(@_);
1633 if ($chopped eq $str) {
1634 return esc_html($chopped);
1635 } else {
1636 $str =~ s/[[:cntrl:]]/?/g;
1637 return $cgi->span({-title=>$str}, esc_html($chopped));
1638 }
1639 }
1641 ## ----------------------------------------------------------------------
1642 ## functions returning short strings
1644 # CSS class for given age value (in seconds)
1645 sub age_class {
1646 my $age = shift;
1648 if (!defined $age) {
1649 return "noage";
1650 } elsif ($age < 60*60*2) {
1651 return "age0";
1652 } elsif ($age < 60*60*24*2) {
1653 return "age1";
1654 } else {
1655 return "age2";
1656 }
1657 }
1659 # convert age in seconds to "nn units ago" string
1660 sub age_string {
1661 my $age = shift;
1662 my $age_str;
1664 if ($age > 60*60*24*365*2) {
1665 $age_str = (int $age/60/60/24/365);
1666 $age_str .= " years ago";
1667 } elsif ($age > 60*60*24*(365/12)*2) {
1668 $age_str = int $age/60/60/24/(365/12);
1669 $age_str .= " months ago";
1670 } elsif ($age > 60*60*24*7*2) {
1671 $age_str = int $age/60/60/24/7;
1672 $age_str .= " weeks ago";
1673 } elsif ($age > 60*60*24*2) {
1674 $age_str = int $age/60/60/24;
1675 $age_str .= " days ago";
1676 } elsif ($age > 60*60*2) {
1677 $age_str = int $age/60/60;
1678 $age_str .= " hours ago";
1679 } elsif ($age > 60*2) {
1680 $age_str = int $age/60;
1681 $age_str .= " min ago";
1682 } elsif ($age > 2) {
1683 $age_str = int $age;
1684 $age_str .= " sec ago";
1685 } else {
1686 $age_str .= " right now";
1687 }
1688 return $age_str;
1689 }
1691 use constant {
1692 S_IFINVALID => 0030000,
1693 S_IFGITLINK => 0160000,
1694 };
1696 # submodule/subproject, a commit object reference
1697 sub S_ISGITLINK {
1698 my $mode = shift;
1700 return (($mode & S_IFMT) == S_IFGITLINK)
1701 }
1703 # convert file mode in octal to symbolic file mode string
1704 sub mode_str {
1705 my $mode = oct shift;
1707 if (S_ISGITLINK($mode)) {
1708 return 'm---------';
1709 } elsif (S_ISDIR($mode & S_IFMT)) {
1710 return 'drwxr-xr-x';
1711 } elsif (S_ISLNK($mode)) {
1712 return 'lrwxrwxrwx';
1713 } elsif (S_ISREG($mode)) {
1714 # git cares only about the executable bit
1715 if ($mode & S_IXUSR) {
1716 return '-rwxr-xr-x';
1717 } else {
1718 return '-rw-r--r--';
1719 };
1720 } else {
1721 return '----------';
1722 }
1723 }
1725 # convert file mode in octal to file type string
1726 sub file_type {
1727 my $mode = shift;
1729 if ($mode !~ m/^[0-7]+$/) {
1730 return $mode;
1731 } else {
1732 $mode = oct $mode;
1733 }
1735 if (S_ISGITLINK($mode)) {
1736 return "submodule";
1737 } elsif (S_ISDIR($mode & S_IFMT)) {
1738 return "directory";
1739 } elsif (S_ISLNK($mode)) {
1740 return "symlink";
1741 } elsif (S_ISREG($mode)) {
1742 return "file";
1743 } else {
1744 return "unknown";
1745 }
1746 }
1748 # convert file mode in octal to file type description string
1749 sub file_type_long {
1750 my $mode = shift;
1752 if ($mode !~ m/^[0-7]+$/) {
1753 return $mode;
1754 } else {
1755 $mode = oct $mode;
1756 }
1758 if (S_ISGITLINK($mode)) {
1759 return "submodule";
1760 } elsif (S_ISDIR($mode & S_IFMT)) {
1761 return "directory";
1762 } elsif (S_ISLNK($mode)) {
1763 return "symlink";
1764 } elsif (S_ISREG($mode)) {
1765 if ($mode & S_IXUSR) {
1766 return "executable";
1767 } else {
1768 return "file";
1769 };
1770 } else {
1771 return "unknown";
1772 }
1773 }
1776 ## ----------------------------------------------------------------------
1777 ## functions returning short HTML fragments, or transforming HTML fragments
1778 ## which don't belong to other sections
1780 # format line of commit message.
1781 sub format_log_line_html {
1782 my $line = shift;
1784 $line = esc_html($line, -nbsp=>1);
1785 $line =~ s{\b([0-9a-fA-F]{8,40})\b}{
1786 $cgi->a({-href => href(action=>"object", hash=>$1),
1787 -class => "text"}, $1);
1788 }eg;
1790 return $line;
1791 }
1793 # format marker of refs pointing to given object
1795 # the destination action is chosen based on object type and current context:
1796 # - for annotated tags, we choose the tag view unless it's the current view
1797 # already, in which case we go to shortlog view
1798 # - for other refs, we keep the current view if we're in history, shortlog or
1799 # log view, and select shortlog otherwise
1800 sub format_ref_marker {
1801 my ($refs, $id) = @_;
1802 my $markers = '';
1804 if (defined $refs->{$id}) {
1805 foreach my $ref (@{$refs->{$id}}) {
1806 # this code exploits the fact that non-lightweight tags are the
1807 # only indirect objects, and that they are the only objects for which
1808 # we want to use tag instead of shortlog as action
1809 my ($type, $name) = qw();
1810 my $indirect = ($ref =~ s/\^\{\}$//);
1811 # e.g. tags/v2.6.11 or heads/next
1812 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1813 $type = $1;
1814 $name = $2;
1815 } else {
1816 $type = "ref";
1817 $name = $ref;
1818 }
1820 my $class = $type;
1821 $class .= " indirect" if $indirect;
1823 my $dest_action = "shortlog";
1825 if ($indirect) {
1826 $dest_action = "tag" unless $action eq "tag";
1827 } elsif ($action =~ /^(history|(short)?log)$/) {
1828 $dest_action = $action;
1829 }
1831 my $dest = "";
1832 $dest .= "refs/" unless $ref =~ m!^refs/!;
1833 $dest .= $ref;
1835 my $link = $cgi->a({
1836 -href => href(
1837 action=>$dest_action,
1838 hash=>$dest
1839 )}, $name);
1841 $markers .= " <span class=\"".esc_attr($class)."\" title=\"".esc_attr($ref)."\">" .
1842 $link . "</span>";
1843 }
1844 }
1846 if ($markers) {
1847 return ' <span class="refs">'. $markers . '</span>';
1848 } else {
1849 return "";
1850 }
1851 }
1853 # format, perhaps shortened and with markers, title line
1854 sub format_subject_html {
1855 my ($long, $short, $href, $extra) = @_;
1856 $extra = '' unless defined($extra);
1858 if (length($short) < length($long)) {
1859 $long =~ s/[[:cntrl:]]/?/g;
1860 return $cgi->a({-href => $href, -class => "list subject",
1861 -title => to_utf8($long)},
1862 esc_html($short)) . $extra;
1863 } else {
1864 return $cgi->a({-href => $href, -class => "list subject"},
1865 esc_html($long)) . $extra;
1866 }
1867 }
1869 # Rather than recomputing the url for an email multiple times, we cache it
1870 # after the first hit. This gives a visible benefit in views where the avatar
1871 # for the same email is used repeatedly (e.g. shortlog).
1872 # The cache is shared by all avatar engines (currently gravatar only), which
1873 # are free to use it as preferred. Since only one avatar engine is used for any
1874 # given page, there's no risk for cache conflicts.
1875 our %avatar_cache = ();
1877 # Compute the picon url for a given email, by using the picon search service over at
1878 # http://www.cs.indiana.edu/picons/search.html
1879 sub picon_url {
1880 my $email = lc shift;
1881 if (!$avatar_cache{$email}) {
1882 my ($user, $domain) = split('@', $email);
1883 $avatar_cache{$email} =
1884 "http://www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
1885 "$domain/$user/" .
1886 "users+domains+unknown/up/single";
1887 }
1888 return $avatar_cache{$email};
1889 }
1891 # Compute the gravatar url for a given email, if it's not in the cache already.
1892 # Gravatar stores only the part of the URL before the size, since that's the
1893 # one computationally more expensive. This also allows reuse of the cache for
1894 # different sizes (for this particular engine).
1895 sub gravatar_url {
1896 my $email = lc shift;
1897 my $size = shift;
1898 $avatar_cache{$email} ||=
1899 "http://www.gravatar.com/avatar/" .
1900 Digest::MD5::md5_hex($email) . "?s=";
1901 return $avatar_cache{$email} . $size;
1902 }
1904 # Insert an avatar for the given $email at the given $size if the feature
1905 # is enabled.
1906 sub git_get_avatar {
1907 my ($email, %opts) = @_;
1908 my $pre_white = ($opts{-pad_before} ? " " : "");
1909 my $post_white = ($opts{-pad_after} ? " " : "");
1910 $opts{-size} ||= 'default';
1911 my $size = $avatar_size{$opts{-size}} || $avatar_size{'default'};
1912 my $url = "";
1913 if ($git_avatar eq 'gravatar') {
1914 $url = gravatar_url($email, $size);
1915 } elsif ($git_avatar eq 'picon') {
1916 $url = picon_url($email);
1917 }
1918 # Other providers can be added by extending the if chain, defining $url
1919 # as needed. If no variant puts something in $url, we assume avatars
1920 # are completely disabled/unavailable.
1921 if ($url) {
1922 return $pre_white .
1923 "<img width=\"$size\" " .
1924 "class=\"avatar\" " .
1925 "src=\"".esc_url($url)."\" " .
1926 "alt=\"\" " .
1927 "/>" . $post_white;
1928 } else {
1929 return "";
1930 }
1931 }
1933 sub format_search_author {
1934 my ($author, $searchtype, $displaytext) = @_;
1935 my $have_search = gitweb_check_feature('search');
1937 if ($have_search) {
1938 my $performed = "";
1939 if ($searchtype eq 'author') {
1940 $performed = "authored";
1941 } elsif ($searchtype eq 'committer') {
1942 $performed = "committed";
1943 }
1945 return $cgi->a({-href => href(action=>"search", hash=>$hash,
1946 searchtext=>$author,
1947 searchtype=>$searchtype), class=>"list",
1948 title=>"Search for commits $performed by $author"},
1949 $displaytext);
1951 } else {
1952 return $displaytext;
1953 }
1954 }
1956 # format the author name of the given commit with the given tag
1957 # the author name is chopped and escaped according to the other
1958 # optional parameters (see chop_str).
1959 sub format_author_html {
1960 my $tag = shift;
1961 my $co = shift;
1962 my $author = chop_and_escape_str($co->{'author_name'}, @_);
1963 return "<$tag class=\"author\">" .
1964 format_search_author($co->{'author_name'}, "author",
1965 git_get_avatar($co->{'author_email'}, -pad_after => 1) .
1966 $author) .
1967 "</$tag>";
1968 }
1970 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1971 sub format_git_diff_header_line {
1972 my $line = shift;
1973 my $diffinfo = shift;
1974 my ($from, $to) = @_;
1976 if ($diffinfo->{'nparents'}) {
1977 # combined diff
1978 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1979 if ($to->{'href'}) {
1980 $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
1981 esc_path($to->{'file'}));
1982 } else { # file was deleted (no href)
1983 $line .= esc_path($to->{'file'});
1984 }
1985 } else {
1986 # "ordinary" diff
1987 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1988 if ($from->{'href'}) {
1989 $line .= $cgi->a({-href => $from->{'href'}, -class => "path"},
1990 'a/' . esc_path($from->{'file'}));
1991 } else { # file was added (no href)
1992 $line .= 'a/' . esc_path($from->{'file'});
1993 }
1994 $line .= ' ';
1995 if ($to->{'href'}) {
1996 $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
1997 'b/' . esc_path($to->{'file'}));
1998 } else { # file was deleted
1999 $line .= 'b/' . esc_path($to->{'file'});
2000 }
2001 }
2003 return "<div class=\"diff header\">$line</div>\n";
2004 }
2006 # format extended diff header line, before patch itself
2007 sub format_extended_diff_header_line {
2008 my $line = shift;
2009 my $diffinfo = shift;
2010 my ($from, $to) = @_;
2012 # match <path>
2013 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
2014 $line .= $cgi->a({-href=>$from->{'href'}, -class=>"path"},
2015 esc_path($from->{'file'}));
2016 }
2017 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
2018 $line .= $cgi->a({-href=>$to->{'href'}, -class=>"path"},
2019 esc_path($to->{'file'}));
2020 }
2021 # match single <mode>
2022 if ($line =~ m/\s(\d{6})$/) {
2023 $line .= '<span class="info"> (' .
2024 file_type_long($1) .
2025 ')</span>';
2026 }
2027 # match <hash>
2028 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
2029 # can match only for combined diff
2030 $line = 'index ';
2031 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2032 if ($from->{'href'}[$i]) {
2033 $line .= $cgi->a({-href=>$from->{'href'}[$i],
2034 -class=>"hash"},
2035 substr($diffinfo->{'from_id'}[$i],0,7));
2036 } else {
2037 $line .= '0' x 7;
2038 }
2039 # separator
2040 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
2041 }
2042 $line .= '..';
2043 if ($to->{'href'}) {
2044 $line .= $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
2045 substr($diffinfo->{'to_id'},0,7));
2046 } else {
2047 $line .= '0' x 7;
2048 }
2050 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
2051 # can match only for ordinary diff
2052 my ($from_link, $to_link);
2053 if ($from->{'href'}) {
2054 $from_link = $cgi->a({-href=>$from->{'href'}, -class=>"hash"},
2055 substr($diffinfo->{'from_id'},0,7));
2056 } else {
2057 $from_link = '0' x 7;
2058 }
2059 if ($to->{'href'}) {
2060 $to_link = $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
2061 substr($diffinfo->{'to_id'},0,7));
2062 } else {
2063 $to_link = '0' x 7;
2064 }
2065 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2066 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2067 }
2069 return $line . "<br/>\n";
2070 }
2072 # format from-file/to-file diff header
2073 sub format_diff_from_to_header {
2074 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
2075 my $line;
2076 my $result = '';
2078 $line = $from_line;
2079 #assert($line =~ m/^---/) if DEBUG;
2080 # no extra formatting for "^--- /dev/null"
2081 if (! $diffinfo->{'nparents'}) {
2082 # ordinary (single parent) diff
2083 if ($line =~ m!^--- "?a/!) {
2084 if ($from->{'href'}) {
2085 $line = '--- a/' .
2086 $cgi->a({-href=>$from->{'href'}, -class=>"path"},
2087 esc_path($from->{'file'}));
2088 } else {
2089 $line = '--- a/' .
2090 esc_path($from->{'file'});
2091 }
2092 }
2093 $result .= qq!<div class="diff from_file">$line</div>\n!;
2095 } else {
2096 # combined diff (merge commit)
2097 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2098 if ($from->{'href'}[$i]) {
2099 $line = '--- ' .
2100 $cgi->a({-href=>href(action=>"blobdiff",
2101 hash_parent=>$diffinfo->{'from_id'}[$i],
2102 hash_parent_base=>$parents[$i],
2103 file_parent=>$from->{'file'}[$i],
2104 hash=>$diffinfo->{'to_id'},
2105 hash_base=>$hash,
2106 file_name=>$to->{'file'}),
2107 -class=>"path",
2108 -title=>"diff" . ($i+1)},
2109 $i+1) .
2110 '/' .
2111 $cgi->a({-href=>$from->{'href'}[$i], -class=>"path"},
2112 esc_path($from->{'file'}[$i]));
2113 } else {
2114 $line = '--- /dev/null';
2115 }
2116 $result .= qq!<div class="diff from_file">$line</div>\n!;
2117 }
2118 }
2120 $line = $to_line;
2121 #assert($line =~ m/^\+\+\+/) if DEBUG;
2122 # no extra formatting for "^+++ /dev/null"
2123 if ($line =~ m!^\+\+\+ "?b/!) {
2124 if ($to->{'href'}) {
2125 $line = '+++ b/' .
2126 $cgi->a({-href=>$to->{'href'}, -class=>"path"},
2127 esc_path($to->{'file'}));
2128 } else {
2129 $line = '+++ b/' .
2130 esc_path($to->{'file'});
2131 }
2132 }
2133 $result .= qq!<div class="diff to_file">$line</div>\n!;
2135 return $result;
2136 }
2138 # create note for patch simplified by combined diff
2139 sub format_diff_cc_simplified {
2140 my ($diffinfo, @parents) = @_;
2141 my $result = '';
2143 $result .= "<div class=\"diff header\">" .
2144 "diff --cc ";
2145 if (!is_deleted($diffinfo)) {
2146 $result .= $cgi->a({-href => href(action=>"blob",
2147 hash_base=>$hash,
2148 hash=>$diffinfo->{'to_id'},
2149 file_name=>$diffinfo->{'to_file'}),
2150 -class => "path"},
2151 esc_path($diffinfo->{'to_file'}));
2152 } else {
2153 $result .= esc_path($diffinfo->{'to_file'});
2154 }
2155 $result .= "</div>\n" . # class="diff header"
2156 "<div class=\"diff nodifferences\">" .
2157 "Simple merge" .
2158 "</div>\n"; # class="diff nodifferences"
2160 return $result;
2161 }
2163 # format patch (diff) line (not to be used for diff headers)
2164 sub format_diff_line {
2165 my $line = shift;
2166 my ($from, $to) = @_;
2167 my $diff_class = "";
2169 chomp $line;
2171 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2172 # combined diff
2173 my $prefix = substr($line, 0, scalar @{$from->{'href'}});
2174 if ($line =~ m/^\@{3}/) {
2175 $diff_class = " chunk_header";
2176 } elsif ($line =~ m/^\\/) {
2177 $diff_class = " incomplete";
2178 } elsif ($prefix =~ tr/+/+/) {
2179 $diff_class = " add";
2180 } elsif ($prefix =~ tr/-/-/) {
2181 $diff_class = " rem";
2182 }
2183 } else {
2184 # assume ordinary diff
2185 my $char = substr($line, 0, 1);
2186 if ($char eq '+') {
2187 $diff_class = " add";
2188 } elsif ($char eq '-') {
2189 $diff_class = " rem";
2190 } elsif ($char eq '@') {
2191 $diff_class = " chunk_header";
2192 } elsif ($char eq "\\") {
2193 $diff_class = " incomplete";
2194 }
2195 }
2196 $line = untabify($line);
2197 if ($from && $to && $line =~ m/^\@{2} /) {
2198 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2199 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2201 $from_lines = 0 unless defined $from_lines;
2202 $to_lines = 0 unless defined $to_lines;
2204 if ($from->{'href'}) {
2205 $from_text = $cgi->a({-href=>"$from->{'href'}#l$from_start",
2206 -class=>"list"}, $from_text);
2207 }
2208 if ($to->{'href'}) {
2209 $to_text = $cgi->a({-href=>"$to->{'href'}#l$to_start",
2210 -class=>"list"}, $to_text);
2211 }
2212 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2213 "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
2214 return "<div class=\"diff$diff_class\">$line</div>\n";
2215 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2216 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2217 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2219 @from_text = split(' ', $ranges);
2220 for (my $i = 0; $i < @from_text; ++$i) {
2221 ($from_start[$i], $from_nlines[$i]) =
2222 (split(',', substr($from_text[$i], 1)), 0);
2223 }
2225 $to_text = pop @from_text;
2226 $to_start = pop @from_start;
2227 $to_nlines = pop @from_nlines;
2229 $line = "<span class=\"chunk_info\">$prefix ";
2230 for (my $i = 0; $i < @from_text; ++$i) {
2231 if ($from->{'href'}[$i]) {
2232 $line .= $cgi->a({-href=>"$from->{'href'}[$i]#l$from_start[$i]",
2233 -class=>"list"}, $from_text[$i]);
2234 } else {
2235 $line .= $from_text[$i];
2236 }
2237 $line .= " ";
2238 }
2239 if ($to->{'href'}) {
2240 $line .= $cgi->a({-href=>"$to->{'href'}#l$to_start",
2241 -class=>"list"}, $to_text);
2242 } else {
2243 $line .= $to_text;
2244 }
2245 $line .= " $prefix</span>" .
2246 "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
2247 return "<div class=\"diff$diff_class\">$line</div>\n";
2248 }
2249 return "<div class=\"diff$diff_class\">" . esc_html($line, -nbsp=>1) . "</div>\n";
2250 }
2252 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2253 # linked. Pass the hash of the tree/commit to snapshot.
2254 sub format_snapshot_links {
2255 my ($hash) = @_;
2256 my $num_fmts = @snapshot_fmts;
2257 if ($num_fmts > 1) {
2258 # A parenthesized list of links bearing format names.
2259 # e.g. "snapshot (_tar.gz_ _zip_)"
2260 return "snapshot (" . join(' ', map
2261 $cgi->a({
2262 -href => href(
2263 action=>"snapshot",
2264 hash=>$hash,
2265 snapshot_format=>$_
2266 )
2267 }, $known_snapshot_formats{$_}{'display'})
2268 , @snapshot_fmts) . ")";
2269 } elsif ($num_fmts == 1) {
2270 # A single "snapshot" link whose tooltip bears the format name.
2271 # i.e. "_snapshot_"
2272 my ($fmt) = @snapshot_fmts;
2273 return
2274 $cgi->a({
2275 -href => href(
2276 action=>"snapshot",
2277 hash=>$hash,
2278 snapshot_format=>$fmt
2279 ),
2280 -title => "in format: $known_snapshot_formats{$fmt}{'display'}"
2281 }, "snapshot");
2282 } else { # $num_fmts == 0
2283 return undef;
2284 }
2285 }
2287 ## ......................................................................
2288 ## functions returning values to be passed, perhaps after some
2289 ## transformation, to other functions; e.g. returning arguments to href()
2291 # returns hash to be passed to href to generate gitweb URL
2292 # in -title key it returns description of link
2293 sub get_feed_info {
2294 my $format = shift || 'Atom';
2295 my %res = (action => lc($format));
2297 # feed links are possible only for project views
2298 return unless (defined $project);
2299 # some views should link to OPML, or to generic project feed,
2300 # or don't have specific feed yet (so they should use generic)
2301 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
2303 my $branch;
2304 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
2305 # from tag links; this also makes possible to detect branch links
2306 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
2307 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
2308 $branch = $1;
2309 }
2310 # find log type for feed description (title)
2311 my $type = 'log';
2312 if (defined $file_name) {
2313 $type = "history of $file_name";
2314 $type .= "/" if ($action eq 'tree');
2315 $type .= " on '$branch'" if (defined $branch);
2316 } else {
2317 $type = "log of $branch" if (defined $branch);
2318 }
2320 $res{-title} = $type;
2321 $res{'hash'} = (defined $branch ? "refs/heads/$branch" : undef);
2322 $res{'file_name'} = $file_name;
2324 return %res;
2325 }
2327 ## ----------------------------------------------------------------------
2328 ## git utility subroutines, invoking git commands
2330 # returns path to the core git executable and the --git-dir parameter as list
2331 sub git_cmd {
2332 $number_of_git_cmds++;
2333 return $GIT, '--git-dir='.$git_dir;
2334 }
2336 # quote the given arguments for passing them to the shell
2337 # quote_command("command", "arg 1", "arg with ' and ! characters")
2338 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2339 # Try to avoid using this function wherever possible.
2340 sub quote_command {
2341 return join(' ',
2342 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
2343 }
2345 # get HEAD ref of given project as hash
2346 sub git_get_head_hash {
2347 return git_get_full_hash(shift, 'HEAD');
2348 }
2350 sub git_get_full_hash {
2351 return git_get_hash(@_);
2352 }
2354 sub git_get_short_hash {
2355 return git_get_hash(@_, '--short=7');
2356 }
2358 sub git_get_hash {
2359 my ($project, $hash, @options) = @_;
2360 my $o_git_dir = $git_dir;
2361 my $retval = undef;
2362 $git_dir = "$projectroot/$project";
2363 if (open my $fd, '-|', git_cmd(), 'rev-parse',
2364 '--verify', '-q', @options, $hash) {
2365 $retval = <$fd>;
2366 chomp $retval if defined $retval;
2367 close $fd;
2368 }
2369 if (defined $o_git_dir) {
2370 $git_dir = $o_git_dir;
2371 }
2372 return $retval;
2373 }
2375 # get type of given object
2376 sub git_get_type {
2377 my $hash = shift;
2379 open my $fd, "-|", git_cmd(), "cat-file", '-t', $hash or return;
2380 my $type = <$fd>;
2381 close $fd or return;
2382 chomp $type;
2383 return $type;
2384 }
2386 # repository configuration
2387 our $config_file = '';
2388 our %config;
2390 # store multiple values for single key as anonymous array reference
2391 # single values stored directly in the hash, not as [ <value> ]
2392 sub hash_set_multi {
2393 my ($hash, $key, $value) = @_;
2395 if (!exists $hash->{$key}) {
2396 $hash->{$key} = $value;
2397 } elsif (!ref $hash->{$key}) {
2398 $hash->{$key} = [ $hash->{$key}, $value ];
2399 } else {
2400 push @{$hash->{$key}}, $value;
2401 }
2402 }
2404 # return hash of git project configuration
2405 # optionally limited to some section, e.g. 'gitweb'
2406 sub git_parse_project_config {
2407 my $section_regexp = shift;
2408 my %config;
2410 local $/ = "\0";
2412 open my $fh, "-|", git_cmd(), "config", '-z', '-l',
2413 or return;
2415 while (my $keyval = <$fh>) {
2416 chomp $keyval;
2417 my ($key, $value) = split(/\n/, $keyval, 2);
2419 hash_set_multi(\%config, $key, $value)
2420 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2421 }
2422 close $fh;
2424 return %config;
2425 }
2427 # convert config value to boolean: 'true' or 'false'
2428 # no value, number > 0, 'true' and 'yes' values are true
2429 # rest of values are treated as false (never as error)
2430 sub config_to_bool {
2431 my $val = shift;
2433 return 1 if !defined $val; # section.key
2435 # strip leading and trailing whitespace
2436 $val =~ s/^\s+//;
2437 $val =~ s/\s+$//;
2439 return (($val =~ /^\d+$/ && $val) || # section.key = 1
2440 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2441 }
2443 # convert config value to simple decimal number
2444 # an optional value suffix of 'k', 'm', or 'g' will cause the value
2445 # to be multiplied by 1024, 1048576, or 1073741824
2446 sub config_to_int {
2447 my $val = shift;
2449 # strip leading and trailing whitespace
2450 $val =~ s/^\s+//;
2451 $val =~ s/\s+$//;
2453 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2454 $unit = lc($unit);
2455 # unknown unit is treated as 1
2456 return $num * ($unit eq 'g' ? 1073741824 :
2457 $unit eq 'm' ? 1048576 :
2458 $unit eq 'k' ? 1024 : 1);
2459 }
2460 return $val;
2461 }
2463 # convert config value to array reference, if needed
2464 sub config_to_multi {
2465 my $val = shift;
2467 return ref($val) ? $val : (defined($val) ? [ $val ] : []);
2468 }
2470 sub git_get_project_config {
2471 my ($key, $type) = @_;
2473 return unless defined $git_dir;
2475 # key sanity check
2476 return unless ($key);
2477 $key =~ s/^gitweb\.//;
2478 return if ($key =~ m/\W/);
2480 # type sanity check
2481 if (defined $type) {
2482 $type =~ s/^--//;
2483 $type = undef
2484 unless ($type eq 'bool' || $type eq 'int');
2485 }
2487 # get config
2488 if (!defined $config_file ||
2489 $config_file ne "$git_dir/config") {
2490 %config = git_parse_project_config('gitweb');
2491 $config_file = "$git_dir/config";
2492 }
2494 # check if config variable (key) exists
2495 return unless exists $config{"gitweb.$key"};
2497 # ensure given type
2498 if (!defined $type) {
2499 return $config{"gitweb.$key"};
2500 } elsif ($type eq 'bool') {
2501 # backward compatibility: 'git config --bool' returns true/false
2502 return config_to_bool($config{"gitweb.$key"}) ? 'true' : 'false';
2503 } elsif ($type eq 'int') {
2504 return config_to_int($config{"gitweb.$key"});
2505 }
2506 return $config{"gitweb.$key"};
2507 }
2509 # get hash of given path at given ref
2510 sub git_get_hash_by_path {
2511 my $base = shift;
2512 my $path = shift || return undef;
2513 my $type = shift;
2515 $path =~ s,/+$,,;
2517 open my $fd, "-|", git_cmd(), "ls-tree", $base, "--", $path
2518 or die_error(500, "Open git-ls-tree failed");
2519 my $line = <$fd>;
2520 close $fd or return undef;
2522 if (!defined $line) {
2523 # there is no tree or hash given by $path at $base
2524 return undef;
2525 }
2527 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2528 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2529 if (defined $type && $type ne $2) {
2530 # type doesn't match
2531 return undef;
2532 }
2533 return $3;
2534 }
2536 # get path of entry with given hash at given tree-ish (ref)
2537 # used to get 'from' filename for combined diff (merge commit) for renames
2538 sub git_get_path_by_hash {
2539 my $base = shift || return;
2540 my $hash = shift || return;
2542 local $/ = "\0";
2544 open my $fd, "-|", git_cmd(), "ls-tree", '-r', '-t', '-z', $base
2545 or return undef;
2546 while (my $line = <$fd>) {
2547 chomp $line;
2549 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2550 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2551 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2552 close $fd;
2553 return $1;
2554 }
2555 }
2556 close $fd;
2557 return undef;
2558 }
2560 ## ......................................................................
2561 ## git utility functions, directly accessing git repository
2563 sub git_get_project_description {
2564 my $path = shift;
2566 $git_dir = "$projectroot/$path";
2567 open my $fd, '<', "$git_dir/description"
2568 or return git_get_project_config('description');
2569 my $descr = <$fd>;
2570 close $fd;
2571 if (defined $descr) {
2572 chomp $descr;
2573 }
2574 return $descr;
2575 }
2577 sub git_get_project_ctags {
2578 my $path = shift;
2579 my $ctags = {};
2581 $git_dir = "$projectroot/$path";
2582 opendir my $dh, "$git_dir/ctags"
2583 or return $ctags;
2584 foreach (grep { -f $_ } map { "$git_dir/ctags/$_" } readdir($dh)) {
2585 open my $ct, '<', $_ or next;
2586 my $val = <$ct>;
2587 chomp $val;
2588 close $ct;
2589 my $ctag = $_; $ctag =~ s#.*/##;
2590 $ctags->{$ctag} = $val;
2591 }
2592 closedir $dh;
2593 $ctags;
2594 }
2596 sub git_populate_project_tagcloud {
2597 my $ctags = shift;
2599 # First, merge different-cased tags; tags vote on casing
2600 my %ctags_lc;
2601 foreach (keys %$ctags) {
2602 $ctags_lc{lc $_}->{count} += $ctags->{$_};
2603 if (not $ctags_lc{lc $_}->{topcount}
2604 or $ctags_lc{lc $_}->{topcount} < $ctags->{$_}) {
2605 $ctags_lc{lc $_}->{topcount} = $ctags->{$_};
2606 $ctags_lc{lc $_}->{topname} = $_;
2607 }
2608 }
2610 my $cloud;
2611 if (eval { require HTML::TagCloud; 1; }) {
2612 $cloud = HTML::TagCloud->new;
2613 foreach (sort keys %ctags_lc) {
2614 # Pad the title with spaces so that the cloud looks
2615 # less crammed.
2616 my $title = $ctags_lc{$_}->{topname};
2617 $title =~ s/ / /g;
2618 $title =~ s/^/ /g;
2619 $title =~ s/$/ /g;
2620 $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count});
2621 }
2622 } else {
2623 $cloud = \%ctags_lc;
2624 }
2625 $cloud;
2626 }
2628 sub git_show_project_tagcloud {
2629 my ($cloud, $count) = @_;
2630 print STDERR ref($cloud)."..\n";
2631 if (ref $cloud eq 'HTML::TagCloud') {
2632 return $cloud->html_and_css($count);
2633 } else {
2634 my @tags = sort { $cloud->{$a}->{count} <=> $cloud->{$b}->{count} } keys %$cloud;
2635 return '<p align="center">' . join (', ', map {
2636 $cgi->a({-href=>"$home_link?by_tag=$_"}, $cloud->{$_}->{topname})
2637 } splice(@tags, 0, $count)) . '</p>';
2638 }
2639 }
2641 sub git_get_project_url_list {
2642 my $path = shift;
2644 $git_dir = "$projectroot/$path";
2645 open my $fd, '<', "$git_dir/cloneurl"
2646 or return wantarray ?
2647 @{ config_to_multi(git_get_project_config('url')) } :
2648 config_to_multi(git_get_project_config('url'));
2649 my @git_project_url_list = map { chomp; $_ } <$fd>;
2650 close $fd;
2652 return wantarray ? @git_project_url_list : \@git_project_url_list;
2653 }
2655 sub git_get_projects_list {
2656 my ($filter) = @_;
2657 my @list;
2659 $filter ||= '';
2660 $filter =~ s/\.git$//;
2662 my $check_forks = gitweb_check_feature('forks');
2664 if (-d $projects_list) {
2665 # search in directory
2666 my $dir = $projects_list . ($filter ? "/$filter" : '');
2667 # remove the trailing "/"
2668 $dir =~ s!/+$!!;
2669 my $pfxlen = length("$dir");
2670 my $pfxdepth = ($dir =~ tr!/!!);
2672 File::Find::find({
2673 follow_fast => 1, # follow symbolic links
2674 follow_skip => 2, # ignore duplicates
2675 dangling_symlinks => 0, # ignore dangling symlinks, silently
2676 wanted => sub {
2677 # global variables
2678 our $project_maxdepth;
2679 our $projectroot;
2680 # skip project-list toplevel, if we get it.
2681 return if (m!^[/.]$!);
2682 # only directories can be git repositories
2683 return unless (-d $_);
2684 # don't traverse too deep (Find is super slow on os x)
2685 if (($File::Find::name =~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2686 $File::Find::prune = 1;
2687 return;
2688 }
2690 my $subdir = substr($File::Find::name, $pfxlen + 1);
2691 # we check related file in $projectroot
2692 my $path = ($filter ? "$filter/" : '') . $subdir;
2693 if (check_export_ok("$projectroot/$path")) {
2694 push @list, { path => $path };
2695 $File::Find::prune = 1;
2696 }
2697 },
2698 }, "$dir");
2700 } elsif (-f $projects_list) {
2701 # read from file(url-encoded):
2702 # 'git%2Fgit.git Linus+Torvalds'
2703 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2704 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2705 my %paths;
2706 open my $fd, '<', $projects_list or return;
2707 PROJECT:
2708 while (my $line = <$fd>) {
2709 chomp $line;
2710 my ($path, $owner) = split ' ', $line;
2711 $path = unescape($path);
2712 $owner = unescape($owner);
2713 if (!defined $path) {
2714 next;
2715 }
2716 if ($filter ne '') {
2717 # looking for forks;
2718 my $pfx = substr($path, 0, length($filter));
2719 if ($pfx ne $filter) {
2720 next PROJECT;
2721 }
2722 my $sfx = substr($path, length($filter));
2723 if ($sfx !~ /^\/.*\.git$/) {
2724 next PROJECT;
2725 }
2726 } elsif ($check_forks) {
2727 PATH:
2728 foreach my $filter (keys %paths) {
2729 # looking for forks;
2730 my $pfx = substr($path, 0, length($filter));
2731 if ($pfx ne $filter) {
2732 next PATH;
2733 }
2734 my $sfx = substr($path, length($filter));
2735 if ($sfx !~ /^\/.*\.git$/) {
2736 next PATH;
2737 }
2738 # is a fork, don't include it in
2739 # the list
2740 next PROJECT;
2741 }
2742 }
2743 if (check_export_ok("$projectroot/$path")) {
2744 my $pr = {
2745 path => $path,
2746 owner => to_utf8($owner),
2747 };
2748 push @list, $pr;
2749 (my $forks_path = $path) =~ s/\.git$//;
2750 $paths{$forks_path}++;
2751 }
2752 }
2753 close $fd;
2754 }
2755 return @list;
2756 }
2758 our $gitweb_project_owner = undef;
2759 sub git_get_project_list_from_file {
2761 return if (defined $gitweb_project_owner);
2763 $gitweb_project_owner = {};
2764 # read from file (url-encoded):
2765 # 'git%2Fgit.git Linus+Torvalds'
2766 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2767 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2768 if (-f $projects_list) {
2769 open(my $fd, '<', $projects_list);
2770 while (my $line = <$fd>) {
2771 chomp $line;
2772 my ($pr, $ow) = split ' ', $line;
2773 $pr = unescape($pr);
2774 $ow = unescape($ow);
2775 $gitweb_project_owner->{$pr} = to_utf8($ow);
2776 }
2777 close $fd;
2778 }
2779 }
2781 sub git_get_project_owner {
2782 my $project = shift;
2783 my $owner;
2785 return undef unless $project;
2786 $git_dir = "$projectroot/$project";
2788 if (!defined $gitweb_project_owner) {
2789 git_get_project_list_from_file();
2790 }
2792 if (exists $gitweb_project_owner->{$project}) {
2793 $owner = $gitweb_project_owner->{$project};
2794 }
2795 if (!defined $owner){
2796 $owner = git_get_project_config('owner');
2797 }
2798 if (!defined $owner) {
2799 $owner = get_file_owner("$git_dir");
2800 }
2802 return $owner;
2803 }
2805 sub git_get_last_activity {
2806 my ($path) = @_;
2807 my $fd;
2809 $git_dir = "$projectroot/$path";
2810 open($fd, "-|", git_cmd(), 'for-each-ref',
2811 '--format=%(committer)',
2812 '--sort=-committerdate',
2813 '--count=1',
2814 'refs/heads') or return;
2815 my $most_recent = <$fd>;
2816 close $fd or return;
2817 if (defined $most_recent &&
2818 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2819 my $timestamp = $1;
2820 my $age = time - $timestamp;
2821 return ($age, age_string($age));
2822 }
2823 return (undef, undef);
2824 }
2826 # Implementation note: when a single remote is wanted, we cannot use 'git
2827 # remote show -n' because that command always work (assuming it's a remote URL
2828 # if it's not defined), and we cannot use 'git remote show' because that would
2829 # try to make a network roundtrip. So the only way to find if that particular
2830 # remote is defined is to walk the list provided by 'git remote -v' and stop if
2831 # and when we find what we want.
2832 sub git_get_remotes_list {
2833 my $wanted = shift;
2834 my %remotes = ();
2836 open my $fd, '-|' , git_cmd(), 'remote', '-v';
2837 return unless $fd;
2838 while (my $remote = <$fd>) {
2839 chomp $remote;
2840 $remote =~ s!\t(.*?)\s+\((\w+)\)$!!;
2841 next if $wanted and not $remote eq $wanted;
2842 my ($url, $key) = ($1, $2);
2844 $remotes{$remote} ||= { 'heads' => () };
2845 $remotes{$remote}{$key} = $url;
2846 }
2847 close $fd or return;
2848 return wantarray ? %remotes : \%remotes;
2849 }
2851 # Takes a hash of remotes as first parameter and fills it by adding the
2852 # available remote heads for each of the indicated remotes.
2853 sub fill_remote_heads {
2854 my $remotes = shift;
2855 my @heads = map { "remotes/$_" } keys %$remotes;
2856 my @remoteheads = git_get_heads_list(undef, @heads);
2857 foreach my $remote (keys %$remotes) {
2858 $remotes->{$remote}{'heads'} = [ grep {
2859 $_->{'name'} =~ s!^$remote/!!
2860 } @remoteheads ];
2861 }
2862 }
2864 sub git_get_references {
2865 my $type = shift || "";
2866 my %refs;
2867 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2868 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2869 open my $fd, "-|", git_cmd(), "show-ref", "--dereference",
2870 ($type ? ("--", "refs/$type") : ()) # use -- <pattern> if $type
2871 or return;
2873 while (my $line = <$fd>) {
2874 chomp $line;
2875 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2876 if (defined $refs{$1}) {
2877 push @{$refs{$1}}, $2;
2878 } else {
2879 $refs{$1} = [ $2 ];
2880 }
2881 }
2882 }
2883 close $fd or return;
2884 return \%refs;
2885 }
2887 sub git_get_rev_name_tags {
2888 my $hash = shift || return undef;
2890 open my $fd, "-|", git_cmd(), "name-rev", "--tags", $hash
2891 or return;
2892 my $name_rev = <$fd>;
2893 close $fd;
2895 if ($name_rev =~ m|^$hash tags/(.*)$|) {
2896 return $1;
2897 } else {
2898 # catches also '$hash undefined' output
2899 return undef;
2900 }
2901 }
2903 ## ----------------------------------------------------------------------
2904 ## parse to hash functions
2906 sub parse_date {
2907 my $epoch = shift;
2908 my $tz = shift || "-0000";
2910 my %date;
2911 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2912 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2913 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2914 $date{'hour'} = $hour;
2915 $date{'minute'} = $min;
2916 $date{'mday'} = $mday;
2917 $date{'day'} = $days[$wday];
2918 $date{'month'} = $months[$mon];
2919 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2920 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2921 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2922 $mday, $months[$mon], $hour ,$min;
2923 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2924 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2926 my ($tz_sign, $tz_hour, $tz_min) =
2927 ($tz =~ m/^([-+])(\d\d)(\d\d)$/);
2928 $tz_sign = ($tz_sign eq '-' ? -1 : +1);
2929 my $local = $epoch + $tz_sign*((($tz_hour*60) + $tz_min)*60);
2930 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2931 $date{'hour_local'} = $hour;
2932 $date{'minute_local'} = $min;
2933 $date{'tz_local'} = $tz;
2934 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2935 1900+$year, $mon+1, $mday,
2936 $hour, $min, $sec, $tz);
2937 return %date;
2938 }
2940 sub parse_tag {
2941 my $tag_id = shift;
2942 my %tag;
2943 my @comment;
2945 open my $fd, "-|", git_cmd(), "cat-file", "tag", $tag_id or return;
2946 $tag{'id'} = $tag_id;
2947 while (my $line = <$fd>) {
2948 chomp $line;
2949 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2950 $tag{'object'} = $1;
2951 } elsif ($line =~ m/^type (.+)$/) {
2952 $tag{'type'} = $1;
2953 } elsif ($line =~ m/^tag (.+)$/) {
2954 $tag{'name'} = $1;
2955 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2956 $tag{'author'} = $1;
2957 $tag{'author_epoch'} = $2;
2958 $tag{'author_tz'} = $3;
2959 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2960 $tag{'author_name'} = $1;
2961 $tag{'author_email'} = $2;
2962 } else {
2963 $tag{'author_name'} = $tag{'author'};
2964 }
2965 } elsif ($line =~ m/--BEGIN/) {
2966 push @comment, $line;
2967 last;
2968 } elsif ($line eq "") {
2969 last;
2970 }
2971 }
2972 push @comment, <$fd>;
2973 $tag{'comment'} = \@comment;
2974 close $fd or return;
2975 if (!defined $tag{'name'}) {
2976 return
2977 };
2978 return %tag
2979 }
2981 sub parse_commit_text {
2982 my ($commit_text, $withparents) = @_;
2983 my @commit_lines = split '\n', $commit_text;
2984 my %co;
2986 pop @commit_lines; # Remove '\0'
2988 if (! @commit_lines) {
2989 return;
2990 }
2992 my $header = shift @commit_lines;
2993 if ($header !~ m/^[0-9a-fA-F]{40}/) {
2994 return;
2995 }
2996 ($co{'id'}, my @parents) = split ' ', $header;
2997 while (my $line = shift @commit_lines) {
2998 last if $line eq "\n";
2999 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
3000 $co{'tree'} = $1;
3001 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
3002 push @parents, $1;
3003 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
3004 $co{'author'} = to_utf8($1);
3005 $co{'author_epoch'} = $2;
3006 $co{'author_tz'} = $3;
3007 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3008 $co{'author_name'} = $1;
3009 $co{'author_email'} = $2;
3010 } else {
3011 $co{'author_name'} = $co{'author'};
3012 }
3013 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
3014 $co{'committer'} = to_utf8($1);
3015 $co{'committer_epoch'} = $2;
3016 $co{'committer_tz'} = $3;
3017 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
3018 $co{'committer_name'} = $1;
3019 $co{'committer_email'} = $2;
3020 } else {
3021 $co{'committer_name'} = $co{'committer'};
3022 }
3023 }
3024 }
3025 if (!defined $co{'tree'}) {
3026 return;
3027 };
3028 $co{'parents'} = \@parents;
3029 $co{'parent'} = $parents[0];
3031 foreach my $title (@commit_lines) {
3032 $title =~ s/^ //;
3033 if ($title ne "") {
3034 $co{'title'} = chop_str($title, 80, 5);
3035 # remove leading stuff of merges to make the interesting part visible
3036 if (length($title) > 50) {
3037 $title =~ s/^Automatic //;
3038 $title =~ s/^merge (of|with) /Merge ... /i;
3039 if (length($title) > 50) {
3040 $title =~ s/(http|rsync):\/\///;
3041 }
3042 if (length($title) > 50) {
3043 $title =~ s/(master|www|rsync)\.//;
3044 }
3045 if (length($title) > 50) {
3046 $title =~ s/kernel.org:?//;
3047 }
3048 if (length($title) > 50) {
3049 $title =~ s/\/pub\/scm//;
3050 }
3051 }
3052 $co{'title_short'} = chop_str($title, 50, 5);
3053 last;
3054 }
3055 }
3056 if (! defined $co{'title'} || $co{'title'} eq "") {
3057 $co{'title'} = $co{'title_short'} = '(no commit message)';
3058 }
3059 # remove added spaces
3060 foreach my $line (@commit_lines) {
3061 $line =~ s/^ //;
3062 }
3063 $co{'comment'} = \@commit_lines;
3065 my $age = time - $co{'committer_epoch'};
3066 $co{'age'} = $age;
3067 $co{'age_string'} = age_string($age);
3068 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
3069 if ($age > 60*60*24*7*2) {
3070 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3071 $co{'age_string_age'} = $co{'age_string'};
3072 } else {
3073 $co{'age_string_date'} = $co{'age_string'};
3074 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3075 }
3076 return %co;
3077 }
3079 sub parse_commit {
3080 my ($commit_id) = @_;
3081 my %co;
3083 local $/ = "\0";
3085 open my $fd, "-|", git_cmd(), "rev-list",
3086 "--parents",
3087 "--header",
3088 "--max-count=1",
3089 $commit_id,
3090 "--",
3091 or die_error(500, "Open git-rev-list failed");
3092 %co = parse_commit_text(<$fd>, 1);
3093 close $fd;
3095 return %co;
3096 }
3098 sub parse_commits {
3099 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
3100 my @cos;
3102 $maxcount ||= 1;
3103 $skip ||= 0;
3105 local $/ = "\0";
3107 open my $fd, "-|", git_cmd(), "rev-list",
3108 "--header",
3109 @args,
3110 ("--max-count=" . $maxcount),
3111 ("--skip=" . $skip),
3112 @extra_options,
3113 $commit_id,
3114 "--",
3115 ($filename ? ($filename) : ())
3116 or die_error(500, "Open git-rev-list failed");
3117 while (my $line = <$fd>) {
3118 my %co = parse_commit_text($line);
3119 push @cos, \%co;
3120 }
3121 close $fd;
3123 return wantarray ? @cos : \@cos;
3124 }
3126 # parse line of git-diff-tree "raw" output
3127 sub parse_difftree_raw_line {
3128 my $line = shift;
3129 my %res;
3131 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3132 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
3133 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
3134 $res{'from_mode'} = $1;
3135 $res{'to_mode'} = $2;
3136 $res{'from_id'} = $3;
3137 $res{'to_id'} = $4;
3138 $res{'status'} = $5;
3139 $res{'similarity'} = $6;
3140 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
3141 ($res{'from_file'}, $res{'to_file'}) = map { unquote($_) } split("\t", $7);
3142 } else {
3143 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote($7);
3144 }
3145 }
3146 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3147 # combined diff (for merge commit)
3148 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
3149 $res{'nparents'} = length($1);
3150 $res{'from_mode'} = [ split(' ', $2) ];
3151 $res{'to_mode'} = pop @{$res{'from_mode'}};
3152 $res{'from_id'} = [ split(' ', $3) ];
3153 $res{'to_id'} = pop @{$res{'from_id'}};
3154 $res{'status'} = [ split('', $4) ];
3155 $res{'to_file'} = unquote($5);
3156 }
3157 # 'c512b523472485aef4fff9e57b229d9d243c967f'
3158 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
3159 $res{'commit'} = $1;
3160 }
3162 return wantarray ? %res : \%res;
3163 }
3165 # wrapper: return parsed line of git-diff-tree "raw" output
3166 # (the argument might be raw line, or parsed info)
3167 sub parsed_difftree_line {
3168 my $line_or_ref = shift;
3170 if (ref($line_or_ref) eq "HASH") {
3171 # pre-parsed (or generated by hand)
3172 return $line_or_ref;
3173 } else {
3174 return parse_difftree_raw_line($line_or_ref);
3175 }
3176 }
3178 # parse line of git-ls-tree output
3179 sub parse_ls_tree_line {
3180 my $line = shift;
3181 my %opts = @_;
3182 my %res;
3184 if ($opts{'-l'}) {
3185 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
3186 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40}) +(-|[0-9]+)\t(.+)$/s;
3188 $res{'mode'} = $1;
3189 $res{'type'} = $2;
3190 $res{'hash'} = $3;
3191 $res{'size'} = $4;
3192 if ($opts{'-z'}) {
3193 $res{'name'} = $5;
3194 } else {
3195 $res{'name'} = unquote($5);
3196 }
3197 } else {
3198 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
3199 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
3201 $res{'mode'} = $1;
3202 $res{'type'} = $2;
3203 $res{'hash'} = $3;
3204 if ($opts{'-z'}) {
3205 $res{'name'} = $4;
3206 } else {
3207 $res{'name'} = unquote($4);
3208 }
3209 }
3211 return wantarray ? %res : \%res;
3212 }
3214 # generates _two_ hashes, references to which are passed as 2 and 3 argument
3215 sub parse_from_to_diffinfo {
3216 my ($diffinfo, $from, $to, @parents) = @_;
3218 if ($diffinfo->{'nparents'}) {
3219 # combined diff
3220 $from->{'file'} = [];
3221 $from->{'href'} = [];
3222 fill_from_file_info($diffinfo, @parents)
3223 unless exists $diffinfo->{'from_file'};
3224 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
3225 $from->{'file'}[$i] =
3226 defined $diffinfo->{'from_file'}[$i] ?
3227 $diffinfo->{'from_file'}[$i] :
3228 $diffinfo->{'to_file'};
3229 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3230 $from->{'href'}[$i] = href(action=>"blob",
3231 hash_base=>$parents[$i],
3232 hash=>$diffinfo->{'from_id'}[$i],
3233 file_name=>$from->{'file'}[$i]);
3234 } else {
3235 $from->{'href'}[$i] = undef;
3236 }
3237 }
3238 } else {
3239 # ordinary (not combined) diff
3240 $from->{'file'} = $diffinfo->{'from_file'};
3241 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3242 $from->{'href'} = href(action=>"blob", hash_base=>$hash_parent,
3243 hash=>$diffinfo->{'from_id'},
3244 file_name=>$from->{'file'});
3245 } else {
3246 delete $from->{'href'};
3247 }
3248 }
3250 $to->{'file'} = $diffinfo->{'to_file'};
3251 if (!is_deleted($diffinfo)) { # file exists in result
3252 $to->{'href'} = href(action=>"blob", hash_base=>$hash,
3253 hash=>$diffinfo->{'to_id'},
3254 file_name=>$to->{'file'});
3255 } else {
3256 delete $to->{'href'};
3257 }
3258 }
3260 ## ......................................................................
3261 ## parse to array of hashes functions
3263 sub git_get_heads_list {
3264 my ($limit, @classes) = @_;
3265 @classes = ('heads') unless @classes;
3266 my @patterns = map { "refs/$_" } @classes;
3267 my @headslist;
3269 open my $fd, '-|', git_cmd(), 'for-each-ref',
3270 ($limit ? '--count='.($limit+1) : ()), '--sort=-committerdate',
3271 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
3272 @patterns
3273 or return;
3274 while (my $line = <$fd>) {
3275 my %ref_item;
3277 chomp $line;
3278 my ($refinfo, $committerinfo) = split(/\0/, $line);
3279 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3280 my ($committer, $epoch, $tz) =
3281 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
3282 $ref_item{'fullname'} = $name;
3283 $name =~ s!^refs/(?:head|remote)s/!!;
3285 $ref_item{'name'} = $name;
3286 $ref_item{'id'} = $hash;
3287 $ref_item{'title'} = $title || '(no commit message)';
3288 $ref_item{'epoch'} = $epoch;
3289 if ($epoch) {
3290 $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
3291 } else {
3292 $ref_item{'age'} = "unknown";
3293 }
3295 push @headslist, \%ref_item;
3296 }
3297 close $fd;
3299 return wantarray ? @headslist : \@headslist;
3300 }
3302 sub git_get_tags_list {
3303 my $limit = shift;
3304 my @tagslist;
3306 open my $fd, '-|', git_cmd(), 'for-each-ref',
3307 ($limit ? '--count='.($limit+1) : ()), '--sort=-creatordate',
3308 '--format=%(objectname) %(objecttype) %(refname) '.
3309 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3310 'refs/tags'
3311 or return;
3312 while (my $line = <$fd>) {
3313 my %ref_item;
3315 chomp $line;
3316 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3317 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3318 my ($creator, $epoch, $tz) =
3319 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
3320 $ref_item{'fullname'} = $name;
3321 $name =~ s!^refs/tags/!!;
3323 $ref_item{'type'} = $type;
3324 $ref_item{'id'} = $id;
3325 $ref_item{'name'} = $name;
3326 if ($type eq "tag") {
3327 $ref_item{'subject'} = $title;
3328 $ref_item{'reftype'} = $reftype;
3329 $ref_item{'refid'} = $refid;
3330 } else {
3331 $ref_item{'reftype'} = $type;
3332 $ref_item{'refid'} = $id;
3333 }
3335 if ($type eq "tag" || $type eq "commit") {
3336 $ref_item{'epoch'} = $epoch;
3337 if ($epoch) {
3338 $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
3339 } else {
3340 $ref_item{'age'} = "unknown";
3341 }
3342 }
3344 push @tagslist, \%ref_item;
3345 }
3346 close $fd;
3348 return wantarray ? @tagslist : \@tagslist;
3349 }
3351 ## ----------------------------------------------------------------------
3352 ## filesystem-related functions
3354 sub get_file_owner {
3355 my $path = shift;
3357 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3358 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3359 if (!defined $gcos) {
3360 return undef;
3361 }
3362 my $owner = $gcos;
3363 $owner =~ s/[,;].*$//;
3364 return to_utf8($owner);
3365 }
3367 # assume that file exists
3368 sub insert_file {
3369 my $filename = shift;
3371 open my $fd, '<', $filename;
3372 print map { to_utf8($_) } <$fd>;
3373 close $fd;
3374 }
3376 ## ......................................................................
3377 ## mimetype related functions
3379 sub mimetype_guess_file {
3380 my $filename = shift;
3381 my $mimemap = shift;
3382 -r $mimemap or return undef;
3384 my %mimemap;
3385 open(my $mh, '<', $mimemap) or return undef;
3386 while (<$mh>) {
3387 next if m/^#/; # skip comments
3388 my ($mimetype, $exts) = split(/\t+/);
3389 if (defined $exts) {
3390 my @exts = split(/\s+/, $exts);
3391 foreach my $ext (@exts) {
3392 $mimemap{$ext} = $mimetype;
3393 }
3394 }
3395 }
3396 close($mh);
3398 $filename =~ /\.([^.]*)$/;
3399 return $mimemap{$1};
3400 }
3402 sub mimetype_guess {
3403 my $filename = shift;
3404 my $mime;
3405 $filename =~ /\./ or return undef;
3407 if ($mimetypes_file) {
3408 my $file = $mimetypes_file;
3409 if ($file !~ m!^/!) { # if it is relative path
3410 # it is relative to project
3411 $file = "$projectroot/$project/$file";
3412 }
3413 $mime = mimetype_guess_file($filename, $file);
3414 }
3415 $mime ||= mimetype_guess_file($filename, '/etc/mime.types');
3416 return $mime;
3417 }
3419 sub blob_mimetype {
3420 my $fd = shift;
3421 my $filename = shift;
3423 if ($filename) {
3424 my $mime = mimetype_guess($filename);
3425 $mime and return $mime;
3426 }
3428 # just in case
3429 return $default_blob_plain_mimetype unless $fd;
3431 if (-T $fd) {
3432 return 'text/plain';
3433 } elsif (! $filename) {
3434 return 'application/octet-stream';
3435 } elsif ($filename =~ m/\.png$/i) {
3436 return 'image/png';
3437 } elsif ($filename =~ m/\.gif$/i) {
3438 return 'image/gif';
3439 } elsif ($filename =~ m/\.jpe?g$/i) {
3440 return 'image/jpeg';
3441 } else {
3442 return 'application/octet-stream';
3443 }
3444 }
3446 sub blob_contenttype {
3447 my ($fd, $file_name, $type) = @_;
3449 $type ||= blob_mimetype($fd, $file_name);
3450 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3451 $type .= "; charset=$default_text_plain_charset";
3452 }
3454 return $type;
3455 }
3457 # guess file syntax for syntax highlighting; return undef if no highlighting
3458 # the name of syntax can (in the future) depend on syntax highlighter used
3459 sub guess_file_syntax {
3460 my ($highlight, $mimetype, $file_name) = @_;
3461 return undef unless ($highlight && defined $file_name);
3462 my $basename = basename($file_name, '.in');
3463 return $highlight_basename{$basename}
3464 if exists $highlight_basename{$basename};
3466 $basename =~ /\.([^.]*)$/;
3467 my $ext = $1 or return undef;
3468 return $highlight_ext{$ext}
3469 if exists $highlight_ext{$ext};
3471 return undef;
3472 }
3474 # run highlighter and return FD of its output,
3475 # or return original FD if no highlighting
3476 sub run_highlighter {
3477 my ($fd, $highlight, $syntax) = @_;
3478 return $fd unless ($highlight && defined $syntax);
3480 close $fd;
3481 open $fd, quote_command(git_cmd(), "cat-file", "blob", $hash)." | ".
3482 quote_command($highlight_bin).
3483 " --replace-tabs=8 --fragment --syntax $syntax |"
3484 or die_error(500, "Couldn't open file or run syntax highlighter");
3485 return $fd;
3486 }
3488 ## ======================================================================
3489 ## functions printing HTML: header, footer, error page
3491 sub get_page_title {
3492 my $title = to_utf8($site_name);
3494 return $title unless (defined $project);
3495 $title .= " - " . to_utf8($project);
3497 return $title unless (defined $action);
3498 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
3500 return $title unless (defined $file_name);
3501 $title .= " - " . esc_path($file_name);
3502 if ($action eq "tree" && $file_name !~ m|/$|) {
3503 $title .= "/";
3504 }
3506 return $title;
3507 }
3509 sub print_feed_meta {
3510 if (defined $project) {
3511 my %href_params = get_feed_info();
3512 if (!exists $href_params{'-title'}) {
3513 $href_params{'-title'} = 'log';
3514 }
3516 foreach my $format (qw(RSS Atom)) {
3517 my $type = lc($format);
3518 my %link_attr = (
3519 '-rel' => 'alternate',
3520 '-title' => esc_attr("$project - $href_params{'-title'} - $format feed"),
3521 '-type' => "application/$type+xml"
3522 );
3524 $href_params{'action'} = $type;
3525 $link_attr{'-href'} = href(%href_params);
3526 print "<link ".
3527 "rel=\"$link_attr{'-rel'}\" ".
3528 "title=\"$link_attr{'-title'}\" ".
3529 "href=\"$link_attr{'-href'}\" ".
3530 "type=\"$link_attr{'-type'}\" ".
3531 "/>\n";
3533 $href_params{'extra_options'} = '--no-merges';
3534 $link_attr{'-href'} = href(%href_params);
3535 $link_attr{'-title'} .= ' (no merges)';
3536 print "<link ".
3537 "rel=\"$link_attr{'-rel'}\" ".
3538 "title=\"$link_attr{'-title'}\" ".
3539 "href=\"$link_attr{'-href'}\" ".
3540 "type=\"$link_attr{'-type'}\" ".
3541 "/>\n";
3542 }
3544 } else {
3545 printf('<link rel="alternate" title="%s projects list" '.
3546 'href="%s" type="text/plain; charset=utf-8" />'."\n",
3547 esc_attr($site_name), href(project=>undef, action=>"project_index"));
3548 printf('<link rel="alternate" title="%s projects feeds" '.
3549 'href="%s" type="text/x-opml" />'."\n",
3550 esc_attr($site_name), href(project=>undef, action=>"opml"));
3551 }
3552 }
3554 sub git_header_html {
3555 my $status = shift || "200 OK";
3556 my $expires = shift;
3557 my %opts = @_;
3559 my $title = get_page_title();
3560 my $content_type;
3561 # require explicit support from the UA if we are to send the page as
3562 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
3563 # we have to do this because MSIE sometimes globs '*/*', pretending to
3564 # support xhtml+xml but choking when it gets what it asked for.
3565 if (defined $cgi->http('HTTP_ACCEPT') &&
3566 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\+xml(,|;|\s|$)/ &&
3567 $cgi->Accept('application/xhtml+xml') != 0) {
3568 $content_type = 'application/xhtml+xml';
3569 } else {
3570 $content_type = 'text/html';
3571 }
3572 print $cgi->header(-type=>$content_type, -charset => 'utf-8',
3573 -status=> $status, -expires => $expires)
3574 unless ($opts{'-no_http_header'});
3575 my $mod_perl_version = $ENV{'MOD_PERL'} ? " $ENV{'MOD_PERL'}" : '';
3576 print <<EOF;
3577 <?xml version="1.0" encoding="utf-8"?>
3578 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3579 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
3580 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
3581 <!-- git core binaries version $git_version -->
3582 <head>
3583 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
3584 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
3585 <meta name="robots" content="index, nofollow"/>
3586 <title>$title</title>
3587 EOF
3588 # the stylesheet, favicon etc urls won't work correctly with path_info
3589 # unless we set the appropriate base URL
3590 if ($ENV{'PATH_INFO'}) {
3591 print "<base href=\"".esc_url($base_url)."\" />\n";
3592 }
3593 # print out each stylesheet that exist, providing backwards capability
3594 # for those people who defined $stylesheet in a config file
3595 if (defined $stylesheet) {
3596 print '<link rel="stylesheet" type="text/css" href="'.esc_url($stylesheet).'"/>'."\n";
3597 } else {
3598 foreach my $stylesheet (@stylesheets) {
3599 next unless $stylesheet;
3600 print '<link rel="stylesheet" type="text/css" href="'.esc_url($stylesheet).'"/>'."\n";
3601 }
3602 }
3603 print_feed_meta()
3604 if ($status eq '200 OK');
3605 if (defined $favicon) {
3606 print qq(<link rel="shortcut icon" href=").esc_url($favicon).qq(" type="image/png" />\n);
3607 }
3609 print "</head>\n" .
3610 "<body>\n";
3612 if (defined $site_header && -f $site_header) {
3613 insert_file($site_header);
3614 }
3616 print "<div class=\"page_header\">\n";
3617 if (defined $logo) {
3618 print $cgi->a({-href => esc_url($logo_url),
3619 -title => $logo_label},
3620 $cgi->img({-src => esc_url($logo),
3621 -width => 72, -height => 27,
3622 -alt => "git",
3623 -class => "logo"}));
3624 }
3625 print $cgi->a({-href => esc_url($home_link)}, $home_link_str) . " / ";
3626 if (defined $project) {
3627 print $cgi->a({-href => href(action=>"summary")}, esc_html($project));
3628 if (defined $action) {
3629 my $action_print = $action ;
3630 if (defined $opts{-action_extra}) {
3631 $action_print = $cgi->a({-href => href(action=>$action)},
3632 $action);
3633 }
3634 print " / $action_print";
3635 }
3636 if (defined $opts{-action_extra}) {
3637 print " / $opts{-action_extra}";
3638 }
3639 print "\n";
3640 }
3641 print "</div>\n";
3643 my $have_search = gitweb_check_feature('search');
3644 if (defined $project && $have_search) {
3645 if (!defined $searchtext) {
3646 $searchtext = "";
3647 }
3648 my $search_hash;
3649 if (defined $hash_base) {
3650 $search_hash = $hash_base;
3651 } elsif (defined $hash) {
3652 $search_hash = $hash;
3653 } else {
3654 $search_hash = "HEAD";
3655 }
3656 my $action = $my_uri;
3657 my $use_pathinfo = gitweb_check_feature('pathinfo');
3658 if ($use_pathinfo) {
3659 $action .= "/".esc_url($project);
3660 }
3661 print $cgi->startform(-method => "get", -action => $action) .
3662 "<div class=\"search\">\n" .
3663 (!$use_pathinfo &&
3664 $cgi->input({-name=>"p", -value=>$project, -type=>"hidden"}) . "\n") .
3665 $cgi->input({-name=>"a", -value=>"search", -type=>"hidden"}) . "\n" .
3666 $cgi->input({-name=>"h", -value=>$search_hash, -type=>"hidden"}) . "\n" .
3667 $cgi->popup_menu(-name => 'st', -default => 'commit',
3668 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3669 $cgi->sup($cgi->a({-href => href(action=>"search_help")}, "?")) .
3670 " search:\n",
3671 $cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
3672 "<span title=\"Extended regular expression\">" .
3673 $cgi->checkbox(-name => 'sr', -value => 1, -label => 're',
3674 -checked => $search_use_regexp) .
3675 "</span>" .
3676 "</div>" .
3677 $cgi->end_form() . "\n";
3678 }
3679 }
3681 sub git_footer_html {
3682 my $feed_class = 'rss_logo';
3684 print "<div class=\"page_footer\">\n";
3685 if (defined $project) {
3686 my $descr = git_get_project_description($project);
3687 if (defined $descr) {
3688 print "<div class=\"page_footer_text\">" . esc_html($descr) . "</div>\n";
3689 }
3691 my %href_params = get_feed_info();
3692 if (!%href_params) {
3693 $feed_class .= ' generic';
3694 }
3695 $href_params{'-title'} ||= 'log';
3697 foreach my $format (qw(RSS Atom)) {
3698 $href_params{'action'} = lc($format);
3699 print $cgi->a({-href => href(%href_params),
3700 -title => "$href_params{'-title'} $format feed",
3701 -class => $feed_class}, $format)."\n";
3702 }
3704 } else {
3705 print $cgi->a({-href => href(project=>undef, action=>"opml"),
3706 -class => $feed_class}, "OPML") . " ";
3707 print $cgi->a({-href => href(project=>undef, action=>"project_index"),
3708 -class => $feed_class}, "TXT") . "\n";
3709 }
3710 print "</div>\n"; # class="page_footer"
3712 if (defined $t0 && gitweb_check_feature('timed')) {
3713 print "<div id=\"generating_info\">\n";
3714 print 'This page took '.
3715 '<span id="generating_time" class="time_span">'.
3716 tv_interval($t0, [ gettimeofday() ]).
3717 ' seconds </span>'.
3718 ' and '.
3719 '<span id="generating_cmd">'.
3720 $number_of_git_cmds.
3721 '</span> git commands '.
3722 " to generate.\n";
3723 print "</div>\n"; # class="page_footer"
3724 }
3726 if (defined $site_footer && -f $site_footer) {
3727 insert_file($site_footer);
3728 }
3730 print qq!<script type="text/javascript" src="!.esc_url($javascript).qq!"></script>\n!;
3731 if (defined $action &&
3732 $action eq 'blame_incremental') {
3733 print qq!<script type="text/javascript">\n!.
3734 qq!startBlame("!. href(action=>"blame_data", -replay=>1) .qq!",\n!.
3735 qq! "!. href() .qq!");\n!.
3736 qq!</script>\n!;
3737 } elsif (gitweb_check_feature('javascript-actions')) {
3738 print qq!<script type="text/javascript">\n!.
3739 qq!window.onload = fixLinks;\n!.
3740 qq!</script>\n!;
3741 }
3743 print "</body>\n" .
3744 "</html>";
3745 }
3747 # die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
3748 # Example: die_error(404, 'Hash not found')
3749 # By convention, use the following status codes (as defined in RFC 2616):
3750 # 400: Invalid or missing CGI parameters, or
3751 # requested object exists but has wrong type.
3752 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
3753 # this server or project.
3754 # 404: Requested object/revision/project doesn't exist.
3755 # 500: The server isn't configured properly, or
3756 # an internal error occurred (e.g. failed assertions caused by bugs), or
3757 # an unknown error occurred (e.g. the git binary died unexpectedly).
3758 # 503: The server is currently unavailable (because it is overloaded,
3759 # or down for maintenance). Generally, this is a temporary state.
3760 sub die_error {
3761 my $status = shift || 500;
3762 my $error = esc_html(shift) || "Internal Server Error";
3763 my $extra = shift;
3764 my %opts = @_;
3766 my %http_responses = (
3767 400 => '400 Bad Request',
3768 403 => '403 Forbidden',
3769 404 => '404 Not Found',
3770 500 => '500 Internal Server Error',
3771 503 => '503 Service Unavailable',
3772 );
3773 git_header_html($http_responses{$status}, undef, %opts);
3774 print <<EOF;
3775 <div class="page_body">
3776 <br /><br />
3777 $status - $error
3778 <br />
3779 EOF
3780 if (defined $extra) {
3781 print "<hr />\n" .
3782 "$extra\n";
3783 }
3784 print "</div>\n";
3786 git_footer_html();
3787 goto DONE_GITWEB
3788 unless ($opts{'-error_handler'});
3789 }
3791 ## ----------------------------------------------------------------------
3792 ## functions printing or outputting HTML: navigation
3794 sub git_print_page_nav {
3795 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3796 $extra = '' if !defined $extra; # pager or formats
3798 my @navs = qw(summary shortlog log commit commitdiff tree);
3799 if ($suppress) {
3800 @navs = grep { $_ ne $suppress } @navs;
3801 }
3803 my %arg = map { $_ => {action=>$_} } @navs;
3804 if (defined $head) {
3805 for (qw(commit commitdiff)) {
3806 $arg{$_}{'hash'} = $head;
3807 }
3808 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3809 for (qw(shortlog log)) {
3810 $arg{$_}{'hash'} = $head;
3811 }
3812 }
3813 }
3815 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3816 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3818 my @actions = gitweb_get_feature('actions');
3819 my %repl = (
3820 '%' => '%',
3821 'n' => $project, # project name
3822 'f' => $git_dir, # project path within filesystem
3823 'h' => $treehead || '', # current hash ('h' parameter)
3824 'b' => $treebase || '', # hash base ('hb' parameter)
3825 );
3826 while (@actions) {
3827 my ($label, $link, $pos) = splice(@actions,0,3);
3828 # insert
3829 @navs = map { $_ eq $pos ? ($_, $label) : $_ } @navs;
3830 # munch munch
3831 $link =~ s/%([%nfhb])/$repl{$1}/g;
3832 $arg{$label}{'_href'} = $link;
3833 }
3835 print "<div class=\"page_nav\">\n" .
3836 (join " | ",
3837 map { $_ eq $current ?
3838 $_ : $cgi->a({-href => ($arg{$_}{_href} ? $arg{$_}{_href} : href(%{$arg{$_}}))}, "$_")
3839 } @navs);
3840 print "<br/>\n$extra<br/>\n" .
3841 "</div>\n";
3842 }
3844 # returns a submenu for the nagivation of the refs views (tags, heads,
3845 # remotes) with the current view disabled and the remotes view only
3846 # available if the feature is enabled
3847 sub format_ref_views {
3848 my ($current) = @_;
3849 my @ref_views = qw{tags heads};
3850 push @ref_views, 'remotes' if gitweb_check_feature('remote_heads');
3851 return join " | ", map {
3852 $_ eq $current ? $_ :
3853 $cgi->a({-href => href(action=>$_)}, $_)
3854 } @ref_views
3855 }
3857 sub format_paging_nav {
3858 my ($action, $page, $has_next_link) = @_;
3859 my $paging_nav;
3862 if ($page > 0) {
3863 $paging_nav .=
3864 $cgi->a({-href => href(-replay=>1, page=>undef)}, "first") .
3865 " ⋅ " .
3866 $cgi->a({-href => href(-replay=>1, page=>$page-1),
3867 -accesskey => "p", -title => "Alt-p"}, "prev");
3868 } else {
3869 $paging_nav .= "first ⋅ prev";
3870 }
3872 if ($has_next_link) {
3873 $paging_nav .= " ⋅ " .
3874 $cgi->a({-href => href(-replay=>1, page=>$page+1),
3875 -accesskey => "n", -title => "Alt-n"}, "next");
3876 } else {
3877 $paging_nav .= " ⋅ next";
3878 }
3880 return $paging_nav;
3881 }
3883 ## ......................................................................
3884 ## functions printing or outputting HTML: div
3886 sub git_print_header_div {
3887 my ($action, $title, $hash, $hash_base) = @_;
3888 my %args = ();
3890 $args{'action'} = $action;
3891 $args{'hash'} = $hash if $hash;
3892 $args{'hash_base'} = $hash_base if $hash_base;
3894 print "<div class=\"header\">\n" .
3895 $cgi->a({-href => href(%args), -class => "title"},
3896 $title ? $title : $action) .
3897 "\n</div>\n";
3898 }
3900 sub format_repo_url {
3901 my ($name, $url) = @_;
3902 return "<tr class=\"metadata_url\"><td>$name</td><td>$url</td></tr>\n";
3903 }
3905 # Group output by placing it in a DIV element and adding a header.
3906 # Options for start_div() can be provided by passing a hash reference as the
3907 # first parameter to the function.
3908 # Options to git_print_header_div() can be provided by passing an array
3909 # reference. This must follow the options to start_div if they are present.
3910 # The content can be a scalar, which is output as-is, a scalar reference, which
3911 # is output after html escaping, an IO handle passed either as *handle or
3912 # *handle{IO}, or a function reference. In the latter case all following
3913 # parameters will be taken as argument to the content function call.
3914 sub git_print_section {
3915 my ($div_args, $header_args, $content);
3916 my $arg = shift;
3917 if (ref($arg) eq 'HASH') {
3918 $div_args = $arg;
3919 $arg = shift;
3920 }
3921 if (ref($arg) eq 'ARRAY') {
3922 $header_args = $arg;
3923 $arg = shift;
3924 }
3925 $content = $arg;
3927 print $cgi->start_div($div_args);
3928 git_print_header_div(@$header_args);
3930 if (ref($content) eq 'CODE') {
3931 $content->(@_);
3932 } elsif (ref($content) eq 'SCALAR') {
3933 print esc_html($$content);
3934 } elsif (ref($content) eq 'GLOB' or ref($content) eq 'IO::Handle') {
3935 print <$content>;
3936 } elsif (!ref($content) && defined($content)) {
3937 print $content;
3938 }
3940 print $cgi->end_div;
3941 }
3943 sub print_local_time {
3944 print format_local_time(@_);
3945 }
3947 sub format_local_time {
3948 my $localtime = '';
3949 my %date = @_;
3950 if ($date{'hour_local'} < 6) {
3951 $localtime .= sprintf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3952 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3953 } else {
3954 $localtime .= sprintf(" (%02d:%02d %s)",
3955 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3956 }
3958 return $localtime;
3959 }
3961 # Outputs the author name and date in long form
3962 sub git_print_authorship {
3963 my $co = shift;
3964 my %opts = @_;
3965 my $tag = $opts{-tag} || 'div';
3966 my $author = $co->{'author_name'};
3968 my %ad = parse_date($co->{'author_epoch'}, $co->{'author_tz'});
3969 print "<$tag class=\"author_date\">" .
3970 format_search_author($author, "author", esc_html($author)) .
3971 " [$ad{'rfc2822'}";
3972 print_local_time(%ad) if ($opts{-localtime});
3973 print "]" . git_get_avatar($co->{'author_email'}, -pad_before => 1)
3974 . "</$tag>\n";
3975 }
3977 # Outputs table rows containing the full author or committer information,
3978 # in the format expected for 'commit' view (& similar).
3979 # Parameters are a commit hash reference, followed by the list of people
3980 # to output information for. If the list is empty it defaults to both
3981 # author and committer.
3982 sub git_print_authorship_rows {
3983 my $co = shift;
3984 # too bad we can't use @people = @_ || ('author', 'committer')
3985 my @people = @_;
3986 @people = ('author', 'committer') unless @people;
3987 foreach my $who (@people) {
3988 my %wd = parse_date($co->{"${who}_epoch"}, $co->{"${who}_tz"});
3989 print "<tr><td>$who</td><td>" .
3990 format_search_author($co->{"${who}_name"}, $who,
3991 esc_html($co->{"${who}_name"})) . " " .
3992 format_search_author($co->{"${who}_email"}, $who,
3993 esc_html("<" . $co->{"${who}_email"} . ">")) .
3994 "</td><td rowspan=\"2\">" .
3995 git_get_avatar($co->{"${who}_email"}, -size => 'double') .
3996 "</td></tr>\n" .
3997 "<tr>" .
3998 "<td></td><td> $wd{'rfc2822'}";
3999 print_local_time(%wd);
4000 print "</td>" .
4001 "</tr>\n";
4002 }
4003 }
4005 sub git_print_page_path {
4006 my $name = shift;
4007 my $type = shift;
4008 my $hb = shift;
4011 print "<div class=\"page_path\">";
4012 print $cgi->a({-href => href(action=>"tree", hash_base=>$hb),
4013 -title => 'tree root'}, to_utf8("[$project]"));
4014 print " / ";
4015 if (defined $name) {
4016 my @dirname = split '/', $name;
4017 my $basename = pop @dirname;
4018 my $fullname = '';
4020 foreach my $dir (@dirname) {
4021 $fullname .= ($fullname ? '/' : '') . $dir;
4022 print $cgi->a({-href => href(action=>"tree", file_name=>$fullname,
4023 hash_base=>$hb),
4024 -title => $fullname}, esc_path($dir));
4025 print " / ";
4026 }
4027 if (defined $type && $type eq 'blob') {
4028 print $cgi->a({-href => href(action=>"blob_plain", file_name=>$file_name,
4029 hash_base=>$hb),
4030 -title => $name}, esc_path($basename));
4031 } elsif (defined $type && $type eq 'tree') {
4032 print $cgi->a({-href => href(action=>"tree", file_name=>$file_name,
4033 hash_base=>$hb),
4034 -title => $name}, esc_path($basename));
4035 print " / ";
4036 } else {
4037 print esc_path($basename);
4038 }
4039 }
4040 print "<br/></div>\n";
4041 }
4043 sub git_print_log {
4044 my $log = shift;
4045 my %opts = @_;
4047 if ($opts{'-remove_title'}) {
4048 # remove title, i.e. first line of log
4049 shift @$log;
4050 }
4051 # remove leading empty lines
4052 while (defined $log->[0] && $log->[0] eq "") {
4053 shift @$log;
4054 }
4056 # print log
4057 my $signoff = 0;
4058 my $empty = 0;
4059 foreach my $line (@$log) {
4060 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
4061 $signoff = 1;
4062 $empty = 0;
4063 if (! $opts{'-remove_signoff'}) {
4064 print "<span class=\"signoff\">" . esc_html($line) . "</span><br/>\n";
4065 next;
4066 } else {
4067 # remove signoff lines
4068 next;
4069 }
4070 } else {
4071 $signoff = 0;
4072 }
4074 # print only one empty line
4075 # do not print empty line after signoff
4076 if ($line eq "") {
4077 next if ($empty || $signoff);
4078 $empty = 1;
4079 } else {
4080 $empty = 0;
4081 }
4083 print format_log_line_html($line) . "<br/>\n";
4084 }
4086 if ($opts{'-final_empty_line'}) {
4087 # end with single empty line
4088 print "<br/>\n" unless $empty;
4089 }
4090 }
4092 # return link target (what link points to)
4093 sub git_get_link_target {
4094 my $hash = shift;
4095 my $link_target;
4097 # read link
4098 open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4099 or return;
4100 {
4101 local $/ = undef;
4102 $link_target = <$fd>;
4103 }
4104 close $fd
4105 or return;
4107 return $link_target;
4108 }
4110 # given link target, and the directory (basedir) the link is in,
4111 # return target of link relative to top directory (top tree);
4112 # return undef if it is not possible (including absolute links).
4113 sub normalize_link_target {
4114 my ($link_target, $basedir) = @_;
4116 # absolute symlinks (beginning with '/') cannot be normalized
4117 return if (substr($link_target, 0, 1) eq '/');
4119 # normalize link target to path from top (root) tree (dir)
4120 my $path;
4121 if ($basedir) {
4122 $path = $basedir . '/' . $link_target;
4123 } else {
4124 # we are in top (root) tree (dir)
4125 $path = $link_target;
4126 }
4128 # remove //, /./, and /../
4129 my @path_parts;
4130 foreach my $part (split('/', $path)) {
4131 # discard '.' and ''
4132 next if (!$part || $part eq '.');
4133 # handle '..'
4134 if ($part eq '..') {
4135 if (@path_parts) {
4136 pop @path_parts;
4137 } else {
4138 # link leads outside repository (outside top dir)
4139 return;
4140 }
4141 } else {
4142 push @path_parts, $part;
4143 }
4144 }
4145 $path = join('/', @path_parts);
4147 return $path;
4148 }
4150 # print tree entry (row of git_tree), but without encompassing <tr> element
4151 sub git_print_tree_entry {
4152 my ($t, $basedir, $hash_base, $have_blame) = @_;
4154 my %base_key = ();
4155 $base_key{'hash_base'} = $hash_base if defined $hash_base;
4157 # The format of a table row is: mode list link. Where mode is
4158 # the mode of the entry, list is the name of the entry, an href,
4159 # and link is the action links of the entry.
4161 print "<td class=\"mode\">" . mode_str($t->{'mode'}) . "</td>\n";
4162 if (exists $t->{'size'}) {
4163 print "<td class=\"size\">$t->{'size'}</td>\n";
4164 }
4165 if ($t->{'type'} eq "blob") {
4166 print "<td class=\"list\">" .
4167 $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
4168 file_name=>"$basedir$t->{'name'}", %base_key),
4169 -class => "list"}, esc_path($t->{'name'}));
4170 if (S_ISLNK(oct $t->{'mode'})) {
4171 my $link_target = git_get_link_target($t->{'hash'});
4172 if ($link_target) {
4173 my $norm_target = normalize_link_target($link_target, $basedir);
4174 if (defined $norm_target) {
4175 print " -> " .
4176 $cgi->a({-href => href(action=>"object", hash_base=>$hash_base,
4177 file_name=>$norm_target),
4178 -title => $norm_target}, esc_path($link_target));
4179 } else {
4180 print " -> " . esc_path($link_target);
4181 }
4182 }
4183 }
4184 print "</td>\n";
4185 print "<td class=\"link\">";
4186 print $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
4187 file_name=>"$basedir$t->{'name'}", %base_key)},
4188 "blob");
4189 if ($have_blame) {
4190 print " | " .
4191 $cgi->a({-href => href(action=>"blame", hash=>$t->{'hash'},
4192 file_name=>"$basedir$t->{'name'}", %base_key)},
4193 "blame");
4194 }
4195 if (defined $hash_base) {
4196 print " | " .
4197 $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
4198 hash=>$t->{'hash'}, file_name=>"$basedir$t->{'name'}")},
4199 "history");
4200 }
4201 print " | " .
4202 $cgi->a({-href => href(action=>"blob_plain", hash_base=>$hash_base,
4203 file_name=>"$basedir$t->{'name'}")},
4204 "raw");
4205 print "</td>\n";
4207 } elsif ($t->{'type'} eq "tree") {
4208 print "<td class=\"list\">";
4209 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
4210 file_name=>"$basedir$t->{'name'}",
4211 %base_key)},
4212 esc_path($t->{'name'}));
4213 print "</td>\n";
4214 print "<td class=\"link\">";
4215 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
4216 file_name=>"$basedir$t->{'name'}",
4217 %base_key)},
4218 "tree");
4219 if (defined $hash_base) {
4220 print " | " .
4221 $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
4222 file_name=>"$basedir$t->{'name'}")},
4223 "history");
4224 }
4225 print "</td>\n";
4226 } else {
4227 # unknown object: we can only present history for it
4228 # (this includes 'commit' object, i.e. submodule support)
4229 print "<td class=\"list\">" .
4230 esc_path($t->{'name'}) .
4231 "</td>\n";
4232 print "<td class=\"link\">";
4233 if (defined $hash_base) {
4234 print $cgi->a({-href => href(action=>"history",
4235 hash_base=>$hash_base,
4236 file_name=>"$basedir$t->{'name'}")},
4237 "history");
4238 }
4239 print "</td>\n";
4240 }
4241 }
4243 ## ......................................................................
4244 ## functions printing large fragments of HTML
4246 # get pre-image filenames for merge (combined) diff
4247 sub fill_from_file_info {
4248 my ($diff, @parents) = @_;
4250 $diff->{'from_file'} = [ ];
4251 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4252 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4253 if ($diff->{'status'}[$i] eq 'R' ||
4254 $diff->{'status'}[$i] eq 'C') {
4255 $diff->{'from_file'}[$i] =
4256 git_get_path_by_hash($parents[$i], $diff->{'from_id'}[$i]);
4257 }
4258 }
4260 return $diff;
4261 }
4263 # is current raw difftree line of file deletion
4264 sub is_deleted {
4265 my $diffinfo = shift;
4267 return $diffinfo->{'to_id'} eq ('0' x 40);
4268 }
4270 # does patch correspond to [previous] difftree raw line
4271 # $diffinfo - hashref of parsed raw diff format
4272 # $patchinfo - hashref of parsed patch diff format
4273 # (the same keys as in $diffinfo)
4274 sub is_patch_split {
4275 my ($diffinfo, $patchinfo) = @_;
4277 return defined $diffinfo && defined $patchinfo
4278 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
4279 }
4282 sub git_difftree_body {
4283 my ($difftree, $hash, @parents) = @_;
4284 my ($parent) = $parents[0];
4285 my $have_blame = gitweb_check_feature('blame');
4286 print "<div class=\"list_head\">\n";
4287 if ($#{$difftree} > 10) {
4288 print(($#{$difftree} + 1) . " files changed:\n");
4289 }
4290 print "</div>\n";
4292 print "<table class=\"" .
4293 (@parents > 1 ? "combined " : "") .
4294 "diff_tree\">\n";
4296 # header only for combined diff in 'commitdiff' view
4297 my $has_header = @$difftree && @parents > 1 && $action eq 'commitdiff';
4298 if ($has_header) {
4299 # table header
4300 print "<thead><tr>\n" .
4301 "<th></th><th></th>\n"; # filename, patchN link
4302 for (my $i = 0; $i < @parents; $i++) {
4303 my $par = $parents[$i];
4304 print "<th>" .
4305 $cgi->a({-href => href(action=>"commitdiff",
4306 hash=>$hash, hash_parent=>$par),
4307 -title => 'commitdiff to parent number ' .
4308 ($i+1) . ': ' . substr($par,0,7)},
4309 $i+1) .
4310 " </th>\n";
4311 }
4312 print "</tr></thead>\n<tbody>\n";
4313 }
4315 my $alternate = 1;
4316 my $patchno = 0;
4317 foreach my $line (@{$difftree}) {
4318 my $diff = parsed_difftree_line($line);
4320 if ($alternate) {
4321 print "<tr class=\"dark\">\n";
4322 } else {
4323 print "<tr class=\"light\">\n";
4324 }
4325 $alternate ^= 1;
4327 if (exists $diff->{'nparents'}) { # combined diff
4329 fill_from_file_info($diff, @parents)
4330 unless exists $diff->{'from_file'};
4332 if (!is_deleted($diff)) {
4333 # file exists in the result (child) commit
4334 print "<td>" .
4335 $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
4336 file_name=>$diff->{'to_file'},
4337 hash_base=>$hash),
4338 -class => "list"}, esc_path($diff->{'to_file'})) .
4339 "</td>\n";
4340 } else {
4341 print "<td>" .
4342 esc_path($diff->{'to_file'}) .
4343 "</td>\n";
4344 }
4346 if ($action eq 'commitdiff') {
4347 # link to patch
4348 $patchno++;
4349 print "<td class=\"link\">" .
4350 $cgi->a({-href => href(-anchor=>"patch$patchno")},
4351 "patch") .
4352 " | " .
4353 "</td>\n";
4354 }
4356 my $has_history = 0;
4357 my $not_deleted = 0;
4358 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4359 my $hash_parent = $parents[$i];
4360 my $from_hash = $diff->{'from_id'}[$i];
4361 my $from_path = $diff->{'from_file'}[$i];
4362 my $status = $diff->{'status'}[$i];
4364 $has_history ||= ($status ne 'A');
4365 $not_deleted ||= ($status ne 'D');
4367 if ($status eq 'A') {
4368 print "<td class=\"link\" align=\"right\"> | </td>\n";
4369 } elsif ($status eq 'D') {
4370 print "<td class=\"link\">" .
4371 $cgi->a({-href => href(action=>"blob",
4372 hash_base=>$hash,
4373 hash=>$from_hash,
4374 file_name=>$from_path)},
4375 "blob" . ($i+1)) .
4376 " | </td>\n";
4377 } else {
4378 if ($diff->{'to_id'} eq $from_hash) {
4379 print "<td class=\"link nochange\">";
4380 } else {
4381 print "<td class=\"link\">";
4382 }
4383 print $cgi->a({-href => href(action=>"blobdiff",
4384 hash=>$diff->{'to_id'},
4385 hash_parent=>$from_hash,
4386 hash_base=>$hash,
4387 hash_parent_base=>$hash_parent,
4388 file_name=>$diff->{'to_file'},
4389 file_parent=>$from_path)},
4390 "diff" . ($i+1)) .
4391 " | </td>\n";
4392 }
4393 }
4395 print "<td class=\"link\">";
4396 if ($not_deleted) {
4397 print $cgi->a({-href => href(action=>"blob",
4398 hash=>$diff->{'to_id'},
4399 file_name=>$diff->{'to_file'},
4400 hash_base=>$hash)},
4401 "blob");
4402 print " | " if ($has_history);
4403 }
4404 if ($has_history) {
4405 print $cgi->a({-href => href(action=>"history",
4406 file_name=>$diff->{'to_file'},
4407 hash_base=>$hash)},
4408 "history");
4409 }
4410 print "</td>\n";
4412 print "</tr>\n";
4413 next; # instead of 'else' clause, to avoid extra indent
4414 }
4415 # else ordinary diff
4417 my ($to_mode_oct, $to_mode_str, $to_file_type);
4418 my ($from_mode_oct, $from_mode_str, $from_file_type);
4419 if ($diff->{'to_mode'} ne ('0' x 6)) {
4420 $to_mode_oct = oct $diff->{'to_mode'};
4421 if (S_ISREG($to_mode_oct)) { # only for regular file
4422 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
4423 }
4424 $to_file_type = file_type($diff->{'to_mode'});
4425 }
4426 if ($diff->{'from_mode'} ne ('0' x 6)) {
4427 $from_mode_oct = oct $diff->{'from_mode'};
4428 if (S_ISREG($from_mode_oct)) { # only for regular file
4429 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
4430 }
4431 $from_file_type = file_type($diff->{'from_mode'});
4432 }
4434 if ($diff->{'status'} eq "A") { # created
4435 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
4436 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
4437 $mode_chng .= "]</span>";
4438 print "<td>";
4439 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
4440 hash_base=>$hash, file_name=>$diff->{'file'}),
4441 -class => "list"}, esc_path($diff->{'file'}));
4442 print "</td>\n";
4443 print "<td>$mode_chng</td>\n";
4444 print "<td class=\"link\">";
4445 if ($action eq 'commitdiff') {
4446 # link to patch
4447 $patchno++;
4448 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
4449 "patch") .
4450 " | ";
4451 }
4452 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
4453 hash_base=>$hash, file_name=>$diff->{'file'})},
4454 "blob");
4455 print "</td>\n";
4457 } elsif ($diff->{'status'} eq "D") { # deleted
4458 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
4459 print "<td>";
4460 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
4461 hash_base=>$parent, file_name=>$diff->{'file'}),
4462 -class => "list"}, esc_path($diff->{'file'}));
4463 print "</td>\n";
4464 print "<td>$mode_chng</td>\n";
4465 print "<td class=\"link\">";
4466 if ($action eq 'commitdiff') {
4467 # link to patch
4468 $patchno++;
4469 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
4470 "patch") .
4471 " | ";
4472 }
4473 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
4474 hash_base=>$parent, file_name=>$diff->{'file'})},
4475 "blob") . " | ";
4476 if ($have_blame) {
4477 print $cgi->a({-href => href(action=>"blame", hash_base=>$parent,
4478 file_name=>$diff->{'file'})},
4479 "blame") . " | ";
4480 }
4481 print $cgi->a({-href => href(action=>"history", hash_base=>$parent,
4482 file_name=>$diff->{'file'})},
4483 "history");
4484 print "</td>\n";
4486 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
4487 my $mode_chnge = "";
4488 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4489 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
4490 if ($from_file_type ne $to_file_type) {
4491 $mode_chnge .= " from $from_file_type to $to_file_type";
4492 }
4493 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
4494 if ($from_mode_str && $to_mode_str) {
4495 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
4496 } elsif ($to_mode_str) {
4497 $mode_chnge .= " mode: $to_mode_str";
4498 }
4499 }
4500 $mode_chnge .= "]</span>\n";
4501 }
4502 print "<td>";
4503 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
4504 hash_base=>$hash, file_name=>$diff->{'file'}),
4505 -class => "list"}, esc_path($diff->{'file'}));
4506 print "</td>\n";
4507 print "<td>$mode_chnge</td>\n";
4508 print "<td class=\"link\">";
4509 if ($action eq 'commitdiff') {
4510 # link to patch
4511 $patchno++;
4512 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
4513 "patch") .
4514 " | ";
4515 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4516 # "commit" view and modified file (not onlu mode changed)
4517 print $cgi->a({-href => href(action=>"blobdiff",
4518 hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
4519 hash_base=>$hash, hash_parent_base=>$parent,
4520 file_name=>$diff->{'file'})},
4521 "diff") .
4522 " | ";
4523 }
4524 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
4525 hash_base=>$hash, file_name=>$diff->{'file'})},
4526 "blob") . " | ";
4527 if ($have_blame) {
4528 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
4529 file_name=>$diff->{'file'})},
4530 "blame") . " | ";
4531 }
4532 print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
4533 file_name=>$diff->{'file'})},
4534 "history");
4535 print "</td>\n";
4537 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
4538 my %status_name = ('R' => 'moved', 'C' => 'copied');
4539 my $nstatus = $status_name{$diff->{'status'}};
4540 my $mode_chng = "";
4541 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
4542 # mode also for directories, so we cannot use $to_mode_str
4543 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
4544 }
4545 print "<td>" .
4546 $cgi->a({-href => href(action=>"blob", hash_base=>$hash,
4547 hash=>$diff->{'to_id'}, file_name=>$diff->{'to_file'}),
4548 -class => "list"}, esc_path($diff->{'to_file'})) . "</td>\n" .
4549 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
4550 $cgi->a({-href => href(action=>"blob", hash_base=>$parent,
4551 hash=>$diff->{'from_id'}, file_name=>$diff->{'from_file'}),
4552 -class => "list"}, esc_path($diff->{'from_file'})) .
4553 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
4554 "<td class=\"link\">";
4555 if ($action eq 'commitdiff') {
4556 # link to patch
4557 $patchno++;
4558 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
4559 "patch") .
4560 " | ";
4561 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
4562 # "commit" view and modified file (not only pure rename or copy)
4563 print $cgi->a({-href => href(action=>"blobdiff",
4564 hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
4565 hash_base=>$hash, hash_parent_base=>$parent,
4566 file_name=>$diff->{'to_file'}, file_parent=>$diff->{'from_file'})},
4567 "diff") .
4568 " | ";
4569 }
4570 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
4571 hash_base=>$parent, file_name=>$diff->{'to_file'})},
4572 "blob") . " | ";
4573 if ($have_blame) {
4574 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
4575 file_name=>$diff->{'to_file'})},
4576 "blame") . " | ";
4577 }
4578 print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
4579 file_name=>$diff->{'to_file'})},
4580 "history");
4581 print "</td>\n";
4583 } # we should not encounter Unmerged (U) or Unknown (X) status
4584 print "</tr>\n";
4585 }
4586 print "</tbody>" if $has_header;
4587 print "</table>\n";
4588 }
4590 sub git_patchset_body {
4591 my ($fd, $difftree, $hash, @hash_parents) = @_;
4592 my ($hash_parent) = $hash_parents[0];
4594 my $is_combined = (@hash_parents > 1);
4595 my $patch_idx = 0;
4596 my $patch_number = 0;
4597 my $patch_line;
4598 my $diffinfo;
4599 my $to_name;
4600 my (%from, %to);
4602 print "<div class=\"patchset\">\n";
4604 # skip to first patch
4605 while ($patch_line = <$fd>) {
4606 chomp $patch_line;
4608 last if ($patch_line =~ m/^diff /);
4609 }
4611 PATCH:
4612 while ($patch_line) {
4614 # parse "git diff" header line
4615 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
4616 # $1 is from_name, which we do not use
4617 $to_name = unquote($2);
4618 $to_name =~ s!^b/!!;
4619 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
4620 # $1 is 'cc' or 'combined', which we do not use
4621 $to_name = unquote($2);
4622 } else {
4623 $to_name = undef;
4624 }
4626 # check if current patch belong to current raw line
4627 # and parse raw git-diff line if needed
4628 if (is_patch_split($diffinfo, { 'to_file' => $to_name })) {
4629 # this is continuation of a split patch
4630 print "<div class=\"patch cont\">\n";
4631 } else {
4632 # advance raw git-diff output if needed
4633 $patch_idx++ if defined $diffinfo;
4635 # read and prepare patch information
4636 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
4638 # compact combined diff output can have some patches skipped
4639 # find which patch (using pathname of result) we are at now;
4640 if ($is_combined) {
4641 while ($to_name ne $diffinfo->{'to_file'}) {
4642 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4643 format_diff_cc_simplified($diffinfo, @hash_parents) .
4644 "</div>\n"; # class="patch"
4646 $patch_idx++;
4647 $patch_number++;
4649 last if $patch_idx > $#$difftree;
4650 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
4651 }
4652 }
4654 # modifies %from, %to hashes
4655 parse_from_to_diffinfo($diffinfo, \%from, \%to, @hash_parents);
4657 # this is first patch for raw difftree line with $patch_idx index
4658 # we index @$difftree array from 0, but number patches from 1
4659 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
4660 }
4662 # git diff header
4663 #assert($patch_line =~ m/^diff /) if DEBUG;
4664 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
4665 $patch_number++;
4666 # print "git diff" header
4667 print format_git_diff_header_line($patch_line, $diffinfo,
4668 \%from, \%to);
4670 # print extended diff header
4671 print "<div class=\"diff extended_header\">\n";
4672 EXTENDED_HEADER:
4673 while ($patch_line = <$fd>) {
4674 chomp $patch_line;
4676 last EXTENDED_HEADER if ($patch_line =~ m/^--- |^diff /);
4678 print format_extended_diff_header_line($patch_line, $diffinfo,
4679 \%from, \%to);
4680 }
4681 print "</div>\n"; # class="diff extended_header"
4683 # from-file/to-file diff header
4684 if (! $patch_line) {
4685 print "</div>\n"; # class="patch"
4686 last PATCH;
4687 }
4688 next PATCH if ($patch_line =~ m/^diff /);
4689 #assert($patch_line =~ m/^---/) if DEBUG;
4691 my $last_patch_line = $patch_line;
4692 $patch_line = <$fd>;
4693 chomp $patch_line;
4694 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
4696 print format_diff_from_to_header($last_patch_line, $patch_line,
4697 $diffinfo, \%from, \%to,
4698 @hash_parents);
4700 # the patch itself
4701 LINE:
4702 while ($patch_line = <$fd>) {
4703 chomp $patch_line;
4705 next PATCH if ($patch_line =~ m/^diff /);
4707 print format_diff_line($patch_line, \%from, \%to);
4708 }
4710 } continue {
4711 print "</div>\n"; # class="patch"
4712 }
4714 # for compact combined (--cc) format, with chunk and patch simplification
4715 # the patchset might be empty, but there might be unprocessed raw lines
4716 for (++$patch_idx if $patch_number > 0;
4717 $patch_idx < @$difftree;
4718 ++$patch_idx) {
4719 # read and prepare patch information
4720 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
4722 # generate anchor for "patch" links in difftree / whatchanged part
4723 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
4724 format_diff_cc_simplified($diffinfo, @hash_parents) .
4725 "</div>\n"; # class="patch"
4727 $patch_number++;
4728 }
4730 if ($patch_number == 0) {
4731 if (@hash_parents > 1) {
4732 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
4733 } else {
4734 print "<div class=\"diff nodifferences\">No differences found</div>\n";
4735 }
4736 }
4738 print "</div>\n"; # class="patchset"
4739 }
4741 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4743 # fills project list info (age, description, owner, forks) for each
4744 # project in the list, removing invalid projects from returned list
4745 # NOTE: modifies $projlist, but does not remove entries from it
4746 sub fill_project_list_info {
4747 my ($projlist, $check_forks) = @_;
4748 my @projects;
4750 my $show_ctags = gitweb_check_feature('ctags');
4751 PROJECT:
4752 foreach my $pr (@$projlist) {
4753 my (@activity) = git_get_last_activity($pr->{'path'});
4754 unless (@activity) {
4755 next PROJECT;
4756 }
4757 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
4758 if (!defined $pr->{'descr'}) {
4759 my $descr = git_get_project_description($pr->{'path'}) || "";
4760 $descr = to_utf8($descr);
4761 $pr->{'descr_long'} = $descr;
4762 $pr->{'descr'} = chop_str($descr, $projects_list_description_width, 5);
4763 }
4764 if (!defined $pr->{'owner'}) {
4765 $pr->{'owner'} = git_get_project_owner("$pr->{'path'}") || "";
4766 }
4767 if ($check_forks) {
4768 my $pname = $pr->{'path'};
4769 if (($pname =~ s/\.git$//) &&
4770 ($pname !~ /\/$/) &&
4771 (-d "$projectroot/$pname")) {
4772 $pr->{'forks'} = "-d $projectroot/$pname";
4773 } else {
4774 $pr->{'forks'} = 0;
4775 }
4776 }
4777 $show_ctags and $pr->{'ctags'} = git_get_project_ctags($pr->{'path'});
4778 push @projects, $pr;
4779 }
4781 return @projects;
4782 }
4784 # print 'sort by' <th> element, generating 'sort by $name' replay link
4785 # if that order is not selected
4786 sub print_sort_th {
4787 print format_sort_th(@_);
4788 }
4790 sub format_sort_th {
4791 my ($name, $order, $header) = @_;
4792 my $sort_th = "";
4793 $header ||= ucfirst($name);
4795 if ($order eq $name) {
4796 $sort_th .= "<th>$header</th>\n";
4797 } else {
4798 $sort_th .= "<th>" .
4799 $cgi->a({-href => href(-replay=>1, order=>$name),
4800 -class => "header"}, $header) .
4801 "</th>\n";
4802 }
4804 return $sort_th;
4805 }
4807 sub git_project_list_body {
4808 # actually uses global variable $project
4809 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
4811 my $check_forks = gitweb_check_feature('forks');
4812 my @projects = fill_project_list_info($projlist, $check_forks);
4814 $order ||= $default_projects_order;
4815 $from = 0 unless defined $from;
4816 $to = $#projects if (!defined $to || $#projects < $to);
4818 my %order_info = (
4819 project => { key => 'path', type => 'str' },
4820 descr => { key => 'descr_long', type => 'str' },
4821 owner => { key => 'owner', type => 'str' },
4822 age => { key => 'age', type => 'num' }
4823 );
4824 my $oi = $order_info{$order};
4825 if ($oi->{'type'} eq 'str') {
4826 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
4827 } else {
4828 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
4829 }
4831 my $show_ctags = gitweb_check_feature('ctags');
4832 if ($show_ctags) {
4833 my %ctags;
4834 foreach my $p (@projects) {
4835 foreach my $ct (keys %{$p->{'ctags'}}) {
4836 $ctags{$ct} += $p->{'ctags'}->{$ct};
4837 }
4838 }
4839 my $cloud = git_populate_project_tagcloud(\%ctags);
4840 print git_show_project_tagcloud($cloud, 64);
4841 }
4843 print "<table class=\"project_list\">\n";
4844 unless ($no_header) {
4845 print "<tr>\n";
4846 if ($check_forks) {
4847 print "<th></th>\n";
4848 }
4849 print_sort_th('project', $order, 'Project');
4850 print_sort_th('descr', $order, 'Description');
4851 print_sort_th('owner', $order, 'Owner');
4852 print_sort_th('age', $order, 'Last Change');
4853 print "<th></th>\n" . # for links
4854 "</tr>\n";
4855 }
4856 my $alternate = 1;
4857 my $tagfilter = $cgi->param('by_tag');
4858 for (my $i = $from; $i <= $to; $i++) {
4859 my $pr = $projects[$i];
4861 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
4862 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
4863 and not $pr->{'descr_long'} =~ /$searchtext/;
4864 # Weed out forks or non-matching entries of search
4865 if ($check_forks) {
4866 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s#\.git$#/#;
4867 $forkbase="^$forkbase" if $forkbase;
4868 next if not $searchtext and not $tagfilter and $show_ctags
4869 and $pr->{'path'} =~ m#$forkbase.*/.*#; # regexp-safe
4870 }
4872 if ($alternate) {
4873 print "<tr class=\"dark\">\n";
4874 } else {
4875 print "<tr class=\"light\">\n";
4876 }
4877 $alternate ^= 1;
4878 if ($check_forks) {
4879 print "<td>";
4880 if ($pr->{'forks'}) {
4881 print "<!-- $pr->{'forks'} -->\n";
4882 print $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "+");
4883 }
4884 print "</td>\n";
4885 }
4886 print "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
4887 -class => "list"}, esc_html($pr->{'path'})) . "</td>\n" .
4888 "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
4889 -class => "list", -title => $pr->{'descr_long'}},
4890 esc_html($pr->{'descr'})) . "</td>\n" .
4891 "<td><i>" . chop_and_escape_str($pr->{'owner'}, 15) . "</i></td>\n";
4892 print "<td class=\"". age_class($pr->{'age'}) . "\">" .
4893 (defined $pr->{'age_string'} ? $pr->{'age_string'} : "No commits") . "</td>\n" .
4894 "<td class=\"link\">" .
4895 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary")}, "summary") . " | " .
4896 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"shortlog")}, "shortlog") . " | " .
4897 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"log")}, "log") . " | " .
4898 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"tree")}, "tree") .
4899 ($pr->{'forks'} ? " | " . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "forks") : '') .
4900 "</td>\n" .
4901 "</tr>\n";
4902 }
4903 if (defined $extra) {
4904 print "<tr>\n";
4905 if ($check_forks) {
4906 print "<td></td>\n";
4907 }
4908 print "<td colspan=\"5\">$extra</td>\n" .
4909 "</tr>\n";
4910 }
4911 print "</table>\n";
4912 }
4914 sub git_log_body {
4915 # uses global variable $project
4916 my ($commitlist, $from, $to, $refs, $extra) = @_;
4918 $from = 0 unless defined $from;
4919 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4921 for (my $i = 0; $i <= $to; $i++) {
4922 my %co = %{$commitlist->[$i]};
4923 next if !%co;
4924 my $commit = $co{'id'};
4925 my $ref = format_ref_marker($refs, $commit);
4926 git_print_header_div('commit',
4927 "<span class=\"age\">$co{'age_string'}</span>" .
4928 esc_html($co{'title'}) . $ref,
4929 $commit);
4930 print "<div class=\"title_text\">\n" .
4931 "<div class=\"log_link\">\n" .
4932 $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") .
4933 " | " .
4934 $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") .
4935 " | " .
4936 $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree") .
4937 "<br/>\n" .
4938 "</div>\n";
4939 git_print_authorship(\%co, -tag => 'span');
4940 print "<br/>\n</div>\n";
4942 print "<div class=\"log_body\">\n";
4943 git_print_log($co{'comment'}, -final_empty_line=> 1);
4944 print "</div>\n";
4945 }
4946 if ($extra) {
4947 print "<div class=\"page_nav\">\n";
4948 print "$extra\n";
4949 print "</div>\n";
4950 }
4951 }
4953 sub git_shortlog_body {
4954 # uses global variable $project
4955 my ($commitlist, $from, $to, $refs, $extra) = @_;
4957 $from = 0 unless defined $from;
4958 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4960 print "<table class=\"shortlog\">\n";
4961 my $alternate = 1;
4962 for (my $i = $from; $i <= $to; $i++) {
4963 my %co = %{$commitlist->[$i]};
4964 my $commit = $co{'id'};
4965 my $ref = format_ref_marker($refs, $commit);
4966 if ($alternate) {
4967 print "<tr class=\"dark\">\n";
4968 } else {
4969 print "<tr class=\"light\">\n";
4970 }
4971 $alternate ^= 1;
4972 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4973 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4974 format_author_html('td', \%co, 10) . "<td>";
4975 print format_subject_html($co{'title'}, $co{'title_short'},
4976 href(action=>"commit", hash=>$commit), $ref);
4977 print "</td>\n" .
4978 "<td class=\"link\">" .
4979 $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") . " | " .
4980 $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") . " | " .
4981 $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree");
4982 my $snapshot_links = format_snapshot_links($commit);
4983 if (defined $snapshot_links) {
4984 print " | " . $snapshot_links;
4985 }
4986 print "</td>\n" .
4987 "</tr>\n";
4988 }
4989 if (defined $extra) {
4990 print "<tr>\n" .
4991 "<td colspan=\"4\">$extra</td>\n" .
4992 "</tr>\n";
4993 }
4994 print "</table>\n";
4995 }
4997 sub git_history_body {
4998 # Warning: assumes constant type (blob or tree) during history
4999 my ($commitlist, $from, $to, $refs, $extra,
5000 $file_name, $file_hash, $ftype) = @_;
5002 $from = 0 unless defined $from;
5003 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
5005 print "<table class=\"history\">\n";
5006 my $alternate = 1;
5007 for (my $i = $from; $i <= $to; $i++) {
5008 my %co = %{$commitlist->[$i]};
5009 if (!%co) {
5010 next;
5011 }
5012 my $commit = $co{'id'};
5014 my $ref = format_ref_marker($refs, $commit);
5016 if ($alternate) {
5017 print "<tr class=\"dark\">\n";
5018 } else {
5019 print "<tr class=\"light\">\n";
5020 }
5021 $alternate ^= 1;
5022 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5023 # shortlog: format_author_html('td', \%co, 10)
5024 format_author_html('td', \%co, 15, 3) . "<td>";
5025 # originally git_history used chop_str($co{'title'}, 50)
5026 print format_subject_html($co{'title'}, $co{'title_short'},
5027 href(action=>"commit", hash=>$commit), $ref);
5028 print "</td>\n" .
5029 "<td class=\"link\">" .
5030 $cgi->a({-href => href(action=>$ftype, hash_base=>$commit, file_name=>$file_name)}, $ftype) . " | " .
5031 $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff");
5033 if ($ftype eq 'blob') {
5034 my $blob_current = $file_hash;
5035 my $blob_parent = git_get_hash_by_path($commit, $file_name);
5036 if (defined $blob_current && defined $blob_parent &&
5037 $blob_current ne $blob_parent) {
5038 print " | " .
5039 $cgi->a({-href => href(action=>"blobdiff",
5040 hash=>$blob_current, hash_parent=>$blob_parent,
5041 hash_base=>$hash_base, hash_parent_base=>$commit,
5042 file_name=>$file_name)},
5043 "diff to current");
5044 }
5045 }
5046 print "</td>\n" .
5047 "</tr>\n";
5048 }
5049 if (defined $extra) {
5050 print "<tr>\n" .
5051 "<td colspan=\"4\">$extra</td>\n" .
5052 "</tr>\n";
5053 }
5054 print "</table>\n";
5055 }
5057 sub git_tags_body {
5058 # uses global variable $project
5059 my ($taglist, $from, $to, $extra) = @_;
5060 $from = 0 unless defined $from;
5061 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
5063 print "<table class=\"tags\">\n";
5064 my $alternate = 1;
5065 for (my $i = $from; $i <= $to; $i++) {
5066 my $entry = $taglist->[$i];
5067 my %tag = %$entry;
5068 my $comment = $tag{'subject'};
5069 my $comment_short;
5070 if (defined $comment) {
5071 $comment_short = chop_str($comment, 30, 5);
5072 }
5073 if ($alternate) {
5074 print "<tr class=\"dark\">\n";
5075 } else {
5076 print "<tr class=\"light\">\n";
5077 }
5078 $alternate ^= 1;
5079 if (defined $tag{'age'}) {
5080 print "<td><i>$tag{'age'}</i></td>\n";
5081 } else {
5082 print "<td></td>\n";
5083 }
5084 print "<td>" .
5085 $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'}),
5086 -class => "list name"}, esc_html($tag{'name'})) .
5087 "</td>\n" .
5088 "<td>";
5089 if (defined $comment) {
5090 print format_subject_html($comment, $comment_short,
5091 href(action=>"tag", hash=>$tag{'id'}));
5092 }
5093 print "</td>\n" .
5094 "<td class=\"selflink\">";
5095 if ($tag{'type'} eq "tag") {
5096 print $cgi->a({-href => href(action=>"tag", hash=>$tag{'id'})}, "tag");
5097 } else {
5098 print " ";
5099 }
5100 print "</td>\n" .
5101 "<td class=\"link\">" . " | " .
5102 $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'})}, $tag{'reftype'});
5103 if ($tag{'reftype'} eq "commit") {
5104 print " | " . $cgi->a({-href => href(action=>"shortlog", hash=>$tag{'fullname'})}, "shortlog") .
5105 " | " . $cgi->a({-href => href(action=>"log", hash=>$tag{'fullname'})}, "log");
5106 } elsif ($tag{'reftype'} eq "blob") {
5107 print " | " . $cgi->a({-href => href(action=>"blob_plain", hash=>$tag{'refid'})}, "raw");
5108 }
5109 print "</td>\n" .
5110 "</tr>";
5111 }
5112 if (defined $extra) {
5113 print "<tr>\n" .
5114 "<td colspan=\"5\">$extra</td>\n" .
5115 "</tr>\n";
5116 }
5117 print "</table>\n";
5118 }
5120 sub git_heads_body {
5121 # uses global variable $project
5122 my ($headlist, $head, $from, $to, $extra) = @_;
5123 $from = 0 unless defined $from;
5124 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
5126 print "<table class=\"heads\">\n";
5127 my $alternate = 1;
5128 for (my $i = $from; $i <= $to; $i++) {
5129 my $entry = $headlist->[$i];
5130 my %ref = %$entry;
5131 my $curr = $ref{'id'} eq $head;
5132 if ($alternate) {
5133 print "<tr class=\"dark\">\n";
5134 } else {
5135 print "<tr class=\"light\">\n";
5136 }
5137 $alternate ^= 1;
5138 print "<td><i>$ref{'age'}</i></td>\n" .
5139 ($curr ? "<td class=\"current_head\">" : "<td>") .
5140 $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'}),
5141 -class => "list name"},esc_html($ref{'name'})) .
5142 "</td>\n" .
5143 "<td class=\"link\">" .
5144 $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'})}, "shortlog") . " | " .
5145 $cgi->a({-href => href(action=>"log", hash=>$ref{'fullname'})}, "log") . " | " .
5146 $cgi->a({-href => href(action=>"tree", hash=>$ref{'fullname'}, hash_base=>$ref{'fullname'})}, "tree") .
5147 "</td>\n" .
5148 "</tr>";
5149 }
5150 if (defined $extra) {
5151 print "<tr>\n" .
5152 "<td colspan=\"3\">$extra</td>\n" .
5153 "</tr>\n";
5154 }
5155 print "</table>\n";
5156 }
5158 # Display a single remote block
5159 sub git_remote_block {
5160 my ($remote, $rdata, $limit, $head) = @_;
5162 my $heads = $rdata->{'heads'};
5163 my $fetch = $rdata->{'fetch'};
5164 my $push = $rdata->{'push'};
5166 my $urls_table = "<table class=\"projects_list\">\n" ;
5168 if (defined $fetch) {
5169 if ($fetch eq $push) {
5170 $urls_table .= format_repo_url("URL", $fetch);
5171 } else {
5172 $urls_table .= format_repo_url("Fetch URL", $fetch);
5173 $urls_table .= format_repo_url("Push URL", $push) if defined $push;
5174 }
5175 } elsif (defined $push) {
5176 $urls_table .= format_repo_url("Push URL", $push);
5177 } else {
5178 $urls_table .= format_repo_url("", "No remote URL");
5179 }
5181 $urls_table .= "</table>\n";
5183 my $dots;
5184 if (defined $limit && $limit < @$heads) {
5185 $dots = $cgi->a({-href => href(action=>"remotes", hash=>$remote)}, "...");
5186 }
5188 print $urls_table;
5189 git_heads_body($heads, $head, 0, $limit, $dots);
5190 }
5192 # Display a list of remote names with the respective fetch and push URLs
5193 sub git_remotes_list {
5194 my ($remotedata, $limit) = @_;
5195 print "<table class=\"heads\">\n";
5196 my $alternate = 1;
5197 my @remotes = sort keys %$remotedata;
5199 my $limited = $limit && $limit < @remotes;
5201 $#remotes = $limit - 1 if $limited;
5203 while (my $remote = shift @remotes) {
5204 my $rdata = $remotedata->{$remote};
5205 my $fetch = $rdata->{'fetch'};
5206 my $push = $rdata->{'push'};
5207 if ($alternate) {
5208 print "<tr class=\"dark\">\n";
5209 } else {
5210 print "<tr class=\"light\">\n";
5211 }
5212 $alternate ^= 1;
5213 print "<td>" .
5214 $cgi->a({-href=> href(action=>'remotes', hash=>$remote),
5215 -class=> "list name"},esc_html($remote)) .
5216 "</td>";
5217 print "<td class=\"link\">" .
5218 (defined $fetch ? $cgi->a({-href=> $fetch}, "fetch") : "fetch") .
5219 " | " .
5220 (defined $push ? $cgi->a({-href=> $push}, "push") : "push") .
5221 "</td>";
5223 print "</tr>\n";
5224 }
5226 if ($limited) {
5227 print "<tr>\n" .
5228 "<td colspan=\"3\">" .
5229 $cgi->a({-href => href(action=>"remotes")}, "...") .
5230 "</td>\n" . "</tr>\n";
5231 }
5233 print "</table>";
5234 }
5236 # Display remote heads grouped by remote, unless there are too many
5237 # remotes, in which case we only display the remote names
5238 sub git_remotes_body {
5239 my ($remotedata, $limit, $head) = @_;
5240 if ($limit and $limit < keys %$remotedata) {
5241 git_remotes_list($remotedata, $limit);
5242 } else {
5243 fill_remote_heads($remotedata);
5244 while (my ($remote, $rdata) = each %$remotedata) {
5245 git_print_section({-class=>"remote", -id=>$remote},
5246 ["remotes", $remote, $remote], sub {
5247 git_remote_block($remote, $rdata, $limit, $head);
5248 });
5249 }
5250 }
5251 }
5253 sub git_search_grep_body {
5254 my ($commitlist, $from, $to, $extra) = @_;
5255 $from = 0 unless defined $from;
5256 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5258 print "<table class=\"commit_search\">\n";
5259 my $alternate = 1;
5260 for (my $i = $from; $i <= $to; $i++) {
5261 my %co = %{$commitlist->[$i]};
5262 if (!%co) {
5263 next;
5264 }
5265 my $commit = $co{'id'};
5266 if ($alternate) {
5267 print "<tr class=\"dark\">\n";
5268 } else {
5269 print "<tr class=\"light\">\n";
5270 }
5271 $alternate ^= 1;
5272 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5273 format_author_html('td', \%co, 15, 5) .
5274 "<td>" .
5275 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
5276 -class => "list subject"},
5277 chop_and_escape_str($co{'title'}, 50) . "<br/>");
5278 my $comment = $co{'comment'};
5279 foreach my $line (@$comment) {
5280 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
5281 my ($lead, $match, $trail) = ($1, $2, $3);
5282 $match = chop_str($match, 70, 5, 'center');
5283 my $contextlen = int((80 - length($match))/2);
5284 $contextlen = 30 if ($contextlen > 30);
5285 $lead = chop_str($lead, $contextlen, 10, 'left');
5286 $trail = chop_str($trail, $contextlen, 10, 'right');
5288 $lead = esc_html($lead);
5289 $match = esc_html($match);
5290 $trail = esc_html($trail);
5292 print "$lead<span class=\"match\">$match</span>$trail<br />";
5293 }
5294 }
5295 print "</td>\n" .
5296 "<td class=\"link\">" .
5297 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
5298 " | " .
5299 $cgi->a({-href => href(action=>"commitdiff", hash=>$co{'id'})}, "commitdiff") .
5300 " | " .
5301 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
5302 print "</td>\n" .
5303 "</tr>\n";
5304 }
5305 if (defined $extra) {
5306 print "<tr>\n" .
5307 "<td colspan=\"3\">$extra</td>\n" .
5308 "</tr>\n";
5309 }
5310 print "</table>\n";
5311 }
5313 ## ======================================================================
5314 ## ======================================================================
5315 ## actions
5317 sub git_project_list {
5318 my $order = $input_params{'order'};
5319 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5320 die_error(400, "Unknown order parameter");
5321 }
5323 my @list = git_get_projects_list();
5324 if (!@list) {
5325 die_error(404, "No projects found");
5326 }
5328 git_header_html();
5329 if (defined $home_text && -f $home_text) {
5330 print "<div class=\"index_include\">\n";
5331 insert_file($home_text);
5332 print "</div>\n";
5333 }
5334 print $cgi->startform(-method => "get") .
5335 "<p class=\"projsearch\">Search:\n" .
5336 $cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
5337 "</p>" .
5338 $cgi->end_form() . "\n";
5339 git_project_list_body(\@list, $order);
5340 git_footer_html();
5341 }
5343 sub git_forks {
5344 my $order = $input_params{'order'};
5345 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
5346 die_error(400, "Unknown order parameter");
5347 }
5349 my @list = git_get_projects_list($project);
5350 if (!@list) {
5351 die_error(404, "No forks found");
5352 }
5354 git_header_html();
5355 git_print_page_nav('','');
5356 git_print_header_div('summary', "$project forks");
5357 git_project_list_body(\@list, $order);
5358 git_footer_html();
5359 }
5361 sub git_project_index {
5362 my @projects = git_get_projects_list($project);
5364 print $cgi->header(
5365 -type => 'text/plain',
5366 -charset => 'utf-8',
5367 -content_disposition => 'inline; filename="index.aux"');
5369 foreach my $pr (@projects) {
5370 if (!exists $pr->{'owner'}) {
5371 $pr->{'owner'} = git_get_project_owner("$pr->{'path'}");
5372 }
5374 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
5375 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
5376 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
5377 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
5378 $path =~ s/ /\+/g;
5379 $owner =~ s/ /\+/g;
5381 print "$path $owner\n";
5382 }
5383 }
5385 sub git_summary {
5386 my $descr = git_get_project_description($project) || "none";
5387 my %co = parse_commit("HEAD");
5388 my %cd = %co ? parse_date($co{'committer_epoch'}, $co{'committer_tz'}) : ();
5389 my $head = $co{'id'};
5390 my $remote_heads = gitweb_check_feature('remote_heads');
5392 my $owner = git_get_project_owner($project);
5394 my $refs = git_get_references();
5395 # These get_*_list functions return one more to allow us to see if
5396 # there are more ...
5397 my @taglist = git_get_tags_list(16);
5398 my @headlist = git_get_heads_list(16);
5399 my %remotedata = $remote_heads ? git_get_remotes_list() : ();
5400 my @forklist;
5401 my $check_forks = gitweb_check_feature('forks');
5403 if ($check_forks) {
5404 @forklist = git_get_projects_list($project);
5405 }
5407 git_header_html();
5408 git_print_page_nav('summary','', $head);
5410 print "<div class=\"title\"> </div>\n";
5411 print "<table class=\"projects_list\">\n" .
5412 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html($descr) . "</td></tr>\n" .
5413 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html($owner) . "</td></tr>\n";
5414 if (defined $cd{'rfc2822'}) {
5415 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
5416 }
5418 # use per project git URL list in $projectroot/$project/cloneurl
5419 # or make project git URL from git base URL and project name
5420 my $url_tag = "URL";
5421 my @url_list = git_get_project_url_list($project);
5422 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
5423 foreach my $git_url (@url_list) {
5424 next unless $git_url;
5425 print format_repo_url($url_tag, $git_url);
5426 $url_tag = "";
5427 }
5429 # Tag cloud
5430 my $show_ctags = gitweb_check_feature('ctags');
5431 if ($show_ctags) {
5432 my $ctags = git_get_project_ctags($project);
5433 my $cloud = git_populate_project_tagcloud($ctags);
5434 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
5435 print "</td>\n<td>" unless %$ctags;
5436 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
5437 print "</td>\n<td>" if %$ctags;
5438 print git_show_project_tagcloud($cloud, 48);
5439 print "</td></tr>";
5440 }
5442 print "</table>\n";
5444 # If XSS prevention is on, we don't include README.html.
5445 # TODO: Allow a readme in some safe format.
5446 if (!$prevent_xss && -s "$projectroot/$project/README.html") {
5447 print "<div class=\"title\">readme</div>\n" .
5448 "<div class=\"readme\">\n";
5449 insert_file("$projectroot/$project/README.html");
5450 print "\n</div>\n"; # class="readme"
5451 }
5453 # we need to request one more than 16 (0..15) to check if
5454 # those 16 are all
5455 my @commitlist = $head ? parse_commits($head, 17) : ();
5456 if (@commitlist) {
5457 git_print_header_div('shortlog');
5458 git_shortlog_body(\@commitlist, 0, 15, $refs,
5459 $#commitlist <= 15 ? undef :
5460 $cgi->a({-href => href(action=>"shortlog")}, "..."));
5461 }
5463 if (@taglist) {
5464 git_print_header_div('tags');
5465 git_tags_body(\@taglist, 0, 15,
5466 $#taglist <= 15 ? undef :
5467 $cgi->a({-href => href(action=>"tags")}, "..."));
5468 }
5470 if (@headlist) {
5471 git_print_header_div('heads');
5472 git_heads_body(\@headlist, $head, 0, 15,
5473 $#headlist <= 15 ? undef :
5474 $cgi->a({-href => href(action=>"heads")}, "..."));
5475 }
5477 if (%remotedata) {
5478 git_print_header_div('remotes');
5479 git_remotes_body(\%remotedata, 15, $head);
5480 }
5482 if (@forklist) {
5483 git_print_header_div('forks');
5484 git_project_list_body(\@forklist, 'age', 0, 15,
5485 $#forklist <= 15 ? undef :
5486 $cgi->a({-href => href(action=>"forks")}, "..."),
5487 'no_header');
5488 }
5490 git_footer_html();
5491 }
5493 sub git_tag {
5494 my %tag = parse_tag($hash);
5496 if (! %tag) {
5497 die_error(404, "Unknown tag object");
5498 }
5500 my $head = git_get_head_hash($project);
5501 git_header_html();
5502 git_print_page_nav('','', $head,undef,$head);
5503 git_print_header_div('commit', esc_html($tag{'name'}), $hash);
5504 print "<div class=\"title_text\">\n" .
5505 "<table class=\"object_header\">\n" .
5506 "<tr>\n" .
5507 "<td>object</td>\n" .
5508 "<td>" . $cgi->a({-class => "list", -href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
5509 $tag{'object'}) . "</td>\n" .
5510 "<td class=\"link\">" . $cgi->a({-href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
5511 $tag{'type'}) . "</td>\n" .
5512 "</tr>\n";
5513 if (defined($tag{'author'})) {
5514 git_print_authorship_rows(\%tag, 'author');
5515 }
5516 print "</table>\n\n" .
5517 "</div>\n";
5518 print "<div class=\"page_body\">";
5519 my $comment = $tag{'comment'};
5520 foreach my $line (@$comment) {
5521 chomp $line;
5522 print esc_html($line, -nbsp=>1) . "<br/>\n";
5523 }
5524 print "</div>\n";
5525 git_footer_html();
5526 }
5528 sub git_blame_common {
5529 my $format = shift || 'porcelain';
5530 if ($format eq 'porcelain' && $cgi->param('js')) {
5531 $format = 'incremental';
5532 $action = 'blame_incremental'; # for page title etc
5533 }
5535 # permissions
5536 gitweb_check_feature('blame')
5537 or die_error(403, "Blame view not allowed");
5539 # error checking
5540 die_error(400, "No file name given") unless $file_name;
5541 $hash_base ||= git_get_head_hash($project);
5542 die_error(404, "Couldn't find base commit") unless $hash_base;
5543 my %co = parse_commit($hash_base)
5544 or die_error(404, "Commit not found");
5545 my $ftype = "blob";
5546 if (!defined $hash) {
5547 $hash = git_get_hash_by_path($hash_base, $file_name, "blob")
5548 or die_error(404, "Error looking up file");
5549 } else {
5550 $ftype = git_get_type($hash);
5551 if ($ftype !~ "blob") {
5552 die_error(400, "Object is not a blob");
5553 }
5554 }
5556 my $fd;
5557 if ($format eq 'incremental') {
5558 # get file contents (as base)
5559 open $fd, "-|", git_cmd(), 'cat-file', 'blob', $hash
5560 or die_error(500, "Open git-cat-file failed");
5561 } elsif ($format eq 'data') {
5562 # run git-blame --incremental
5563 open $fd, "-|", git_cmd(), "blame", "--incremental",
5564 $hash_base, "--", $file_name
5565 or die_error(500, "Open git-blame --incremental failed");
5566 } else {
5567 # run git-blame --porcelain
5568 open $fd, "-|", git_cmd(), "blame", '-p',
5569 $hash_base, '--', $file_name
5570 or die_error(500, "Open git-blame --porcelain failed");
5571 }
5573 # incremental blame data returns early
5574 if ($format eq 'data') {
5575 print $cgi->header(
5576 -type=>"text/plain", -charset => "utf-8",
5577 -status=> "200 OK");
5578 local $| = 1; # output autoflush
5579 print while <$fd>;
5580 close $fd
5581 or print "ERROR $!\n";
5583 print 'END';
5584 if (defined $t0 && gitweb_check_feature('timed')) {
5585 print ' '.
5586 tv_interval($t0, [ gettimeofday() ]).
5587 ' '.$number_of_git_cmds;
5588 }
5589 print "\n";
5591 return;
5592 }
5594 # page header
5595 git_header_html();
5596 my $formats_nav =
5597 $cgi->a({-href => href(action=>"blob", -replay=>1)},
5598 "blob") .
5599 " | ";
5600 if ($format eq 'incremental') {
5601 $formats_nav .=
5602 $cgi->a({-href => href(action=>"blame", javascript=>0, -replay=>1)},
5603 "blame") . " (non-incremental)";
5604 } else {
5605 $formats_nav .=
5606 $cgi->a({-href => href(action=>"blame_incremental", -replay=>1)},
5607 "blame") . " (incremental)";
5608 }
5609 $formats_nav .=
5610 " | " .
5611 $cgi->a({-href => href(action=>"history", -replay=>1)},
5612 "history") .
5613 " | " .
5614 $cgi->a({-href => href(action=>$action, file_name=>$file_name)},
5615 "HEAD");
5616 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5617 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
5618 git_print_page_path($file_name, $ftype, $hash_base);
5620 # page body
5621 if ($format eq 'incremental') {
5622 print "<noscript>\n<div class=\"error\"><center><b>\n".
5623 "This page requires JavaScript to run.\n Use ".
5624 $cgi->a({-href => href(action=>'blame',javascript=>0,-replay=>1)},
5625 'this page').
5626 " instead.\n".
5627 "</b></center></div>\n</noscript>\n";
5629 print qq!<div id="progress_bar" style="width: 100%; background-color: yellow"></div>\n!;
5630 }
5632 print qq!<div class="page_body">\n!;
5633 print qq!<div id="progress_info">... / ...</div>\n!
5634 if ($format eq 'incremental');
5635 print qq!<table id="blame_table" class="blame" width="100%">\n!.
5636 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
5637 qq!<thead>\n!.
5638 qq!<tr><th>Commit</th><th>Line</th><th>Data</th></tr>\n!.
5639 qq!</thead>\n!.
5640 qq!<tbody>\n!;
5642 my @rev_color = qw(light dark);
5643 my $num_colors = scalar(@rev_color);
5644 my $current_color = 0;
5646 if ($format eq 'incremental') {
5647 my $color_class = $rev_color[$current_color];
5649 #contents of a file
5650 my $linenr = 0;
5651 LINE:
5652 while (my $line = <$fd>) {
5653 chomp $line;
5654 $linenr++;
5656 print qq!<tr id="l$linenr" class="$color_class">!.
5657 qq!<td class="sha1"><a href=""> </a></td>!.
5658 qq!<td class="linenr">!.
5659 qq!<a class="linenr" href="">$linenr</a></td>!;
5660 print qq!<td class="pre">! . esc_html($line) . "</td>\n";
5661 print qq!</tr>\n!;
5662 }
5664 } else { # porcelain, i.e. ordinary blame
5665 my %metainfo = (); # saves information about commits
5667 # blame data
5668 LINE:
5669 while (my $line = <$fd>) {
5670 chomp $line;
5671 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
5672 # no <lines in group> for subsequent lines in group of lines
5673 my ($full_rev, $orig_lineno, $lineno, $group_size) =
5674 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
5675 if (!exists $metainfo{$full_rev}) {
5676 $metainfo{$full_rev} = { 'nprevious' => 0 };
5677 }
5678 my $meta = $metainfo{$full_rev};
5679 my $data;
5680 while ($data = <$fd>) {
5681 chomp $data;
5682 last if ($data =~ s/^\t//); # contents of line
5683 if ($data =~ /^(\S+)(?: (.*))?$/) {
5684 $meta->{$1} = $2 unless exists $meta->{$1};
5685 }
5686 if ($data =~ /^previous /) {
5687 $meta->{'nprevious'}++;
5688 }
5689 }
5690 my $short_rev = substr($full_rev, 0, 8);
5691 my $author = $meta->{'author'};
5692 my %date =
5693 parse_date($meta->{'author-time'}, $meta->{'author-tz'});
5694 my $date = $date{'iso-tz'};
5695 if ($group_size) {
5696 $current_color = ($current_color + 1) % $num_colors;
5697 }
5698 my $tr_class = $rev_color[$current_color];
5699 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
5700 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
5701 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
5702 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
5703 if ($group_size) {
5704 print "<td class=\"sha1\"";
5705 print " title=\"". esc_html($author) . ", $date\"";
5706 print " rowspan=\"$group_size\"" if ($group_size > 1);
5707 print ">";
5708 print $cgi->a({-href => href(action=>"commit",
5709 hash=>$full_rev,
5710 file_name=>$file_name)},
5711 esc_html($short_rev));
5712 if ($group_size >= 2) {
5713 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
5714 if (@author_initials) {
5715 print "<br />" .
5716 esc_html(join('', @author_initials));
5717 # or join('.', ...)
5718 }
5719 }
5720 print "</td>\n";
5721 }
5722 # 'previous' <sha1 of parent commit> <filename at commit>
5723 if (exists $meta->{'previous'} &&
5724 $meta->{'previous'} =~ /^([a-fA-F0-9]{40}) (.*)$/) {
5725 $meta->{'parent'} = $1;
5726 $meta->{'file_parent'} = unquote($2);
5727 }
5728 my $linenr_commit =
5729 exists($meta->{'parent'}) ?
5730 $meta->{'parent'} : $full_rev;
5731 my $linenr_filename =
5732 exists($meta->{'file_parent'}) ?
5733 $meta->{'file_parent'} : unquote($meta->{'filename'});
5734 my $blamed = href(action => 'blame',
5735 file_name => $linenr_filename,
5736 hash_base => $linenr_commit);
5737 print "<td class=\"linenr\">";
5738 print $cgi->a({ -href => "$blamed#l$orig_lineno",
5739 -class => "linenr" },
5740 esc_html($lineno));
5741 print "</td>";
5742 print "<td class=\"pre\">" . esc_html($data) . "</td>\n";
5743 print "</tr>\n";
5744 } # end while
5746 }
5748 # footer
5749 print "</tbody>\n".
5750 "</table>\n"; # class="blame"
5751 print "</div>\n"; # class="blame_body"
5752 close $fd
5753 or print "Reading blob failed\n";
5755 git_footer_html();
5756 }
5758 sub git_blame {
5759 git_blame_common();
5760 }
5762 sub git_blame_incremental {
5763 git_blame_common('incremental');
5764 }
5766 sub git_blame_data {
5767 git_blame_common('data');
5768 }
5770 sub git_tags {
5771 my $head = git_get_head_hash($project);
5772 git_header_html();
5773 git_print_page_nav('','', $head,undef,$head,format_ref_views('tags'));
5774 git_print_header_div('summary', $project);
5776 my @tagslist = git_get_tags_list();
5777 if (@tagslist) {
5778 git_tags_body(\@tagslist);
5779 }
5780 git_footer_html();
5781 }
5783 sub git_heads {
5784 my $head = git_get_head_hash($project);
5785 git_header_html();
5786 git_print_page_nav('','', $head,undef,$head,format_ref_views('heads'));
5787 git_print_header_div('summary', $project);
5789 my @headslist = git_get_heads_list();
5790 if (@headslist) {
5791 git_heads_body(\@headslist, $head);
5792 }
5793 git_footer_html();
5794 }
5796 # used both for single remote view and for list of all the remotes
5797 sub git_remotes {
5798 gitweb_check_feature('remote_heads')
5799 or die_error(403, "Remote heads view is disabled");
5801 my $head = git_get_head_hash($project);
5802 my $remote = $input_params{'hash'};
5804 my $remotedata = git_get_remotes_list($remote);
5805 die_error(500, "Unable to get remote information") unless defined $remotedata;
5807 unless (%$remotedata) {
5808 die_error(404, defined $remote ?
5809 "Remote $remote not found" :
5810 "No remotes found");
5811 }
5813 git_header_html(undef, undef, -action_extra => $remote);
5814 git_print_page_nav('', '', $head, undef, $head,
5815 format_ref_views($remote ? '' : 'remotes'));
5817 fill_remote_heads($remotedata);
5818 if (defined $remote) {
5819 git_print_header_div('remotes', "$remote remote for $project");
5820 git_remote_block($remote, $remotedata->{$remote}, undef, $head);
5821 } else {
5822 git_print_header_div('summary', "$project remotes");
5823 git_remotes_body($remotedata, undef, $head);
5824 }
5826 git_footer_html();
5827 }
5829 sub git_blob_plain {
5830 my $type = shift;
5831 my $expires;
5833 if (!defined $hash) {
5834 if (defined $file_name) {
5835 my $base = $hash_base || git_get_head_hash($project);
5836 $hash = git_get_hash_by_path($base, $file_name, "blob")
5837 or die_error(404, "Cannot find file");
5838 } else {
5839 die_error(400, "No file name defined");
5840 }
5841 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5842 # blobs defined by non-textual hash id's can be cached
5843 $expires = "+1d";
5844 }
5846 open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
5847 or die_error(500, "Open git-cat-file blob '$hash' failed");
5849 # content-type (can include charset)
5850 $type = blob_contenttype($fd, $file_name, $type);
5852 # "save as" filename, even when no $file_name is given
5853 my $save_as = "$hash";
5854 if (defined $file_name) {
5855 $save_as = $file_name;
5856 } elsif ($type =~ m/^text\//) {
5857 $save_as .= '.txt';
5858 }
5860 # With XSS prevention on, blobs of all types except a few known safe
5861 # ones are served with "Content-Disposition: attachment" to make sure
5862 # they don't run in our security domain. For certain image types,
5863 # blob view writes an <img> tag referring to blob_plain view, and we
5864 # want to be sure not to break that by serving the image as an
5865 # attachment (though Firefox 3 doesn't seem to care).
5866 my $sandbox = $prevent_xss &&
5867 $type !~ m!^(?:text/plain|image/(?:gif|png|jpeg))$!;
5869 print $cgi->header(
5870 -type => $type,
5871 -expires => $expires,
5872 -content_disposition =>
5873 ($sandbox ? 'attachment' : 'inline')
5874 . '; filename="' . $save_as . '"');
5875 local $/ = undef;
5876 binmode STDOUT, ':raw';
5877 print <$fd>;
5878 binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
5879 close $fd;
5880 }
5882 sub git_blob {
5883 my $expires;
5885 if (!defined $hash) {
5886 if (defined $file_name) {
5887 my $base = $hash_base || git_get_head_hash($project);
5888 $hash = git_get_hash_by_path($base, $file_name, "blob")
5889 or die_error(404, "Cannot find file");
5890 } else {
5891 die_error(400, "No file name defined");
5892 }
5893 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5894 # blobs defined by non-textual hash id's can be cached
5895 $expires = "+1d";
5896 }
5898 my $have_blame = gitweb_check_feature('blame');
5899 open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
5900 or die_error(500, "Couldn't cat $file_name, $hash");
5901 my $mimetype = blob_mimetype($fd, $file_name);
5902 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
5903 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B $fd) {
5904 close $fd;
5905 return git_blob_plain($mimetype);
5906 }
5907 # we can have blame only for text/* mimetype
5908 $have_blame &&= ($mimetype =~ m!^text/!);
5910 my $highlight = gitweb_check_feature('highlight');
5911 my $syntax = guess_file_syntax($highlight, $mimetype, $file_name);
5912 $fd = run_highlighter($fd, $highlight, $syntax)
5913 if $syntax;
5915 git_header_html(undef, $expires);
5916 my $formats_nav = '';
5917 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
5918 if (defined $file_name) {
5919 if ($have_blame) {
5920 $formats_nav .=
5921 $cgi->a({-href => href(action=>"blame", -replay=>1)},
5922 "blame") .
5923 " | ";
5924 }
5925 $formats_nav .=
5926 $cgi->a({-href => href(action=>"history", -replay=>1)},
5927 "history") .
5928 " | " .
5929 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
5930 "raw") .
5931 " | " .
5932 $cgi->a({-href => href(action=>"blob",
5933 hash_base=>"HEAD", file_name=>$file_name)},
5934 "HEAD");
5935 } else {
5936 $formats_nav .=
5937 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
5938 "raw");
5939 }
5940 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5941 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
5942 } else {
5943 print "<div class=\"page_nav\">\n" .
5944 "<br/><br/></div>\n" .
5945 "<div class=\"title\">".esc_html($hash)."</div>\n";
5946 }
5947 git_print_page_path($file_name, "blob", $hash_base);
5948 print "<div class=\"page_body\">\n";
5949 if ($mimetype =~ m!^image/!) {
5950 print qq!<img type="!.esc_attr($mimetype).qq!"!;
5951 if ($file_name) {
5952 print qq! alt="!.esc_attr($file_name).qq!" title="!.esc_attr($file_name).qq!"!;
5953 }
5954 print qq! src="! .
5955 href(action=>"blob_plain", hash=>$hash,
5956 hash_base=>$hash_base, file_name=>$file_name) .
5957 qq!" />\n!;
5958 } else {
5959 my $nr;
5960 while (my $line = <$fd>) {
5961 chomp $line;
5962 $nr++;
5963 $line = untabify($line);
5964 printf qq!<div class="pre"><a id="l%i" href="%s#l%i" class="linenr">%4i</a> %s</div>\n!,
5965 $nr, esc_attr(href(-replay => 1)), $nr, $nr, $syntax ? $line : esc_html($line, -nbsp=>1);
5966 }
5967 }
5968 close $fd
5969 or print "Reading blob failed.\n";
5970 print "</div>";
5971 git_footer_html();
5972 }
5974 sub git_tree {
5975 if (!defined $hash_base) {
5976 $hash_base = "HEAD";
5977 }
5978 if (!defined $hash) {
5979 if (defined $file_name) {
5980 $hash = git_get_hash_by_path($hash_base, $file_name, "tree");
5981 } else {
5982 $hash = $hash_base;
5983 }
5984 }
5985 die_error(404, "No such tree") unless defined($hash);
5987 my $show_sizes = gitweb_check_feature('show-sizes');
5988 my $have_blame = gitweb_check_feature('blame');
5990 my @entries = ();
5991 {
5992 local $/ = "\0";
5993 open my $fd, "-|", git_cmd(), "ls-tree", '-z',
5994 ($show_sizes ? '-l' : ()), @extra_options, $hash
5995 or die_error(500, "Open git-ls-tree failed");
5996 @entries = map { chomp; $_ } <$fd>;
5997 close $fd
5998 or die_error(404, "Reading tree failed");
5999 }
6001 my $refs = git_get_references();
6002 my $ref = format_ref_marker($refs, $hash_base);
6003 git_header_html();
6004 my $basedir = '';
6005 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
6006 my @views_nav = ();
6007 if (defined $file_name) {
6008 push @views_nav,
6009 $cgi->a({-href => href(action=>"history", -replay=>1)},
6010 "history"),
6011 $cgi->a({-href => href(action=>"tree",
6012 hash_base=>"HEAD", file_name=>$file_name)},
6013 "HEAD"),
6014 }
6015 my $snapshot_links = format_snapshot_links($hash);
6016 if (defined $snapshot_links) {
6017 # FIXME: Should be available when we have no hash base as well.
6018 push @views_nav, $snapshot_links;
6019 }
6020 git_print_page_nav('tree','', $hash_base, undef, undef,
6021 join(' | ', @views_nav));
6022 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash_base);
6023 } else {
6024 undef $hash_base;
6025 print "<div class=\"page_nav\">\n";
6026 print "<br/><br/></div>\n";
6027 print "<div class=\"title\">".esc_html($hash)."</div>\n";
6028 }
6029 if (defined $file_name) {
6030 $basedir = $file_name;
6031 if ($basedir ne '' && substr($basedir, -1) ne '/') {
6032 $basedir .= '/';
6033 }
6034 git_print_page_path($file_name, 'tree', $hash_base);
6035 }
6036 print "<div class=\"page_body\">\n";
6037 print "<table class=\"tree\">\n";
6038 my $alternate = 1;
6039 # '..' (top directory) link if possible
6040 if (defined $hash_base &&
6041 defined $file_name && $file_name =~ m![^/]+$!) {
6042 if ($alternate) {
6043 print "<tr class=\"dark\">\n";
6044 } else {
6045 print "<tr class=\"light\">\n";
6046 }
6047 $alternate ^= 1;
6049 my $up = $file_name;
6050 $up =~ s!/?[^/]+$!!;
6051 undef $up unless $up;
6052 # based on git_print_tree_entry
6053 print '<td class="mode">' . mode_str('040000') . "</td>\n";
6054 print '<td class="size"> </td>'."\n" if $show_sizes;
6055 print '<td class="list">';
6056 print $cgi->a({-href => href(action=>"tree",
6057 hash_base=>$hash_base,
6058 file_name=>$up)},
6059 "..");
6060 print "</td>\n";
6061 print "<td class=\"link\"></td>\n";
6063 print "</tr>\n";
6064 }
6065 foreach my $line (@entries) {
6066 my %t = parse_ls_tree_line($line, -z => 1, -l => $show_sizes);
6068 if ($alternate) {
6069 print "<tr class=\"dark\">\n";
6070 } else {
6071 print "<tr class=\"light\">\n";
6072 }
6073 $alternate ^= 1;
6075 git_print_tree_entry(\%t, $basedir, $hash_base, $have_blame);
6077 print "</tr>\n";
6078 }
6079 print "</table>\n" .
6080 "</div>";
6081 git_footer_html();
6082 }
6084 sub snapshot_name {
6085 my ($project, $hash) = @_;
6087 # path/to/project.git -> project
6088 # path/to/project/.git -> project
6089 my $name = to_utf8($project);
6090 $name =~ s,([^/])/*\.git$,$1,;
6091 $name = basename($name);
6092 # sanitize name
6093 $name =~ s/[[:cntrl:]]/?/g;
6095 my $ver = $hash;
6096 if ($hash =~ /^[0-9a-fA-F]+$/) {
6097 # shorten SHA-1 hash
6098 my $full_hash = git_get_full_hash($project, $hash);
6099 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
6100 $ver = git_get_short_hash($project, $hash);
6101 }
6102 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
6103 # tags don't need shortened SHA-1 hash
6104 $ver = $1;
6105 } else {
6106 # branches and other need shortened SHA-1 hash
6107 if ($hash =~ m!^refs/(?:heads|remotes)/(.*)$!) {
6108 $ver = $1;
6109 }
6110 $ver .= '-' . git_get_short_hash($project, $hash);
6111 }
6112 # in case of hierarchical branch names
6113 $ver =~ s!/!.!g;
6115 # name = project-version_string
6116 $name = "$name-$ver";
6118 return wantarray ? ($name, $name) : $name;
6119 }
6121 sub git_snapshot {
6122 my $format = $input_params{'snapshot_format'};
6123 if (!@snapshot_fmts) {
6124 die_error(403, "Snapshots not allowed");
6125 }
6126 # default to first supported snapshot format
6127 $format ||= $snapshot_fmts[0];
6128 if ($format !~ m/^[a-z0-9]+$/) {
6129 die_error(400, "Invalid snapshot format parameter");
6130 } elsif (!exists($known_snapshot_formats{$format})) {
6131 die_error(400, "Unknown snapshot format");
6132 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
6133 die_error(403, "Snapshot format not allowed");
6134 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
6135 die_error(403, "Unsupported snapshot format");
6136 }
6138 my $type = git_get_type("$hash^{}");
6139 if (!$type) {
6140 die_error(404, 'Object does not exist');
6141 } elsif ($type eq 'blob') {
6142 die_error(400, 'Object is not a tree-ish');
6143 }
6145 my ($name, $prefix) = snapshot_name($project, $hash);
6146 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
6147 my $cmd = quote_command(
6148 git_cmd(), 'archive',
6149 "--format=$known_snapshot_formats{$format}{'format'}",
6150 "--prefix=$prefix/", $hash);
6151 if (exists $known_snapshot_formats{$format}{'compressor'}) {
6152 $cmd .= ' | ' . quote_command(@{$known_snapshot_formats{$format}{'compressor'}});
6153 }
6155 $filename =~ s/(["\\])/\\$1/g;
6156 print $cgi->header(
6157 -type => $known_snapshot_formats{$format}{'type'},
6158 -content_disposition => 'inline; filename="' . $filename . '"',
6159 -status => '200 OK');
6161 open my $fd, "-|", $cmd
6162 or die_error(500, "Execute git-archive failed");
6163 binmode STDOUT, ':raw';
6164 print <$fd>;
6165 binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
6166 close $fd;
6167 }
6169 sub git_log_generic {
6170 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
6172 my $head = git_get_head_hash($project);
6173 if (!defined $base) {
6174 $base = $head;
6175 }
6176 if (!defined $page) {
6177 $page = 0;
6178 }
6179 my $refs = git_get_references();
6181 my $commit_hash = $base;
6182 if (defined $parent) {
6183 $commit_hash = "$parent..$base";
6184 }
6185 my @commitlist =
6186 parse_commits($commit_hash, 101, (100 * $page),
6187 defined $file_name ? ($file_name, "--full-history") : ());
6189 my $ftype;
6190 if (!defined $file_hash && defined $file_name) {
6191 # some commits could have deleted file in question,
6192 # and not have it in tree, but one of them has to have it
6193 for (my $i = 0; $i < @commitlist; $i++) {
6194 $file_hash = git_get_hash_by_path($commitlist[$i]{'id'}, $file_name);
6195 last if defined $file_hash;
6196 }
6197 }
6198 if (defined $file_hash) {
6199 $ftype = git_get_type($file_hash);
6200 }
6201 if (defined $file_name && !defined $ftype) {
6202 die_error(500, "Unknown type of object");
6203 }
6204 my %co;
6205 if (defined $file_name) {
6206 %co = parse_commit($base)
6207 or die_error(404, "Unknown commit object");
6208 }
6211 my $paging_nav = format_paging_nav($fmt_name, $page, $#commitlist >= 100);
6212 my $next_link = '';
6213 if ($#commitlist >= 100) {
6214 $next_link =
6215 $cgi->a({-href => href(-replay=>1, page=>$page+1),
6216 -accesskey => "n", -title => "Alt-n"}, "next");
6217 }
6218 my $patch_max = gitweb_get_feature('patches');
6219 if ($patch_max && !defined $file_name) {
6220 if ($patch_max < 0 || @commitlist <= $patch_max) {
6221 $paging_nav .= " ⋅ " .
6222 $cgi->a({-href => href(action=>"patches", -replay=>1)},
6223 "patches");
6224 }
6225 }
6227 git_header_html();
6228 git_print_page_nav($fmt_name,'', $hash,$hash,$hash, $paging_nav);
6229 if (defined $file_name) {
6230 git_print_header_div('commit', esc_html($co{'title'}), $base);
6231 } else {
6232 git_print_header_div('summary', $project)
6233 }
6234 git_print_page_path($file_name, $ftype, $hash_base)
6235 if (defined $file_name);
6237 $body_subr->(\@commitlist, 0, 99, $refs, $next_link,
6238 $file_name, $file_hash, $ftype);
6240 git_footer_html();
6241 }
6243 sub git_log {
6244 git_log_generic('log', \&git_log_body,
6245 $hash, $hash_parent);
6246 }
6248 sub git_commit {
6249 $hash ||= $hash_base || "HEAD";
6250 my %co = parse_commit($hash)
6251 or die_error(404, "Unknown commit object");
6253 my $parent = $co{'parent'};
6254 my $parents = $co{'parents'}; # listref
6256 # we need to prepare $formats_nav before any parameter munging
6257 my $formats_nav;
6258 if (!defined $parent) {
6259 # --root commitdiff
6260 $formats_nav .= '(initial)';
6261 } elsif (@$parents == 1) {
6262 # single parent commit
6263 $formats_nav .=
6264 '(parent: ' .
6265 $cgi->a({-href => href(action=>"commit",
6266 hash=>$parent)},
6267 esc_html(substr($parent, 0, 7))) .
6268 ')';
6269 } else {
6270 # merge commit
6271 $formats_nav .=
6272 '(merge: ' .
6273 join(' ', map {
6274 $cgi->a({-href => href(action=>"commit",
6275 hash=>$_)},
6276 esc_html(substr($_, 0, 7)));
6277 } @$parents ) .
6278 ')';
6279 }
6280 if (gitweb_check_feature('patches') && @$parents <= 1) {
6281 $formats_nav .= " | " .
6282 $cgi->a({-href => href(action=>"patch", -replay=>1)},
6283 "patch");
6284 }
6286 if (!defined $parent) {
6287 $parent = "--root";
6288 }
6289 my @difftree;
6290 open my $fd, "-|", git_cmd(), "diff-tree", '-r', "--no-commit-id",
6291 @diff_opts,
6292 (@$parents <= 1 ? $parent : '-c'),
6293 $hash, "--"
6294 or die_error(500, "Open git-diff-tree failed");
6295 @difftree = map { chomp; $_ } <$fd>;
6296 close $fd or die_error(404, "Reading git-diff-tree failed");
6298 # non-textual hash id's can be cached
6299 my $expires;
6300 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6301 $expires = "+1d";
6302 }
6303 my $refs = git_get_references();
6304 my $ref = format_ref_marker($refs, $co{'id'});
6306 git_header_html(undef, $expires);
6307 git_print_page_nav('commit', '',
6308 $hash, $co{'tree'}, $hash,
6309 $formats_nav);
6311 if (defined $co{'parent'}) {
6312 git_print_header_div('commitdiff', esc_html($co{'title'}) . $ref, $hash);
6313 } else {
6314 git_print_header_div('tree', esc_html($co{'title'}) . $ref, $co{'tree'}, $hash);
6315 }
6316 print "<div class=\"title_text\">\n" .
6317 "<table class=\"object_header\">\n";
6318 git_print_authorship_rows(\%co);
6319 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
6320 print "<tr>" .
6321 "<td>tree</td>" .
6322 "<td class=\"sha1\">" .
6323 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash),
6324 class => "list"}, $co{'tree'}) .
6325 "</td>" .
6326 "<td class=\"link\">" .
6327 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash)},
6328 "tree");
6329 my $snapshot_links = format_snapshot_links($hash);
6330 if (defined $snapshot_links) {
6331 print " | " . $snapshot_links;
6332 }
6333 print "</td>" .
6334 "</tr>\n";
6336 foreach my $par (@$parents) {
6337 print "<tr>" .
6338 "<td>parent</td>" .
6339 "<td class=\"sha1\">" .
6340 $cgi->a({-href => href(action=>"commit", hash=>$par),
6341 class => "list"}, $par) .
6342 "</td>" .
6343 "<td class=\"link\">" .
6344 $cgi->a({-href => href(action=>"commit", hash=>$par)}, "commit") .
6345 " | " .
6346 $cgi->a({-href => href(action=>"commitdiff", hash=>$hash, hash_parent=>$par)}, "diff") .
6347 "</td>" .
6348 "</tr>\n";
6349 }
6350 print "</table>".
6351 "</div>\n";
6353 print "<div class=\"page_body\">\n";
6354 git_print_log($co{'comment'});
6355 print "</div>\n";
6357 git_difftree_body(\@difftree, $hash, @$parents);
6359 git_footer_html();
6360 }
6362 sub git_object {
6363 # object is defined by:
6364 # - hash or hash_base alone
6365 # - hash_base and file_name
6366 my $type;
6368 # - hash or hash_base alone
6369 if ($hash || ($hash_base && !defined $file_name)) {
6370 my $object_id = $hash || $hash_base;
6372 open my $fd, "-|", quote_command(
6373 git_cmd(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
6374 or die_error(404, "Object does not exist");
6375 $type = <$fd>;
6376 chomp $type;
6377 close $fd
6378 or die_error(404, "Object does not exist");
6380 # - hash_base and file_name
6381 } elsif ($hash_base && defined $file_name) {
6382 $file_name =~ s,/+$,,;
6384 system(git_cmd(), "cat-file", '-e', $hash_base) == 0
6385 or die_error(404, "Base object does not exist");
6387 # here errors should not hapen
6388 open my $fd, "-|", git_cmd(), "ls-tree", $hash_base, "--", $file_name
6389 or die_error(500, "Open git-ls-tree failed");
6390 my $line = <$fd>;
6391 close $fd;
6393 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
6394 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
6395 die_error(404, "File or directory for given base does not exist");
6396 }
6397 $type = $2;
6398 $hash = $3;
6399 } else {
6400 die_error(400, "Not enough information to find object");
6401 }
6403 print $cgi->redirect(-uri => href(action=>$type, -full=>1,
6404 hash=>$hash, hash_base=>$hash_base,
6405 file_name=>$file_name),
6406 -status => '302 Found');
6407 }
6409 sub git_blobdiff {
6410 my $format = shift || 'html';
6412 my $fd;
6413 my @difftree;
6414 my %diffinfo;
6415 my $expires;
6417 # preparing $fd and %diffinfo for git_patchset_body
6418 # new style URI
6419 if (defined $hash_base && defined $hash_parent_base) {
6420 if (defined $file_name) {
6421 # read raw output
6422 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6423 $hash_parent_base, $hash_base,
6424 "--", (defined $file_parent ? $file_parent : ()), $file_name
6425 or die_error(500, "Open git-diff-tree failed");
6426 @difftree = map { chomp; $_ } <$fd>;
6427 close $fd
6428 or die_error(404, "Reading git-diff-tree failed");
6429 @difftree
6430 or die_error(404, "Blob diff not found");
6432 } elsif (defined $hash &&
6433 $hash =~ /[0-9a-fA-F]{40}/) {
6434 # try to find filename from $hash
6436 # read filtered raw output
6437 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6438 $hash_parent_base, $hash_base, "--"
6439 or die_error(500, "Open git-diff-tree failed");
6440 @difftree =
6441 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
6442 # $hash == to_id
6443 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
6444 map { chomp; $_ } <$fd>;
6445 close $fd
6446 or die_error(404, "Reading git-diff-tree failed");
6447 @difftree
6448 or die_error(404, "Blob diff not found");
6450 } else {
6451 die_error(400, "Missing one of the blob diff parameters");
6452 }
6454 if (@difftree > 1) {
6455 die_error(400, "Ambiguous blob diff specification");
6456 }
6458 %diffinfo = parse_difftree_raw_line($difftree[0]);
6459 $file_parent ||= $diffinfo{'from_file'} || $file_name;
6460 $file_name ||= $diffinfo{'to_file'};
6462 $hash_parent ||= $diffinfo{'from_id'};
6463 $hash ||= $diffinfo{'to_id'};
6465 # non-textual hash id's can be cached
6466 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
6467 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
6468 $expires = '+1d';
6469 }
6471 # open patch output
6472 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6473 '-p', ($format eq 'html' ? "--full-index" : ()),
6474 $hash_parent_base, $hash_base,
6475 "--", (defined $file_parent ? $file_parent : ()), $file_name
6476 or die_error(500, "Open git-diff-tree failed");
6477 }
6479 # old/legacy style URI -- not generated anymore since 1.4.3.
6480 if (!%diffinfo) {
6481 die_error('404 Not Found', "Missing one of the blob diff parameters")
6482 }
6484 # header
6485 if ($format eq 'html') {
6486 my $formats_nav =
6487 $cgi->a({-href => href(action=>"blobdiff_plain", -replay=>1)},
6488 "raw");
6489 git_header_html(undef, $expires);
6490 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
6491 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6492 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
6493 } else {
6494 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
6495 print "<div class=\"title\">".esc_html("$hash vs $hash_parent")."</div>\n";
6496 }
6497 if (defined $file_name) {
6498 git_print_page_path($file_name, "blob", $hash_base);
6499 } else {
6500 print "<div class=\"page_path\"></div>\n";
6501 }
6503 } elsif ($format eq 'plain') {
6504 print $cgi->header(
6505 -type => 'text/plain',
6506 -charset => 'utf-8',
6507 -expires => $expires,
6508 -content_disposition => 'inline; filename="' . "$file_name" . '.patch"');
6510 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6512 } else {
6513 die_error(400, "Unknown blobdiff format");
6514 }
6516 # patch
6517 if ($format eq 'html') {
6518 print "<div class=\"page_body\">\n";
6520 git_patchset_body($fd, [ \%diffinfo ], $hash_base, $hash_parent_base);
6521 close $fd;
6523 print "</div>\n"; # class="page_body"
6524 git_footer_html();
6526 } else {
6527 while (my $line = <$fd>) {
6528 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
6529 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
6531 print $line;
6533 last if $line =~ m!^\+\+\+!;
6534 }
6535 local $/ = undef;
6536 print <$fd>;
6537 close $fd;
6538 }
6539 }
6541 sub git_blobdiff_plain {
6542 git_blobdiff('plain');
6543 }
6545 sub git_commitdiff {
6546 my %params = @_;
6547 my $format = $params{-format} || 'html';
6549 my ($patch_max) = gitweb_get_feature('patches');
6550 if ($format eq 'patch') {
6551 die_error(403, "Patch view not allowed") unless $patch_max;
6552 }
6554 $hash ||= $hash_base || "HEAD";
6555 my %co = parse_commit($hash)
6556 or die_error(404, "Unknown commit object");
6558 # choose format for commitdiff for merge
6559 if (! defined $hash_parent && @{$co{'parents'}} > 1) {
6560 $hash_parent = '--cc';
6561 }
6562 # we need to prepare $formats_nav before almost any parameter munging
6563 my $formats_nav;
6564 if ($format eq 'html') {
6565 $formats_nav =
6566 $cgi->a({-href => href(action=>"commitdiff_plain", -replay=>1)},
6567 "raw");
6568 if ($patch_max && @{$co{'parents'}} <= 1) {
6569 $formats_nav .= " | " .
6570 $cgi->a({-href => href(action=>"patch", -replay=>1)},
6571 "patch");
6572 }
6574 if (defined $hash_parent &&
6575 $hash_parent ne '-c' && $hash_parent ne '--cc') {
6576 # commitdiff with two commits given
6577 my $hash_parent_short = $hash_parent;
6578 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
6579 $hash_parent_short = substr($hash_parent, 0, 7);
6580 }
6581 $formats_nav .=
6582 ' (from';
6583 for (my $i = 0; $i < @{$co{'parents'}}; $i++) {
6584 if ($co{'parents'}[$i] eq $hash_parent) {
6585 $formats_nav .= ' parent ' . ($i+1);
6586 last;
6587 }
6588 }
6589 $formats_nav .= ': ' .
6590 $cgi->a({-href => href(action=>"commitdiff",
6591 hash=>$hash_parent)},
6592 esc_html($hash_parent_short)) .
6593 ')';
6594 } elsif (!$co{'parent'}) {
6595 # --root commitdiff
6596 $formats_nav .= ' (initial)';
6597 } elsif (scalar @{$co{'parents'}} == 1) {
6598 # single parent commit
6599 $formats_nav .=
6600 ' (parent: ' .
6601 $cgi->a({-href => href(action=>"commitdiff",
6602 hash=>$co{'parent'})},
6603 esc_html(substr($co{'parent'}, 0, 7))) .
6604 ')';
6605 } else {
6606 # merge commit
6607 if ($hash_parent eq '--cc') {
6608 $formats_nav .= ' | ' .
6609 $cgi->a({-href => href(action=>"commitdiff",
6610 hash=>$hash, hash_parent=>'-c')},
6611 'combined');
6612 } else { # $hash_parent eq '-c'
6613 $formats_nav .= ' | ' .
6614 $cgi->a({-href => href(action=>"commitdiff",
6615 hash=>$hash, hash_parent=>'--cc')},
6616 'compact');
6617 }
6618 $formats_nav .=
6619 ' (merge: ' .
6620 join(' ', map {
6621 $cgi->a({-href => href(action=>"commitdiff",
6622 hash=>$_)},
6623 esc_html(substr($_, 0, 7)));
6624 } @{$co{'parents'}} ) .
6625 ')';
6626 }
6627 }
6629 my $hash_parent_param = $hash_parent;
6630 if (!defined $hash_parent_param) {
6631 # --cc for multiple parents, --root for parentless
6632 $hash_parent_param =
6633 @{$co{'parents'}} > 1 ? '--cc' : $co{'parent'} || '--root';
6634 }
6636 # read commitdiff
6637 my $fd;
6638 my @difftree;
6639 if ($format eq 'html') {
6640 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6641 "--no-commit-id", "--patch-with-raw", "--full-index",
6642 $hash_parent_param, $hash, "--"
6643 or die_error(500, "Open git-diff-tree failed");
6645 while (my $line = <$fd>) {
6646 chomp $line;
6647 # empty line ends raw part of diff-tree output
6648 last unless $line;
6649 push @difftree, scalar parse_difftree_raw_line($line);
6650 }
6652 } elsif ($format eq 'plain') {
6653 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
6654 '-p', $hash_parent_param, $hash, "--"
6655 or die_error(500, "Open git-diff-tree failed");
6656 } elsif ($format eq 'patch') {
6657 # For commit ranges, we limit the output to the number of
6658 # patches specified in the 'patches' feature.
6659 # For single commits, we limit the output to a single patch,
6660 # diverging from the git-format-patch default.
6661 my @commit_spec = ();
6662 if ($hash_parent) {
6663 if ($patch_max > 0) {
6664 push @commit_spec, "-$patch_max";
6665 }
6666 push @commit_spec, '-n', "$hash_parent..$hash";
6667 } else {
6668 if ($params{-single}) {
6669 push @commit_spec, '-1';
6670 } else {
6671 if ($patch_max > 0) {
6672 push @commit_spec, "-$patch_max";
6673 }
6674 push @commit_spec, "-n";
6675 }
6676 push @commit_spec, '--root', $hash;
6677 }
6678 open $fd, "-|", git_cmd(), "format-patch", @diff_opts,
6679 '--encoding=utf8', '--stdout', @commit_spec
6680 or die_error(500, "Open git-format-patch failed");
6681 } else {
6682 die_error(400, "Unknown commitdiff format");
6683 }
6685 # non-textual hash id's can be cached
6686 my $expires;
6687 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
6688 $expires = "+1d";
6689 }
6691 # write commit message
6692 if ($format eq 'html') {
6693 my $refs = git_get_references();
6694 my $ref = format_ref_marker($refs, $co{'id'});
6696 git_header_html(undef, $expires);
6697 git_print_page_nav('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
6698 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash);
6699 print "<div class=\"title_text\">\n" .
6700 "<table class=\"object_header\">\n";
6701 git_print_authorship_rows(\%co);
6702 print "</table>".
6703 "</div>\n";
6704 print "<div class=\"page_body\">\n";
6705 if (@{$co{'comment'}} > 1) {
6706 print "<div class=\"log\">\n";
6707 git_print_log($co{'comment'}, -final_empty_line=> 1, -remove_title => 1);
6708 print "</div>\n"; # class="log"
6709 }
6711 } elsif ($format eq 'plain') {
6712 my $refs = git_get_references("tags");
6713 my $tagname = git_get_rev_name_tags($hash);
6714 my $filename = basename($project) . "-$hash.patch";
6716 print $cgi->header(
6717 -type => 'text/plain',
6718 -charset => 'utf-8',
6719 -expires => $expires,
6720 -content_disposition => 'inline; filename="' . "$filename" . '"');
6721 my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
6722 print "From: " . to_utf8($co{'author'}) . "\n";
6723 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
6724 print "Subject: " . to_utf8($co{'title'}) . "\n";
6726 print "X-Git-Tag: $tagname\n" if $tagname;
6727 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
6729 foreach my $line (@{$co{'comment'}}) {
6730 print to_utf8($line) . "\n";
6731 }
6732 print "---\n\n";
6733 } elsif ($format eq 'patch') {
6734 my $filename = basename($project) . "-$hash.patch";
6736 print $cgi->header(
6737 -type => 'text/plain',
6738 -charset => 'utf-8',
6739 -expires => $expires,
6740 -content_disposition => 'inline; filename="' . "$filename" . '"');
6741 }
6743 # write patch
6744 if ($format eq 'html') {
6745 my $use_parents = !defined $hash_parent ||
6746 $hash_parent eq '-c' || $hash_parent eq '--cc';
6747 git_difftree_body(\@difftree, $hash,
6748 $use_parents ? @{$co{'parents'}} : $hash_parent);
6749 print "<br/>\n";
6751 git_patchset_body($fd, \@difftree, $hash,
6752 $use_parents ? @{$co{'parents'}} : $hash_parent);
6753 close $fd;
6754 print "</div>\n"; # class="page_body"
6755 git_footer_html();
6757 } elsif ($format eq 'plain') {
6758 local $/ = undef;
6759 print <$fd>;
6760 close $fd
6761 or print "Reading git-diff-tree failed\n";
6762 } elsif ($format eq 'patch') {
6763 local $/ = undef;
6764 print <$fd>;
6765 close $fd
6766 or print "Reading git-format-patch failed\n";
6767 }
6768 }
6770 sub git_commitdiff_plain {
6771 git_commitdiff(-format => 'plain');
6772 }
6774 # format-patch-style patches
6775 sub git_patch {
6776 git_commitdiff(-format => 'patch', -single => 1);
6777 }
6779 sub git_patches {
6780 git_commitdiff(-format => 'patch');
6781 }
6783 sub git_history {
6784 git_log_generic('history', \&git_history_body,
6785 $hash_base, $hash_parent_base,
6786 $file_name, $hash);
6787 }
6789 sub git_search {
6790 gitweb_check_feature('search') or die_error(403, "Search is disabled");
6791 if (!defined $searchtext) {
6792 die_error(400, "Text field is empty");
6793 }
6794 if (!defined $hash) {
6795 $hash = git_get_head_hash($project);
6796 }
6797 my %co = parse_commit($hash);
6798 if (!%co) {
6799 die_error(404, "Unknown commit object");
6800 }
6801 if (!defined $page) {
6802 $page = 0;
6803 }
6805 $searchtype ||= 'commit';
6806 if ($searchtype eq 'pickaxe') {
6807 # pickaxe may take all resources of your box and run for several minutes
6808 # with every query - so decide by yourself how public you make this feature
6809 gitweb_check_feature('pickaxe')
6810 or die_error(403, "Pickaxe is disabled");
6811 }
6812 if ($searchtype eq 'grep') {
6813 gitweb_check_feature('grep')
6814 or die_error(403, "Grep is disabled");
6815 }
6817 git_header_html();
6819 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
6820 my $greptype;
6821 if ($searchtype eq 'commit') {
6822 $greptype = "--grep=";
6823 } elsif ($searchtype eq 'author') {
6824 $greptype = "--author=";
6825 } elsif ($searchtype eq 'committer') {
6826 $greptype = "--committer=";
6827 }
6828 $greptype .= $searchtext;
6829 my @commitlist = parse_commits($hash, 101, (100 * $page), undef,
6830 $greptype, '--regexp-ignore-case',
6831 $search_use_regexp ? '--extended-regexp' : '--fixed-strings');
6833 my $paging_nav = '';
6834 if ($page > 0) {
6835 $paging_nav .=
6836 $cgi->a({-href => href(action=>"search", hash=>$hash,
6837 searchtext=>$searchtext,
6838 searchtype=>$searchtype)},
6839 "first");
6840 $paging_nav .= " ⋅ " .
6841 $cgi->a({-href => href(-replay=>1, page=>$page-1),
6842 -accesskey => "p", -title => "Alt-p"}, "prev");
6843 } else {
6844 $paging_nav .= "first";
6845 $paging_nav .= " ⋅ prev";
6846 }
6847 my $next_link = '';
6848 if ($#commitlist >= 100) {
6849 $next_link =
6850 $cgi->a({-href => href(-replay=>1, page=>$page+1),
6851 -accesskey => "n", -title => "Alt-n"}, "next");
6852 $paging_nav .= " ⋅ $next_link";
6853 } else {
6854 $paging_nav .= " ⋅ next";
6855 }
6857 git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
6858 git_print_header_div('commit', esc_html($co{'title'}), $hash);
6859 if ($page == 0 && !@commitlist) {
6860 print "<p>No match.</p>\n";
6861 } else {
6862 git_search_grep_body(\@commitlist, 0, 99, $next_link);
6863 }
6864 }
6866 if ($searchtype eq 'pickaxe') {
6867 git_print_page_nav('','', $hash,$co{'tree'},$hash);
6868 git_print_header_div('commit', esc_html($co{'title'}), $hash);
6870 print "<table class=\"pickaxe search\">\n";
6871 my $alternate = 1;
6872 local $/ = "\n";
6873 open my $fd, '-|', git_cmd(), '--no-pager', 'log', @diff_opts,
6874 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
6875 ($search_use_regexp ? '--pickaxe-regex' : ());
6876 undef %co;
6877 my @files;
6878 while (my $line = <$fd>) {
6879 chomp $line;
6880 next unless $line;
6882 my %set = parse_difftree_raw_line($line);
6883 if (defined $set{'commit'}) {
6884 # finish previous commit
6885 if (%co) {
6886 print "</td>\n" .
6887 "<td class=\"link\">" .
6888 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
6889 " | " .
6890 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
6891 print "</td>\n" .
6892 "</tr>\n";
6893 }
6895 if ($alternate) {
6896 print "<tr class=\"dark\">\n";
6897 } else {
6898 print "<tr class=\"light\">\n";
6899 }
6900 $alternate ^= 1;
6901 %co = parse_commit($set{'commit'});
6902 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
6903 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
6904 "<td><i>$author</i></td>\n" .
6905 "<td>" .
6906 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
6907 -class => "list subject"},
6908 chop_and_escape_str($co{'title'}, 50) . "<br/>");
6909 } elsif (defined $set{'to_id'}) {
6910 next if ($set{'to_id'} =~ m/^0{40}$/);
6912 print $cgi->a({-href => href(action=>"blob", hash_base=>$co{'id'},
6913 hash=>$set{'to_id'}, file_name=>$set{'to_file'}),
6914 -class => "list"},
6915 "<span class=\"match\">" . esc_path($set{'file'}) . "</span>") .
6916 "<br/>\n";
6917 }
6918 }
6919 close $fd;
6921 # finish last commit (warning: repetition!)
6922 if (%co) {
6923 print "</td>\n" .
6924 "<td class=\"link\">" .
6925 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
6926 " | " .
6927 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
6928 print "</td>\n" .
6929 "</tr>\n";
6930 }
6932 print "</table>\n";
6933 }
6935 if ($searchtype eq 'grep') {
6936 git_print_page_nav('','', $hash,$co{'tree'},$hash);
6937 git_print_header_div('commit', esc_html($co{'title'}), $hash);
6939 print "<table class=\"grep_search\">\n";
6940 my $alternate = 1;
6941 my $matches = 0;
6942 local $/ = "\n";
6943 open my $fd, "-|", git_cmd(), 'grep', '-n',
6944 $search_use_regexp ? ('-E', '-i') : '-F',
6945 $searchtext, $co{'tree'};
6946 my $lastfile = '';
6947 while (my $line = <$fd>) {
6948 chomp $line;
6949 my ($file, $lno, $ltext, $binary);
6950 last if ($matches++ > 1000);
6951 if ($line =~ /^Binary file (.+) matches$/) {
6952 $file = $1;
6953 $binary = 1;
6954 } else {
6955 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
6956 }
6957 if ($file ne $lastfile) {
6958 $lastfile and print "</td></tr>\n";
6959 if ($alternate++) {
6960 print "<tr class=\"dark\">\n";
6961 } else {
6962 print "<tr class=\"light\">\n";
6963 }
6964 print "<td class=\"list\">".
6965 $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
6966 file_name=>"$file"),
6967 -class => "list"}, esc_path($file));
6968 print "</td><td>\n";
6969 $lastfile = $file;
6970 }
6971 if ($binary) {
6972 print "<div class=\"binary\">Binary file</div>\n";
6973 } else {
6974 $ltext = untabify($ltext);
6975 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
6976 $ltext = esc_html($1, -nbsp=>1);
6977 $ltext .= '<span class="match">';
6978 $ltext .= esc_html($2, -nbsp=>1);
6979 $ltext .= '</span>';
6980 $ltext .= esc_html($3, -nbsp=>1);
6981 } else {
6982 $ltext = esc_html($ltext, -nbsp=>1);
6983 }
6984 print "<div class=\"pre\">" .
6985 $cgi->a({-href => href(action=>"blob", hash=>$co{'hash'},
6986 file_name=>"$file").'#l'.$lno,
6987 -class => "linenr"}, sprintf('%4i', $lno))
6988 . ' ' . $ltext . "</div>\n";
6989 }
6990 }
6991 if ($lastfile) {
6992 print "</td></tr>\n";
6993 if ($matches > 1000) {
6994 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
6995 }
6996 } else {
6997 print "<div class=\"diff nodifferences\">No matches found</div>\n";
6998 }
6999 close $fd;
7001 print "</table>\n";
7002 }
7003 git_footer_html();
7004 }
7006 sub git_search_help {
7007 git_header_html();
7008 git_print_page_nav('','', $hash,$hash,$hash);
7009 print <<EOT;
7010 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
7011 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
7012 the pattern entered is recognized as the POSIX extended
7013 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
7014 insensitive).</p>
7015 <dl>
7016 <dt><b>commit</b></dt>
7017 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
7018 EOT
7019 my $have_grep = gitweb_check_feature('grep');
7020 if ($have_grep) {
7021 print <<EOT;
7022 <dt><b>grep</b></dt>
7023 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
7024 a different one) are searched for the given pattern. On large trees, this search can take
7025 a while and put some strain on the server, so please use it with some consideration. Note that
7026 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
7027 case-sensitive.</dd>
7028 EOT
7029 }
7030 print <<EOT;
7031 <dt><b>author</b></dt>
7032 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
7033 <dt><b>committer</b></dt>
7034 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
7035 EOT
7036 my $have_pickaxe = gitweb_check_feature('pickaxe');
7037 if ($have_pickaxe) {
7038 print <<EOT;
7039 <dt><b>pickaxe</b></dt>
7040 <dd>All commits that caused the string to appear or disappear from any file (changes that
7041 added, removed or "modified" the string) will be listed. This search can take a while and
7042 takes a lot of strain on the server, so please use it wisely. Note that since you may be
7043 interested even in changes just changing the case as well, this search is case sensitive.</dd>
7044 EOT
7045 }
7046 print "</dl>\n";
7047 git_footer_html();
7048 }
7050 sub git_shortlog {
7051 git_log_generic('shortlog', \&git_shortlog_body,
7052 $hash, $hash_parent);
7053 }
7055 ## ......................................................................
7056 ## feeds (RSS, Atom; OPML)
7058 sub git_feed {
7059 my $format = shift || 'atom';
7060 my $have_blame = gitweb_check_feature('blame');
7062 # Atom: http://www.atomenabled.org/developers/syndication/
7063 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
7064 if ($format ne 'rss' && $format ne 'atom') {
7065 die_error(400, "Unknown web feed format");
7066 }
7068 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
7069 my $head = $hash || 'HEAD';
7070 my @commitlist = parse_commits($head, 150, 0, $file_name);
7072 my %latest_commit;
7073 my %latest_date;
7074 my $content_type = "application/$format+xml";
7075 if (defined $cgi->http('HTTP_ACCEPT') &&
7076 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
7077 # browser (feed reader) prefers text/xml
7078 $content_type = 'text/xml';
7079 }
7080 if (defined($commitlist[0])) {
7081 %latest_commit = %{$commitlist[0]};
7082 my $latest_epoch = $latest_commit{'committer_epoch'};
7083 %latest_date = parse_date($latest_epoch, $latest_commit{'comitter_tz'});
7084 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
7085 if (defined $if_modified) {
7086 my $since;
7087 if (eval { require HTTP::Date; 1; }) {
7088 $since = HTTP::Date::str2time($if_modified);
7089 } elsif (eval { require Time::ParseDate; 1; }) {
7090 $since = Time::ParseDate::parsedate($if_modified, GMT => 1);
7091 }
7092 if (defined $since && $latest_epoch <= $since) {
7093 print $cgi->header(
7094 -type => $content_type,
7095 -charset => 'utf-8',
7096 -last_modified => $latest_date{'rfc2822'},
7097 -status => '304 Not Modified');
7098 return;
7099 }
7100 }
7101 print $cgi->header(
7102 -type => $content_type,
7103 -charset => 'utf-8',
7104 -last_modified => $latest_date{'rfc2822'});
7105 } else {
7106 print $cgi->header(
7107 -type => $content_type,
7108 -charset => 'utf-8');
7109 }
7111 # Optimization: skip generating the body if client asks only
7112 # for Last-Modified date.
7113 return if ($cgi->request_method() eq 'HEAD');
7115 # header variables
7116 my $title = "$site_name - $project/$action";
7117 my $feed_type = 'log';
7118 if (defined $hash) {
7119 $title .= " - '$hash'";
7120 $feed_type = 'branch log';
7121 if (defined $file_name) {
7122 $title .= " :: $file_name";
7123 $feed_type = 'history';
7124 }
7125 } elsif (defined $file_name) {
7126 $title .= " - $file_name";
7127 $feed_type = 'history';
7128 }
7129 $title .= " $feed_type";
7130 my $descr = git_get_project_description($project);
7131 if (defined $descr) {
7132 $descr = esc_html($descr);
7133 } else {
7134 $descr = "$project " .
7135 ($format eq 'rss' ? 'RSS' : 'Atom') .
7136 " feed";
7137 }
7138 my $owner = git_get_project_owner($project);
7139 $owner = esc_html($owner);
7141 #header
7142 my $alt_url;
7143 if (defined $file_name) {
7144 $alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
7145 } elsif (defined $hash) {
7146 $alt_url = href(-full=>1, action=>"log", hash=>$hash);
7147 } else {
7148 $alt_url = href(-full=>1, action=>"summary");
7149 }
7150 print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
7151 if ($format eq 'rss') {
7152 print <<XML;
7153 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
7154 <channel>
7155 XML
7156 print "<title>$title</title>\n" .
7157 "<link>$alt_url</link>\n" .
7158 "<description>$descr</description>\n" .
7159 "<language>en</language>\n" .
7160 # project owner is responsible for 'editorial' content
7161 "<managingEditor>$owner</managingEditor>\n";
7162 if (defined $logo || defined $favicon) {
7163 # prefer the logo to the favicon, since RSS
7164 # doesn't allow both
7165 my $img = esc_url($logo || $favicon);
7166 print "<image>\n" .
7167 "<url>$img</url>\n" .
7168 "<title>$title</title>\n" .
7169 "<link>$alt_url</link>\n" .
7170 "</image>\n";
7171 }
7172 if (%latest_date) {
7173 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
7174 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
7175 }
7176 print "<generator>gitweb v.$version/$git_version</generator>\n";
7177 } elsif ($format eq 'atom') {
7178 print <<XML;
7179 <feed xmlns="http://www.w3.org/2005/Atom">
7180 XML
7181 print "<title>$title</title>\n" .
7182 "<subtitle>$descr</subtitle>\n" .
7183 '<link rel="alternate" type="text/html" href="' .
7184 $alt_url . '" />' . "\n" .
7185 '<link rel="self" type="' . $content_type . '" href="' .
7186 $cgi->self_url() . '" />' . "\n" .
7187 "<id>" . href(-full=>1) . "</id>\n" .
7188 # use project owner for feed author
7189 "<author><name>$owner</name></author>\n";
7190 if (defined $favicon) {
7191 print "<icon>" . esc_url($favicon) . "</icon>\n";
7192 }
7193 if (defined $logo) {
7194 # not twice as wide as tall: 72 x 27 pixels
7195 print "<logo>" . esc_url($logo) . "</logo>\n";
7196 }
7197 if (! %latest_date) {
7198 # dummy date to keep the feed valid until commits trickle in:
7199 print "<updated>1970-01-01T00:00:00Z</updated>\n";
7200 } else {
7201 print "<updated>$latest_date{'iso-8601'}</updated>\n";
7202 }
7203 print "<generator version='$version/$git_version'>gitweb</generator>\n";
7204 }
7206 # contents
7207 for (my $i = 0; $i <= $#commitlist; $i++) {
7208 my %co = %{$commitlist[$i]};
7209 my $commit = $co{'id'};
7210 # we read 150, we always show 30 and the ones more recent than 48 hours
7211 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
7212 last;
7213 }
7214 my %cd = parse_date($co{'author_epoch'}, $co{'author_tz'});
7216 # get list of changed files
7217 open my $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
7218 $co{'parent'} || "--root",
7219 $co{'id'}, "--", (defined $file_name ? $file_name : ())
7220 or next;
7221 my @difftree = map { chomp; $_ } <$fd>;
7222 close $fd
7223 or next;
7225 # print element (entry, item)
7226 my $co_url = href(-full=>1, action=>"commitdiff", hash=>$commit);
7227 if ($format eq 'rss') {
7228 print "<item>\n" .
7229 "<title>" . esc_html($co{'title'}) . "</title>\n" .
7230 "<author>" . esc_html($co{'author'}) . "</author>\n" .
7231 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
7232 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
7233 "<link>$co_url</link>\n" .
7234 "<description>" . esc_html($co{'title'}) . "</description>\n" .
7235 "<content:encoded>" .
7236 "<![CDATA[\n";
7237 } elsif ($format eq 'atom') {
7238 print "<entry>\n" .
7239 "<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
7240 "<updated>$cd{'iso-8601'}</updated>\n" .
7241 "<author>\n" .
7242 " <name>" . esc_html($co{'author_name'}) . "</name>\n";
7243 if ($co{'author_email'}) {
7244 print " <email>" . esc_html($co{'author_email'}) . "</email>\n";
7245 }
7246 print "</author>\n" .
7247 # use committer for contributor
7248 "<contributor>\n" .
7249 " <name>" . esc_html($co{'committer_name'}) . "</name>\n";
7250 if ($co{'committer_email'}) {
7251 print " <email>" . esc_html($co{'committer_email'}) . "</email>\n";
7252 }
7253 print "</contributor>\n" .
7254 "<published>$cd{'iso-8601'}</published>\n" .
7255 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
7256 "<id>$co_url</id>\n" .
7257 "<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
7258 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
7259 }
7260 my $comment = $co{'comment'};
7261 print "<pre>\n";
7262 foreach my $line (@$comment) {
7263 $line = esc_html($line);
7264 print "$line\n";
7265 }
7266 print "</pre><ul>\n";
7267 foreach my $difftree_line (@difftree) {
7268 my %difftree = parse_difftree_raw_line($difftree_line);
7269 next if !$difftree{'from_id'};
7271 my $file = $difftree{'file'} || $difftree{'to_file'};
7273 print "<li>" .
7274 "[" .
7275 $cgi->a({-href => href(-full=>1, action=>"blobdiff",
7276 hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
7277 hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
7278 file_name=>$file, file_parent=>$difftree{'from_file'}),
7279 -title => "diff"}, 'D');
7280 if ($have_blame) {
7281 print $cgi->a({-href => href(-full=>1, action=>"blame",
7282 file_name=>$file, hash_base=>$commit),
7283 -title => "blame"}, 'B');
7284 }
7285 # if this is not a feed of a file history
7286 if (!defined $file_name || $file_name ne $file) {
7287 print $cgi->a({-href => href(-full=>1, action=>"history",
7288 file_name=>$file, hash=>$commit),
7289 -title => "history"}, 'H');
7290 }
7291 $file = esc_path($file);
7292 print "] ".
7293 "$file</li>\n";
7294 }
7295 if ($format eq 'rss') {
7296 print "</ul>]]>\n" .
7297 "</content:encoded>\n" .
7298 "</item>\n";
7299 } elsif ($format eq 'atom') {
7300 print "</ul>\n</div>\n" .
7301 "</content>\n" .
7302 "</entry>\n";
7303 }
7304 }
7306 # end of feed
7307 if ($format eq 'rss') {
7308 print "</channel>\n</rss>\n";
7309 } elsif ($format eq 'atom') {
7310 print "</feed>\n";
7311 }
7312 }
7314 sub git_rss {
7315 git_feed('rss');
7316 }
7318 sub git_atom {
7319 git_feed('atom');
7320 }
7322 sub git_opml {
7323 my @list = git_get_projects_list();
7325 print $cgi->header(
7326 -type => 'text/xml',
7327 -charset => 'utf-8',
7328 -content_disposition => 'inline; filename="opml.xml"');
7330 print <<XML;
7331 <?xml version="1.0" encoding="utf-8"?>
7332 <opml version="1.0">
7333 <head>
7334 <title>$site_name OPML Export</title>
7335 </head>
7336 <body>
7337 <outline text="git RSS feeds">
7338 XML
7340 foreach my $pr (@list) {
7341 my %proj = %$pr;
7342 my $head = git_get_head_hash($proj{'path'});
7343 if (!defined $head) {
7344 next;
7345 }
7346 $git_dir = "$projectroot/$proj{'path'}";
7347 my %co = parse_commit($head);
7348 if (!%co) {
7349 next;
7350 }
7352 my $path = esc_html(chop_str($proj{'path'}, 25, 5));
7353 my $rss = href('project' => $proj{'path'}, 'action' => 'rss', -full => 1);
7354 my $html = href('project' => $proj{'path'}, 'action' => 'summary', -full => 1);
7355 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";
7356 }
7357 print <<XML;
7358 </outline>
7359 </body>
7360 </opml>
7361 XML
7362 }