3 # gitweb - simple web interface to track changes in git repositories
5 # (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
6 # (C) 2005, Christian Gierke
8 # This program is licensed under the GPLv2
12 use CGI
qw(:standard :escapeHTML -nosticky);
13 use CGI
::Util
qw(unescape);
14 use CGI
::Carp
qw(fatalsToBrowser);
18 use File
::Basename
qw(basename);
19 binmode STDOUT
, ':utf8';
22 CGI
->compile() if $ENV{'MOD_PERL'};
26 our $version = "++GIT_VERSION++";
27 our $my_url = $cgi->url();
28 our $my_uri = $cgi->url(-absolute
=> 1);
30 # Base URL for relative URLs in gitweb ($logo, $favicon, ...),
31 # needed and used only for URLs with nonempty PATH_INFO
32 our $base_url = $my_url;
34 # When the script is used as DirectoryIndex, the URL does not contain the name
35 # of the script file itself, and $cgi->url() fails to strip PATH_INFO, so we
36 # have to do it ourselves. We make $path_info global because it's also used
39 # Another issue with the script being the DirectoryIndex is that the resulting
40 # $my_url data is not the full script URL: this is good, because we want
41 # generated links to keep implying the script name if it wasn't explicitly
42 # indicated in the URL we're handling, but it means that $my_url cannot be used
44 # Therefore, if we needed to strip PATH_INFO, then we know that we have
45 # to build the base URL ourselves:
46 our $path_info = $ENV{"PATH_INFO"};
48 if ($my_url =~ s
,\Q
$path_info\E
$,, &&
49 $my_uri =~ s
,\Q
$path_info\E
$,, &&
50 defined $ENV{'SCRIPT_NAME'}) {
51 $base_url = $cgi->url(-base
=> 1) . $ENV{'SCRIPT_NAME'};
55 # core git executable to use
56 # this can just be "git" if your webserver has a sensible PATH
57 our $GIT = "++GIT_BINDIR++/git";
59 # absolute fs-path which will be prepended to the project path
60 #our $projectroot = "/pub/scm";
61 our $projectroot = "++GITWEB_PROJECTROOT++";
63 # fs traversing limit for getting project list
64 # the number is relative to the projectroot
65 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
67 # target of the home link on top of all pages
68 our $home_link = $my_uri || "/";
70 # string of the home link on top of all pages
71 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
73 # name of your site or organization to appear in page titles
74 # replace this with something more descriptive for clearer bookmarks
75 our $site_name = "++GITWEB_SITENAME++"
76 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
78 # filename of html text to include at top of each page
79 our $site_header = "++GITWEB_SITE_HEADER++";
80 # html text to include at home page
81 our $home_text = "++GITWEB_HOMETEXT++";
82 # filename of html text to include at bottom of each page
83 our $site_footer = "++GITWEB_SITE_FOOTER++";
86 our @stylesheets = ("++GITWEB_CSS++");
87 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
88 our $stylesheet = undef;
89 # URI of GIT logo (72x27 size)
90 our $logo = "++GITWEB_LOGO++";
91 # URI of GIT favicon, assumed to be image/png type
92 our $favicon = "++GITWEB_FAVICON++";
94 # URI and label (title) of GIT logo link
95 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
96 #our $logo_label = "git documentation";
97 our $logo_url = "http://git.or.cz/";
98 our $logo_label = "git homepage";
100 # source of projects list
101 our $projects_list = "++GITWEB_LIST++";
103 # the width (in characters) of the projects list "Description" column
104 our $projects_list_description_width = 25;
106 # default order of projects list
107 # valid values are none, project, descr, owner, and age
108 our $default_projects_order = "project";
110 # show repository only if this file exists
111 # (only effective if this variable evaluates to true)
112 our $export_ok = "++GITWEB_EXPORT_OK++";
114 # show repository only if this subroutine returns true
115 # when given the path to the project, for example:
116 # sub { return -e "$_[0]/git-daemon-export-ok"; }
117 our $export_auth_hook = undef;
119 # only allow viewing of repositories also shown on the overview page
120 our $strict_export = "++GITWEB_STRICT_EXPORT++";
122 # list of git base URLs used for URL to where fetch project from,
123 # i.e. full URL is "$git_base_url/$project"
124 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
126 # default blob_plain mimetype and default charset for text/plain blob
127 our $default_blob_plain_mimetype = 'text/plain';
128 our $default_text_plain_charset = undef;
130 # file to use for guessing MIME types before trying /etc/mime.types
131 # (relative to the current git repository)
132 our $mimetypes_file = undef;
134 # assume this charset if line contains non-UTF-8 characters;
135 # it should be valid encoding (see Encoding::Supported(3pm) for list),
136 # for which encoding all byte sequences are valid, for example
137 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
138 # could be even 'utf-8' for the old behavior)
139 our $fallback_encoding = 'latin1';
141 # rename detection options for git-diff and git-diff-tree
142 # - default is '-M', with the cost proportional to
143 # (number of removed files) * (number of new files).
144 # - more costly is '-C' (which implies '-M'), with the cost proportional to
145 # (number of changed files + number of removed files) * (number of new files)
146 # - even more costly is '-C', '--find-copies-harder' with cost
147 # (number of files in the original tree) * (number of new files)
148 # - one might want to include '-B' option, e.g. '-B', '-M'
149 our @diff_opts = ('-M'); # taken from git_commit
151 # Disables features that would allow repository owners to inject script into
153 our $prevent_xss = 0;
155 # information about snapshot formats that gitweb is capable of serving
156 our %known_snapshot_formats = (
158 # 'display' => display name,
159 # 'type' => mime type,
160 # 'suffix' => filename suffix,
161 # 'format' => --format for git-archive,
162 # 'compressor' => [compressor command and arguments]
163 # (array reference, optional)}
166 'display' => 'tar.gz',
167 'type' => 'application/x-gzip',
168 'suffix' => '.tar.gz',
170 'compressor' => ['gzip']},
173 'display' => 'tar.bz2',
174 'type' => 'application/x-bzip2',
175 'suffix' => '.tar.bz2',
177 'compressor' => ['bzip2']},
181 'type' => 'application/x-zip',
186 # Aliases so we understand old gitweb.snapshot values in repository
188 our %known_snapshot_format_aliases = (
192 # backward compatibility: legacy gitweb config support
193 'x-gzip' => undef, 'gz' => undef,
194 'x-bzip2' => undef, 'bz2' => undef,
195 'x-zip' => undef, '' => undef,
198 # You define site-wide feature defaults here; override them with
199 # $GITWEB_CONFIG as necessary.
202 # 'sub' => feature-sub (subroutine),
203 # 'override' => allow-override (boolean),
204 # 'default' => [ default options...] (array reference)}
206 # if feature is overridable (it means that allow-override has true value),
207 # then feature-sub will be called with default options as parameters;
208 # return value of feature-sub indicates if to enable specified feature
210 # if there is no 'sub' key (no feature-sub), then feature cannot be
213 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
214 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
217 # Enable the 'blame' blob view, showing the last commit that modified
218 # each line in the file. This can be very CPU-intensive.
220 # To enable system wide have in $GITWEB_CONFIG
221 # $feature{'blame'}{'default'} = [1];
222 # To have project specific config enable override in $GITWEB_CONFIG
223 # $feature{'blame'}{'override'} = 1;
224 # and in project config gitweb.blame = 0|1;
226 'sub' => sub { feature_bool
('blame', @_) },
230 # Enable the 'snapshot' link, providing a compressed archive of any
231 # tree. This can potentially generate high traffic if you have large
234 # Value is a list of formats defined in %known_snapshot_formats that
236 # To disable system wide have in $GITWEB_CONFIG
237 # $feature{'snapshot'}{'default'} = [];
238 # To have project specific config enable override in $GITWEB_CONFIG
239 # $feature{'snapshot'}{'override'} = 1;
240 # and in project config, a comma-separated list of formats or "none"
241 # to disable. Example: gitweb.snapshot = tbz2,zip;
243 'sub' => \
&feature_snapshot
,
245 'default' => ['tgz']},
247 # Enable text search, which will list the commits which match author,
248 # committer or commit text to a given string. Enabled by default.
249 # Project specific override is not supported.
254 # Enable grep search, which will list the files in currently selected
255 # tree containing the given string. Enabled by default. This can be
256 # potentially CPU-intensive, of course.
258 # To enable system wide have in $GITWEB_CONFIG
259 # $feature{'grep'}{'default'} = [1];
260 # To have project specific config enable override in $GITWEB_CONFIG
261 # $feature{'grep'}{'override'} = 1;
262 # and in project config gitweb.grep = 0|1;
264 'sub' => sub { feature_bool
('grep', @_) },
268 # Enable the pickaxe search, which will list the commits that modified
269 # a given string in a file. This can be practical and quite faster
270 # alternative to 'blame', but still potentially CPU-intensive.
272 # To enable system wide have in $GITWEB_CONFIG
273 # $feature{'pickaxe'}{'default'} = [1];
274 # To have project specific config enable override in $GITWEB_CONFIG
275 # $feature{'pickaxe'}{'override'} = 1;
276 # and in project config gitweb.pickaxe = 0|1;
278 'sub' => sub { feature_bool
('pickaxe', @_) },
282 # Make gitweb use an alternative format of the URLs which can be
283 # more readable and natural-looking: project name is embedded
284 # directly in the path and the query string contains other
285 # auxiliary information. All gitweb installations recognize
286 # URL in either format; this configures in which formats gitweb
289 # To enable system wide have in $GITWEB_CONFIG
290 # $feature{'pathinfo'}{'default'} = [1];
291 # Project specific override is not supported.
293 # Note that you will need to change the default location of CSS,
294 # favicon, logo and possibly other files to an absolute URL. Also,
295 # if gitweb.cgi serves as your indexfile, you will need to force
296 # $my_uri to contain the script name in your $GITWEB_CONFIG.
301 # Make gitweb consider projects in project root subdirectories
302 # to be forks of existing projects. Given project $projname.git,
303 # projects matching $projname/*.git will not be shown in the main
304 # projects list, instead a '+' mark will be added to $projname
305 # there and a 'forks' view will be enabled for the project, listing
306 # all the forks. If project list is taken from a file, forks have
307 # to be listed after the main project.
309 # To enable system wide have in $GITWEB_CONFIG
310 # $feature{'forks'}{'default'} = [1];
311 # Project specific override is not supported.
316 # Insert custom links to the action bar of all project pages.
317 # This enables you mainly to link to third-party scripts integrating
318 # into gitweb; e.g. git-browser for graphical history representation
319 # or custom web-based repository administration interface.
321 # The 'default' value consists of a list of triplets in the form
322 # (label, link, position) where position is the label after which
323 # to insert the link and link is a format string where %n expands
324 # to the project name, %f to the project path within the filesystem,
325 # %h to the current hash (h gitweb parameter) and %b to the current
326 # hash base (hb gitweb parameter); %% expands to %.
328 # To enable system wide have in $GITWEB_CONFIG e.g.
329 # $feature{'actions'}{'default'} = [('graphiclog',
330 # '/git-browser/by-commit.html?r=%n', 'summary')];
331 # Project specific override is not supported.
336 # Allow gitweb scan project content tags described in ctags/
337 # of project repository, and display the popular Web 2.0-ish
338 # "tag cloud" near the project list. Note that this is something
339 # COMPLETELY different from the normal Git tags.
341 # gitweb by itself can show existing tags, but it does not handle
342 # tagging itself; you need an external application for that.
343 # For an example script, check Girocco's cgi/tagproj.cgi.
344 # You may want to install the HTML::TagCloud Perl module to get
345 # a pretty tag cloud instead of just a list of tags.
347 # To enable system wide have in $GITWEB_CONFIG
348 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
349 # Project specific override is not supported.
354 # The maximum number of patches in a patchset generated in patch
355 # view. Set this to 0 or undef to disable patch view, or to a
356 # negative number to remove any limit.
358 # To disable system wide have in $GITWEB_CONFIG
359 # $feature{'patches'}{'default'} = [0];
360 # To have project specific config enable override in $GITWEB_CONFIG
361 # $feature{'patches'}{'override'} = 1;
362 # and in project config gitweb.patches = 0|n;
363 # where n is the maximum number of patches allowed in a patchset.
365 'sub' => \
&feature_patches
,
370 sub gitweb_get_feature
{
372 return unless exists $feature{$name};
373 my ($sub, $override, @defaults) = (
374 $feature{$name}{'sub'},
375 $feature{$name}{'override'},
376 @
{$feature{$name}{'default'}});
377 if (!$override) { return @defaults; }
379 warn "feature $name is not overrideable";
382 return $sub->(@defaults);
385 # A wrapper to check if a given feature is enabled.
386 # With this, you can say
388 # my $bool_feat = gitweb_check_feature('bool_feat');
389 # gitweb_check_feature('bool_feat') or somecode;
393 # my ($bool_feat) = gitweb_get_feature('bool_feat');
394 # (gitweb_get_feature('bool_feat'))[0] or somecode;
396 sub gitweb_check_feature
{
397 return (gitweb_get_feature
(@_))[0];
403 my ($val) = git_get_project_config
($key, '--bool');
407 } elsif ($val eq 'true') {
409 } elsif ($val eq 'false') {
414 sub feature_snapshot
{
417 my ($val) = git_get_project_config
('snapshot');
420 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
426 sub feature_patches
{
427 my @val = (git_get_project_config
('patches', '--int'));
436 # checking HEAD file with -e is fragile if the repository was
437 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
439 sub check_head_link
{
441 my $headfile = "$dir/HEAD";
442 return ((-e
$headfile) ||
443 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
446 sub check_export_ok
{
448 return (check_head_link
($dir) &&
449 (!$export_ok || -e
"$dir/$export_ok") &&
450 (!$export_auth_hook || $export_auth_hook->($dir)));
453 # process alternate names for backward compatibility
454 # filter out unsupported (unknown) snapshot formats
455 sub filter_snapshot_fmts
{
459 exists $known_snapshot_format_aliases{$_} ?
460 $known_snapshot_format_aliases{$_} : $_} @fmts;
462 exists $known_snapshot_formats{$_} } @fmts;
465 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
466 if (-e
$GITWEB_CONFIG) {
469 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
470 do $GITWEB_CONFIG_SYSTEM if -e
$GITWEB_CONFIG_SYSTEM;
473 # version of the core git binary
474 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
476 $projects_list ||= $projectroot;
478 # ======================================================================
479 # input validation and dispatch
481 # input parameters can be collected from a variety of sources (presently, CGI
482 # and PATH_INFO), so we define an %input_params hash that collects them all
483 # together during validation: this allows subsequent uses (e.g. href()) to be
484 # agnostic of the parameter origin
486 our %input_params = ();
488 # input parameters are stored with the long parameter name as key. This will
489 # also be used in the href subroutine to convert parameters to their CGI
490 # equivalent, and since the href() usage is the most frequent one, we store
491 # the name -> CGI key mapping here, instead of the reverse.
493 # XXX: Warning: If you touch this, check the search form for updating,
496 our @cgi_param_mapping = (
504 hash_parent_base
=> "hpb",
509 snapshot_format
=> "sf",
510 extra_options
=> "opt",
511 search_use_regexp
=> "sr",
513 our %cgi_param_mapping = @cgi_param_mapping;
515 # we will also need to know the possible actions, for validation
517 "blame" => \
&git_blame
,
518 "blobdiff" => \
&git_blobdiff
,
519 "blobdiff_plain" => \
&git_blobdiff_plain
,
520 "blob" => \
&git_blob
,
521 "blob_plain" => \
&git_blob_plain
,
522 "commitdiff" => \
&git_commitdiff
,
523 "commitdiff_plain" => \
&git_commitdiff_plain
,
524 "commit" => \
&git_commit
,
525 "forks" => \
&git_forks
,
526 "heads" => \
&git_heads
,
527 "history" => \
&git_history
,
529 "patch" => \
&git_patch
,
530 "patches" => \
&git_patches
,
532 "atom" => \
&git_atom
,
533 "search" => \
&git_search
,
534 "search_help" => \
&git_search_help
,
535 "shortlog" => \
&git_shortlog
,
536 "summary" => \
&git_summary
,
538 "tags" => \
&git_tags
,
539 "tree" => \
&git_tree
,
540 "snapshot" => \
&git_snapshot
,
541 "object" => \
&git_object
,
542 # those below don't need $project
543 "opml" => \
&git_opml
,
544 "project_list" => \
&git_project_list
,
545 "project_index" => \
&git_project_index
,
548 # finally, we have the hash of allowed extra_options for the commands that
550 our %allowed_options = (
551 "--no-merges" => [ qw(rss atom log shortlog history) ],
554 # fill %input_params with the CGI parameters. All values except for 'opt'
555 # should be single values, but opt can be an array. We should probably
556 # build an array of parameters that can be multi-valued, but since for the time
557 # being it's only this one, we just single it out
558 while (my ($name, $symbol) = each %cgi_param_mapping) {
559 if ($symbol eq 'opt') {
560 $input_params{$name} = [ $cgi->param($symbol) ];
562 $input_params{$name} = $cgi->param($symbol);
566 # now read PATH_INFO and update the parameter list for missing parameters
567 sub evaluate_path_info
{
568 return if defined $input_params{'project'};
569 return if !$path_info;
570 $path_info =~ s
,^/+,,;
571 return if !$path_info;
573 # find which part of PATH_INFO is project
574 my $project = $path_info;
576 while ($project && !check_head_link
("$projectroot/$project")) {
577 $project =~ s
,/*[^/]*$,,;
579 return unless $project;
580 $input_params{'project'} = $project;
582 # do not change any parameters if an action is given using the query string
583 return if $input_params{'action'};
584 $path_info =~ s
,^\Q
$project\E
/*,,;
586 # next, check if we have an action
587 my $action = $path_info;
589 if (exists $actions{$action}) {
590 $path_info =~ s
,^$action/*,,;
591 $input_params{'action'} = $action;
594 # list of actions that want hash_base instead of hash, but can have no
595 # pathname (f) parameter
602 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
603 my ($parentrefname, $parentpathname, $refname, $pathname) =
604 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?(.+?)(?::(.+))?$/);
606 # first, analyze the 'current' part
607 if (defined $pathname) {
608 # we got "branch:filename" or "branch:dir/"
609 # we could use git_get_type(branch:pathname), but:
610 # - it needs $git_dir
611 # - it does a git() call
612 # - the convention of terminating directories with a slash
613 # makes it superfluous
614 # - embedding the action in the PATH_INFO would make it even
616 $pathname =~ s
,^/+,,;
617 if (!$pathname || substr($pathname, -1) eq "/") {
618 $input_params{'action'} ||= "tree";
621 # the default action depends on whether we had parent info
623 if ($parentrefname) {
624 $input_params{'action'} ||= "blobdiff_plain";
626 $input_params{'action'} ||= "blob_plain";
629 $input_params{'hash_base'} ||= $refname;
630 $input_params{'file_name'} ||= $pathname;
631 } elsif (defined $refname) {
632 # we got "branch". In this case we have to choose if we have to
633 # set hash or hash_base.
635 # Most of the actions without a pathname only want hash to be
636 # set, except for the ones specified in @wants_base that want
637 # hash_base instead. It should also be noted that hand-crafted
638 # links having 'history' as an action and no pathname or hash
639 # set will fail, but that happens regardless of PATH_INFO.
640 $input_params{'action'} ||= "shortlog";
641 if (grep { $_ eq $input_params{'action'} } @wants_base) {
642 $input_params{'hash_base'} ||= $refname;
644 $input_params{'hash'} ||= $refname;
648 # next, handle the 'parent' part, if present
649 if (defined $parentrefname) {
650 # a missing pathspec defaults to the 'current' filename, allowing e.g.
651 # someproject/blobdiff/oldrev..newrev:/filename
652 if ($parentpathname) {
653 $parentpathname =~ s
,^/+,,;
654 $parentpathname =~ s
,/$,,;
655 $input_params{'file_parent'} ||= $parentpathname;
657 $input_params{'file_parent'} ||= $input_params{'file_name'};
659 # we assume that hash_parent_base is wanted if a path was specified,
660 # or if the action wants hash_base instead of hash
661 if (defined $input_params{'file_parent'} ||
662 grep { $_ eq $input_params{'action'} } @wants_base) {
663 $input_params{'hash_parent_base'} ||= $parentrefname;
665 $input_params{'hash_parent'} ||= $parentrefname;
669 # for the snapshot action, we allow URLs in the form
670 # $project/snapshot/$hash.ext
671 # where .ext determines the snapshot and gets removed from the
672 # passed $refname to provide the $hash.
674 # To be able to tell that $refname includes the format extension, we
675 # require the following two conditions to be satisfied:
676 # - the hash input parameter MUST have been set from the $refname part
677 # of the URL (i.e. they must be equal)
678 # - the snapshot format MUST NOT have been defined already (e.g. from
680 # It's also useless to try any matching unless $refname has a dot,
681 # so we check for that too
682 if (defined $input_params{'action'} &&
683 $input_params{'action'} eq 'snapshot' &&
684 defined $refname && index($refname, '.') != -1 &&
685 $refname eq $input_params{'hash'} &&
686 !defined $input_params{'snapshot_format'}) {
687 # We loop over the known snapshot formats, checking for
688 # extensions. Allowed extensions are both the defined suffix
689 # (which includes the initial dot already) and the snapshot
690 # format key itself, with a prepended dot
691 while (my ($fmt, $opt) = each %known_snapshot_formats) {
693 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
697 # a valid suffix was found, so set the snapshot format
698 # and reset the hash parameter
699 $input_params{'snapshot_format'} = $fmt;
700 $input_params{'hash'} = $hash;
701 # we also set the format suffix to the one requested
702 # in the URL: this way a request for e.g. .tgz returns
703 # a .tgz instead of a .tar.gz
704 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
709 evaluate_path_info
();
711 our $action = $input_params{'action'};
712 if (defined $action) {
713 if (!validate_action
($action)) {
714 die_error
(400, "Invalid action parameter");
718 # parameters which are pathnames
719 our $project = $input_params{'project'};
720 if (defined $project) {
721 if (!validate_project
($project)) {
723 die_error
(404, "No such project");
727 our $file_name = $input_params{'file_name'};
728 if (defined $file_name) {
729 if (!validate_pathname
($file_name)) {
730 die_error
(400, "Invalid file parameter");
734 our $file_parent = $input_params{'file_parent'};
735 if (defined $file_parent) {
736 if (!validate_pathname
($file_parent)) {
737 die_error
(400, "Invalid file parent parameter");
741 # parameters which are refnames
742 our $hash = $input_params{'hash'};
744 if (!validate_refname
($hash)) {
745 die_error
(400, "Invalid hash parameter");
749 our $hash_parent = $input_params{'hash_parent'};
750 if (defined $hash_parent) {
751 if (!validate_refname
($hash_parent)) {
752 die_error
(400, "Invalid hash parent parameter");
756 our $hash_base = $input_params{'hash_base'};
757 if (defined $hash_base) {
758 if (!validate_refname
($hash_base)) {
759 die_error
(400, "Invalid hash base parameter");
763 our @extra_options = @
{$input_params{'extra_options'}};
764 # @extra_options is always defined, since it can only be (currently) set from
765 # CGI, and $cgi->param() returns the empty array in array context if the param
767 foreach my $opt (@extra_options) {
768 if (not exists $allowed_options{$opt}) {
769 die_error
(400, "Invalid option parameter");
771 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
772 die_error
(400, "Invalid option parameter for this action");
776 our $hash_parent_base = $input_params{'hash_parent_base'};
777 if (defined $hash_parent_base) {
778 if (!validate_refname
($hash_parent_base)) {
779 die_error
(400, "Invalid hash parent base parameter");
784 our $page = $input_params{'page'};
786 if ($page =~ m/[^0-9]/) {
787 die_error
(400, "Invalid page parameter");
791 our $searchtype = $input_params{'searchtype'};
792 if (defined $searchtype) {
793 if ($searchtype =~ m/[^a-z]/) {
794 die_error
(400, "Invalid searchtype parameter");
798 our $search_use_regexp = $input_params{'search_use_regexp'};
800 our $searchtext = $input_params{'searchtext'};
802 if (defined $searchtext) {
803 if (length($searchtext) < 2) {
804 die_error
(403, "At least two characters are required for search parameter");
806 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
809 # path to the current git repository
811 $git_dir = "$projectroot/$project" if $project;
813 # list of supported snapshot formats
814 our @snapshot_fmts = gitweb_get_feature
('snapshot');
815 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
818 if (!defined $action) {
820 $action = git_get_type
($hash);
821 } elsif (defined $hash_base && defined $file_name) {
822 $action = git_get_type
("$hash_base:$file_name");
823 } elsif (defined $project) {
826 $action = 'project_list';
829 if (!defined($actions{$action})) {
830 die_error
(400, "Unknown action");
832 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
834 die_error
(400, "Project needed");
836 $actions{$action}->();
839 ## ======================================================================
844 # default is to use -absolute url() i.e. $my_uri
845 my $href = $params{-full
} ?
$my_url : $my_uri;
847 $params{'project'} = $project unless exists $params{'project'};
849 if ($params{-replay
}) {
850 while (my ($name, $symbol) = each %cgi_param_mapping) {
851 if (!exists $params{$name}) {
852 $params{$name} = $input_params{$name};
857 my $use_pathinfo = gitweb_check_feature
('pathinfo');
858 if ($use_pathinfo and defined $params{'project'}) {
859 # try to put as many parameters as possible in PATH_INFO:
862 # - hash_parent or hash_parent_base:/file_parent
863 # - hash or hash_base:/filename
864 # - the snapshot_format as an appropriate suffix
866 # When the script is the root DirectoryIndex for the domain,
867 # $href here would be something like http://gitweb.example.com/
868 # Thus, we strip any trailing / from $href, to spare us double
869 # slashes in the final URL
872 # Then add the project name, if present
873 $href .= "/".esc_url
($params{'project'});
874 delete $params{'project'};
876 # since we destructively absorb parameters, we keep this
877 # boolean that remembers if we're handling a snapshot
878 my $is_snapshot = $params{'action'} eq 'snapshot';
880 # Summary just uses the project path URL, any other action is
882 if (defined $params{'action'}) {
883 $href .= "/".esc_url
($params{'action'}) unless $params{'action'} eq 'summary';
884 delete $params{'action'};
887 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
888 # stripping nonexistent or useless pieces
889 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
890 || $params{'hash_parent'} || $params{'hash'});
891 if (defined $params{'hash_base'}) {
892 if (defined $params{'hash_parent_base'}) {
893 $href .= esc_url
($params{'hash_parent_base'});
894 # skip the file_parent if it's the same as the file_name
895 delete $params{'file_parent'} if $params{'file_parent'} eq $params{'file_name'};
896 if (defined $params{'file_parent'} && $params{'file_parent'} !~ /\.\./) {
897 $href .= ":/".esc_url
($params{'file_parent'});
898 delete $params{'file_parent'};
901 delete $params{'hash_parent'};
902 delete $params{'hash_parent_base'};
903 } elsif (defined $params{'hash_parent'}) {
904 $href .= esc_url
($params{'hash_parent'}). "..";
905 delete $params{'hash_parent'};
908 $href .= esc_url
($params{'hash_base'});
909 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
910 $href .= ":/".esc_url
($params{'file_name'});
911 delete $params{'file_name'};
913 delete $params{'hash'};
914 delete $params{'hash_base'};
915 } elsif (defined $params{'hash'}) {
916 $href .= esc_url
($params{'hash'});
917 delete $params{'hash'};
920 # If the action was a snapshot, we can absorb the
921 # snapshot_format parameter too
923 my $fmt = $params{'snapshot_format'};
924 # snapshot_format should always be defined when href()
925 # is called, but just in case some code forgets, we
926 # fall back to the default
927 $fmt ||= $snapshot_fmts[0];
928 $href .= $known_snapshot_formats{$fmt}{'suffix'};
929 delete $params{'snapshot_format'};
933 # now encode the parameters explicitly
935 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
936 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
937 if (defined $params{$name}) {
938 if (ref($params{$name}) eq "ARRAY") {
939 foreach my $par (@
{$params{$name}}) {
940 push @result, $symbol . "=" . esc_param
($par);
943 push @result, $symbol . "=" . esc_param
($params{$name});
947 $href .= "?" . join(';', @result) if scalar @result;
953 ## ======================================================================
954 ## validation, quoting/unquoting and escaping
956 sub validate_action
{
957 my $input = shift || return undef;
958 return undef unless exists $actions{$input};
962 sub validate_project
{
963 my $input = shift || return undef;
964 if (!validate_pathname
($input) ||
965 !(-d
"$projectroot/$input") ||
966 !check_export_ok
("$projectroot/$input") ||
967 ($strict_export && !project_in_list
($input))) {
974 sub validate_pathname
{
975 my $input = shift || return undef;
977 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
978 # at the beginning, at the end, and between slashes.
979 # also this catches doubled slashes
980 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
984 if ($input =~ m!\0!) {
990 sub validate_refname
{
991 my $input = shift || return undef;
993 # textual hashes are O.K.
994 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
997 # it must be correct pathname
998 $input = validate_pathname
($input)
1000 # restrictions on ref name according to git-check-ref-format
1001 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1007 # decode sequences of octets in utf8 into Perl's internal form,
1008 # which is utf-8 with utf8 flag set if needed. gitweb writes out
1009 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1012 if (utf8
::valid
($str)) {
1016 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
1020 # quote unsafe chars, but keep the slash, even when it's not
1021 # correct, but quoted slashes look too horrible in bookmarks
1024 $str =~ s/([^A-Za-z0-9\-_.~()\/:@])/sprintf
("%%%02X", ord($1))/eg
;
1030 # quote unsafe chars in whole URL, so some charactrs cannot be quoted
1033 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&=])/sprintf
("%%%02X", ord($1))/eg
;
1039 # replace invalid utf8 character with SUBSTITUTION sequence
1044 $str = to_utf8
($str);
1045 $str = $cgi->escapeHTML($str);
1046 if ($opts{'-nbsp'}) {
1047 $str =~ s/ / /g;
1049 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
1053 # quote control characters and escape filename to HTML
1058 $str = to_utf8
($str);
1059 $str = $cgi->escapeHTML($str);
1060 if ($opts{'-nbsp'}) {
1061 $str =~ s/ / /g;
1063 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
1067 # Make control characters "printable", using character escape codes (CEC)
1071 my %es = ( # character escape codes, aka escape sequences
1072 "\t" => '\t', # tab (HT)
1073 "\n" => '\n', # line feed (LF)
1074 "\r" => '\r', # carrige return (CR)
1075 "\f" => '\f', # form feed (FF)
1076 "\b" => '\b', # backspace (BS)
1077 "\a" => '\a', # alarm (bell) (BEL)
1078 "\e" => '\e', # escape (ESC)
1079 "\013" => '\v', # vertical tab (VT)
1080 "\000" => '\0', # nul character (NUL)
1082 my $chr = ( (exists $es{$cntrl})
1084 : sprintf('\%2x', ord($cntrl)) );
1085 if ($opts{-nohtml
}) {
1088 return "<span class=\"cntrl\">$chr</span>";
1092 # Alternatively use unicode control pictures codepoints,
1093 # Unicode "printable representation" (PR)
1098 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
1099 if ($opts{-nohtml
}) {
1102 return "<span class=\"cntrl\">$chr</span>";
1106 # git may return quoted and escaped filenames
1112 my %es = ( # character escape codes, aka escape sequences
1113 't' => "\t", # tab (HT, TAB)
1114 'n' => "\n", # newline (NL)
1115 'r' => "\r", # return (CR)
1116 'f' => "\f", # form feed (FF)
1117 'b' => "\b", # backspace (BS)
1118 'a' => "\a", # alarm (bell) (BEL)
1119 'e' => "\e", # escape (ESC)
1120 'v' => "\013", # vertical tab (VT)
1123 if ($seq =~ m/^[0-7]{1,3}$/) {
1124 # octal char sequence
1125 return chr(oct($seq));
1126 } elsif (exists $es{$seq}) {
1127 # C escape sequence, aka character escape code
1130 # quoted ordinary character
1134 if ($str =~ m/^"(.*)"$/) {
1137 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1142 # escape tabs (convert tabs to spaces)
1146 while ((my $pos = index($line, "\t")) != -1) {
1147 if (my $count = (8 - ($pos % 8))) {
1148 my $spaces = ' ' x
$count;
1149 $line =~ s/\t/$spaces/;
1156 sub project_in_list
{
1157 my $project = shift;
1158 my @list = git_get_projects_list
();
1159 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1162 ## ----------------------------------------------------------------------
1163 ## HTML aware string manipulation
1165 # Try to chop given string on a word boundary between position
1166 # $len and $len+$add_len. If there is no word boundary there,
1167 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1168 # (marking chopped part) would be longer than given string.
1172 my $add_len = shift || 10;
1173 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1175 # Make sure perl knows it is utf8 encoded so we don't
1176 # cut in the middle of a utf8 multibyte char.
1177 $str = to_utf8
($str);
1179 # allow only $len chars, but don't cut a word if it would fit in $add_len
1180 # if it doesn't fit, cut it if it's still longer than the dots we would add
1181 # remove chopped character entities entirely
1183 # when chopping in the middle, distribute $len into left and right part
1184 # return early if chopping wouldn't make string shorter
1185 if ($where eq 'center') {
1186 return $str if ($len + 5 >= length($str)); # filler is length 5
1189 return $str if ($len + 4 >= length($str)); # filler is length 4
1192 # regexps: ending and beginning with word part up to $add_len
1193 my $endre = qr/.{$len}\w{0,$add_len}/;
1194 my $begre = qr/\w{0,$add_len}.{$len}/;
1196 if ($where eq 'left') {
1197 $str =~ m/^(.*?)($begre)$/;
1198 my ($lead, $body) = ($1, $2);
1199 if (length($lead) > 4) {
1200 $body =~ s/^[^;]*;// if ($lead =~ m/&[^;]*$/);
1203 return "$lead$body";
1205 } elsif ($where eq 'center') {
1206 $str =~ m/^($endre)(.*)$/;
1207 my ($left, $str) = ($1, $2);
1208 $str =~ m/^(.*?)($begre)$/;
1209 my ($mid, $right) = ($1, $2);
1210 if (length($mid) > 5) {
1211 $left =~ s/&[^;]*$//;
1212 $right =~ s/^[^;]*;// if ($mid =~ m/&[^;]*$/);
1215 return "$left$mid$right";
1218 $str =~ m/^($endre)(.*)$/;
1221 if (length($tail) > 4) {
1222 $body =~ s/&[^;]*$//;
1225 return "$body$tail";
1229 # takes the same arguments as chop_str, but also wraps a <span> around the
1230 # result with a title attribute if it does get chopped. Additionally, the
1231 # string is HTML-escaped.
1232 sub chop_and_escape_str
{
1235 my $chopped = chop_str
(@_);
1236 if ($chopped eq $str) {
1237 return esc_html
($chopped);
1239 $str =~ s/[[:cntrl:]]/?/g;
1240 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1244 ## ----------------------------------------------------------------------
1245 ## functions returning short strings
1247 # CSS class for given age value (in seconds)
1251 if (!defined $age) {
1253 } elsif ($age < 60*60*2) {
1255 } elsif ($age < 60*60*24*2) {
1262 # convert age in seconds to "nn units ago" string
1267 if ($age > 60*60*24*365*2) {
1268 $age_str = (int $age/60/60/24/365);
1269 $age_str .= " years ago";
1270 } elsif ($age > 60*60*24*(365/12)*2) {
1271 $age_str = int $age/60/60/24/(365/12);
1272 $age_str .= " months ago";
1273 } elsif ($age > 60*60*24*7*2) {
1274 $age_str = int $age/60/60/24/7;
1275 $age_str .= " weeks ago";
1276 } elsif ($age > 60*60*24*2) {
1277 $age_str = int $age/60/60/24;
1278 $age_str .= " days ago";
1279 } elsif ($age > 60*60*2) {
1280 $age_str = int $age/60/60;
1281 $age_str .= " hours ago";
1282 } elsif ($age > 60*2) {
1283 $age_str = int $age/60;
1284 $age_str .= " min ago";
1285 } elsif ($age > 2) {
1286 $age_str = int $age;
1287 $age_str .= " sec ago";
1289 $age_str .= " right now";
1295 S_IFINVALID
=> 0030000,
1296 S_IFGITLINK
=> 0160000,
1299 # submodule/subproject, a commit object reference
1303 return (($mode & S_IFMT
) == S_IFGITLINK
)
1306 # convert file mode in octal to symbolic file mode string
1308 my $mode = oct shift;
1310 if (S_ISGITLINK
($mode)) {
1311 return 'm---------';
1312 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1313 return 'drwxr-xr-x';
1314 } elsif (S_ISLNK
($mode)) {
1315 return 'lrwxrwxrwx';
1316 } elsif (S_ISREG
($mode)) {
1317 # git cares only about the executable bit
1318 if ($mode & S_IXUSR
) {
1319 return '-rwxr-xr-x';
1321 return '-rw-r--r--';
1324 return '----------';
1328 # convert file mode in octal to file type string
1332 if ($mode !~ m/^[0-7]+$/) {
1338 if (S_ISGITLINK
($mode)) {
1340 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1342 } elsif (S_ISLNK
($mode)) {
1344 } elsif (S_ISREG
($mode)) {
1351 # convert file mode in octal to file type description string
1352 sub file_type_long
{
1355 if ($mode !~ m/^[0-7]+$/) {
1361 if (S_ISGITLINK
($mode)) {
1363 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1365 } elsif (S_ISLNK
($mode)) {
1367 } elsif (S_ISREG
($mode)) {
1368 if ($mode & S_IXUSR
) {
1369 return "executable";
1379 ## ----------------------------------------------------------------------
1380 ## functions returning short HTML fragments, or transforming HTML fragments
1381 ## which don't belong to other sections
1383 # format line of commit message.
1384 sub format_log_line_html
{
1387 $line = esc_html
($line, -nbsp
=>1);
1388 $line =~ s
{\b([0-9a
-fA
-F
]{8,40})\b}{
1389 $cgi->a({-href
=> href
(action
=>"object", hash
=>$1),
1390 -class => "text"}, $1);
1396 # format marker of refs pointing to given object
1398 # the destination action is chosen based on object type and current context:
1399 # - for annotated tags, we choose the tag view unless it's the current view
1400 # already, in which case we go to shortlog view
1401 # - for other refs, we keep the current view if we're in history, shortlog or
1402 # log view, and select shortlog otherwise
1403 sub format_ref_marker
{
1404 my ($refs, $id) = @_;
1407 if (defined $refs->{$id}) {
1408 foreach my $ref (@
{$refs->{$id}}) {
1409 # this code exploits the fact that non-lightweight tags are the
1410 # only indirect objects, and that they are the only objects for which
1411 # we want to use tag instead of shortlog as action
1412 my ($type, $name) = qw();
1413 my $indirect = ($ref =~ s/\^\{\}$//);
1414 # e.g. tags/v2.6.11 or heads/next
1415 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1424 $class .= " indirect" if $indirect;
1426 my $dest_action = "shortlog";
1429 $dest_action = "tag" unless $action eq "tag";
1430 } elsif ($action =~ /^(history|(short)?log)$/) {
1431 $dest_action = $action;
1435 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1438 my $link = $cgi->a({
1440 action
=>$dest_action,
1444 $markers .= " <span class=\"$class\" title=\"$ref\">" .
1450 return ' <span class="refs">'. $markers . '</span>';
1456 # format, perhaps shortened and with markers, title line
1457 sub format_subject_html
{
1458 my ($long, $short, $href, $extra) = @_;
1459 $extra = '' unless defined($extra);
1461 if (length($short) < length($long)) {
1462 $long =~ s/[[:cntrl:]]/?/g;
1463 return $cgi->a({-href
=> $href, -class => "list subject",
1464 -title
=> to_utf8
($long)},
1465 esc_html
($short) . $extra);
1467 return $cgi->a({-href
=> $href, -class => "list subject"},
1468 esc_html
($long) . $extra);
1472 # format the author name of the given commit with the given tag
1473 # the author name is chopped and escaped according to the other
1474 # optional parameters (see chop_str).
1475 sub format_author_html
{
1478 my $author = chop_and_escape_str
($co->{'author_name'}, @_);
1479 return "<$tag class=\"author\">" . $author . "</$tag>";
1482 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1483 sub format_git_diff_header_line
{
1485 my $diffinfo = shift;
1486 my ($from, $to) = @_;
1488 if ($diffinfo->{'nparents'}) {
1490 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1491 if ($to->{'href'}) {
1492 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1493 esc_path
($to->{'file'}));
1494 } else { # file was deleted (no href)
1495 $line .= esc_path
($to->{'file'});
1499 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1500 if ($from->{'href'}) {
1501 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
1502 'a/' . esc_path
($from->{'file'}));
1503 } else { # file was added (no href)
1504 $line .= 'a/' . esc_path
($from->{'file'});
1507 if ($to->{'href'}) {
1508 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1509 'b/' . esc_path
($to->{'file'}));
1510 } else { # file was deleted
1511 $line .= 'b/' . esc_path
($to->{'file'});
1515 return "<div class=\"diff header\">$line</div>\n";
1518 # format extended diff header line, before patch itself
1519 sub format_extended_diff_header_line
{
1521 my $diffinfo = shift;
1522 my ($from, $to) = @_;
1525 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1526 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1527 esc_path
($from->{'file'}));
1529 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1530 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1531 esc_path
($to->{'file'}));
1533 # match single <mode>
1534 if ($line =~ m/\s(\d{6})$/) {
1535 $line .= '<span class="info"> (' .
1536 file_type_long
($1) .
1540 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1541 # can match only for combined diff
1543 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1544 if ($from->{'href'}[$i]) {
1545 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
1547 substr($diffinfo->{'from_id'}[$i],0,7));
1552 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1555 if ($to->{'href'}) {
1556 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1557 substr($diffinfo->{'to_id'},0,7));
1562 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
1563 # can match only for ordinary diff
1564 my ($from_link, $to_link);
1565 if ($from->{'href'}) {
1566 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
1567 substr($diffinfo->{'from_id'},0,7));
1569 $from_link = '0' x
7;
1571 if ($to->{'href'}) {
1572 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1573 substr($diffinfo->{'to_id'},0,7));
1577 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
1578 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
1581 return $line . "<br/>\n";
1584 # format from-file/to-file diff header
1585 sub format_diff_from_to_header
{
1586 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
1591 #assert($line =~ m/^---/) if DEBUG;
1592 # no extra formatting for "^--- /dev/null"
1593 if (! $diffinfo->{'nparents'}) {
1594 # ordinary (single parent) diff
1595 if ($line =~ m!^--- "?a/!) {
1596 if ($from->{'href'}) {
1598 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1599 esc_path
($from->{'file'}));
1602 esc_path
($from->{'file'});
1605 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1608 # combined diff (merge commit)
1609 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1610 if ($from->{'href'}[$i]) {
1612 $cgi->a({-href
=>href
(action
=>"blobdiff",
1613 hash_parent
=>$diffinfo->{'from_id'}[$i],
1614 hash_parent_base
=>$parents[$i],
1615 file_parent
=>$from->{'file'}[$i],
1616 hash
=>$diffinfo->{'to_id'},
1618 file_name
=>$to->{'file'}),
1620 -title
=>"diff" . ($i+1)},
1623 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
1624 esc_path
($from->{'file'}[$i]));
1626 $line = '--- /dev/null';
1628 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1633 #assert($line =~ m/^\+\+\+/) if DEBUG;
1634 # no extra formatting for "^+++ /dev/null"
1635 if ($line =~ m!^\+\+\+ "?b/!) {
1636 if ($to->{'href'}) {
1638 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1639 esc_path
($to->{'file'}));
1642 esc_path
($to->{'file'});
1645 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
1650 # create note for patch simplified by combined diff
1651 sub format_diff_cc_simplified
{
1652 my ($diffinfo, @parents) = @_;
1655 $result .= "<div class=\"diff header\">" .
1657 if (!is_deleted
($diffinfo)) {
1658 $result .= $cgi->a({-href
=> href
(action
=>"blob",
1660 hash
=>$diffinfo->{'to_id'},
1661 file_name
=>$diffinfo->{'to_file'}),
1663 esc_path
($diffinfo->{'to_file'}));
1665 $result .= esc_path
($diffinfo->{'to_file'});
1667 $result .= "</div>\n" . # class="diff header"
1668 "<div class=\"diff nodifferences\">" .
1670 "</div>\n"; # class="diff nodifferences"
1675 # format patch (diff) line (not to be used for diff headers)
1676 sub format_diff_line
{
1678 my ($from, $to) = @_;
1679 my $diff_class = "";
1683 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
1685 my $prefix = substr($line, 0, scalar @
{$from->{'href'}});
1686 if ($line =~ m/^\@{3}/) {
1687 $diff_class = " chunk_header";
1688 } elsif ($line =~ m/^\\/) {
1689 $diff_class = " incomplete";
1690 } elsif ($prefix =~ tr/+/+/) {
1691 $diff_class = " add";
1692 } elsif ($prefix =~ tr/-/-/) {
1693 $diff_class = " rem";
1696 # assume ordinary diff
1697 my $char = substr($line, 0, 1);
1699 $diff_class = " add";
1700 } elsif ($char eq '-') {
1701 $diff_class = " rem";
1702 } elsif ($char eq '@') {
1703 $diff_class = " chunk_header";
1704 } elsif ($char eq "\\") {
1705 $diff_class = " incomplete";
1708 $line = untabify
($line);
1709 if ($from && $to && $line =~ m/^\@{2} /) {
1710 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
1711 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
1713 $from_lines = 0 unless defined $from_lines;
1714 $to_lines = 0 unless defined $to_lines;
1716 if ($from->{'href'}) {
1717 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
1718 -class=>"list"}, $from_text);
1720 if ($to->{'href'}) {
1721 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1722 -class=>"list"}, $to_text);
1724 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
1725 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1726 return "<div class=\"diff$diff_class\">$line</div>\n";
1727 } elsif ($from && $to && $line =~ m/^\@{3}/) {
1728 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
1729 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
1731 @from_text = split(' ', $ranges);
1732 for (my $i = 0; $i < @from_text; ++$i) {
1733 ($from_start[$i], $from_nlines[$i]) =
1734 (split(',', substr($from_text[$i], 1)), 0);
1737 $to_text = pop @from_text;
1738 $to_start = pop @from_start;
1739 $to_nlines = pop @from_nlines;
1741 $line = "<span class=\"chunk_info\">$prefix ";
1742 for (my $i = 0; $i < @from_text; ++$i) {
1743 if ($from->{'href'}[$i]) {
1744 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
1745 -class=>"list"}, $from_text[$i]);
1747 $line .= $from_text[$i];
1751 if ($to->{'href'}) {
1752 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1753 -class=>"list"}, $to_text);
1757 $line .= " $prefix</span>" .
1758 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1759 return "<div class=\"diff$diff_class\">$line</div>\n";
1761 return "<div class=\"diff$diff_class\">" . esc_html
($line, -nbsp
=>1) . "</div>\n";
1764 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
1765 # linked. Pass the hash of the tree/commit to snapshot.
1766 sub format_snapshot_links
{
1768 my $num_fmts = @snapshot_fmts;
1769 if ($num_fmts > 1) {
1770 # A parenthesized list of links bearing format names.
1771 # e.g. "snapshot (_tar.gz_ _zip_)"
1772 return "snapshot (" . join(' ', map
1779 }, $known_snapshot_formats{$_}{'display'})
1780 , @snapshot_fmts) . ")";
1781 } elsif ($num_fmts == 1) {
1782 # A single "snapshot" link whose tooltip bears the format name.
1784 my ($fmt) = @snapshot_fmts;
1790 snapshot_format
=>$fmt
1792 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
1794 } else { # $num_fmts == 0
1799 ## ......................................................................
1800 ## functions returning values to be passed, perhaps after some
1801 ## transformation, to other functions; e.g. returning arguments to href()
1803 # returns hash to be passed to href to generate gitweb URL
1804 # in -title key it returns description of link
1806 my $format = shift || 'Atom';
1807 my %res = (action
=> lc($format));
1809 # feed links are possible only for project views
1810 return unless (defined $project);
1811 # some views should link to OPML, or to generic project feed,
1812 # or don't have specific feed yet (so they should use generic)
1813 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
1816 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
1817 # from tag links; this also makes possible to detect branch links
1818 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
1819 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
1822 # find log type for feed description (title)
1824 if (defined $file_name) {
1825 $type = "history of $file_name";
1826 $type .= "/" if ($action eq 'tree');
1827 $type .= " on '$branch'" if (defined $branch);
1829 $type = "log of $branch" if (defined $branch);
1832 $res{-title
} = $type;
1833 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
1834 $res{'file_name'} = $file_name;
1839 ## ----------------------------------------------------------------------
1840 ## git utility subroutines, invoking git commands
1842 # returns path to the core git executable and the --git-dir parameter as list
1844 return $GIT, '--git-dir='.$git_dir;
1847 # quote the given arguments for passing them to the shell
1848 # quote_command("command", "arg 1", "arg with ' and ! characters")
1849 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
1850 # Try to avoid using this function wherever possible.
1853 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
1856 # get HEAD ref of given project as hash
1857 sub git_get_head_hash
{
1858 my $project = shift;
1859 my $o_git_dir = $git_dir;
1861 $git_dir = "$projectroot/$project";
1862 if (open my $fd, "-|", git_cmd
(), "rev-parse", "--verify", "HEAD") {
1865 if (defined $head && $head =~ /^([0-9a-fA-F]{40})$/) {
1869 if (defined $o_git_dir) {
1870 $git_dir = $o_git_dir;
1875 # get type of given object
1879 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
1881 close $fd or return;
1886 # repository configuration
1887 our $config_file = '';
1890 # store multiple values for single key as anonymous array reference
1891 # single values stored directly in the hash, not as [ <value> ]
1892 sub hash_set_multi
{
1893 my ($hash, $key, $value) = @_;
1895 if (!exists $hash->{$key}) {
1896 $hash->{$key} = $value;
1897 } elsif (!ref $hash->{$key}) {
1898 $hash->{$key} = [ $hash->{$key}, $value ];
1900 push @
{$hash->{$key}}, $value;
1904 # return hash of git project configuration
1905 # optionally limited to some section, e.g. 'gitweb'
1906 sub git_parse_project_config
{
1907 my $section_regexp = shift;
1912 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
1915 while (my $keyval = <$fh>) {
1917 my ($key, $value) = split(/\n/, $keyval, 2);
1919 hash_set_multi
(\
%config, $key, $value)
1920 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
1927 # convert config value to boolean: 'true' or 'false'
1928 # no value, number > 0, 'true' and 'yes' values are true
1929 # rest of values are treated as false (never as error)
1930 sub config_to_bool
{
1933 return 1 if !defined $val; # section.key
1935 # strip leading and trailing whitespace
1939 return (($val =~ /^\d+$/ && $val) || # section.key = 1
1940 ($val =~ /^(?:true|yes)$/i)); # section.key = true
1943 # convert config value to simple decimal number
1944 # an optional value suffix of 'k', 'm', or 'g' will cause the value
1945 # to be multiplied by 1024, 1048576, or 1073741824
1949 # strip leading and trailing whitespace
1953 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
1955 # unknown unit is treated as 1
1956 return $num * ($unit eq 'g' ?
1073741824 :
1957 $unit eq 'm' ?
1048576 :
1958 $unit eq 'k' ?
1024 : 1);
1963 # convert config value to array reference, if needed
1964 sub config_to_multi
{
1967 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
1970 sub git_get_project_config
{
1971 my ($key, $type) = @_;
1974 return unless ($key);
1975 $key =~ s/^gitweb\.//;
1976 return if ($key =~ m/\W/);
1979 if (defined $type) {
1982 unless ($type eq 'bool' || $type eq 'int');
1986 if (!defined $config_file ||
1987 $config_file ne "$git_dir/config") {
1988 %config = git_parse_project_config
('gitweb');
1989 $config_file = "$git_dir/config";
1992 # check if config variable (key) exists
1993 return unless exists $config{"gitweb.$key"};
1996 if (!defined $type) {
1997 return $config{"gitweb.$key"};
1998 } elsif ($type eq 'bool') {
1999 # backward compatibility: 'git config --bool' returns true/false
2000 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
2001 } elsif ($type eq 'int') {
2002 return config_to_int
($config{"gitweb.$key"});
2004 return $config{"gitweb.$key"};
2007 # get hash of given path at given ref
2008 sub git_get_hash_by_path
{
2010 my $path = shift || return undef;
2015 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
2016 or die_error
(500, "Open git-ls-tree failed");
2018 close $fd or return undef;
2020 if (!defined $line) {
2021 # there is no tree or hash given by $path at $base
2025 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2026 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
2027 if (defined $type && $type ne $2) {
2028 # type doesn't match
2034 # get path of entry with given hash at given tree-ish (ref)
2035 # used to get 'from' filename for combined diff (merge commit) for renames
2036 sub git_get_path_by_hash
{
2037 my $base = shift || return;
2038 my $hash = shift || return;
2042 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
2044 while (my $line = <$fd>) {
2047 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2048 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2049 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2058 ## ......................................................................
2059 ## git utility functions, directly accessing git repository
2061 sub git_get_project_description
{
2064 $git_dir = "$projectroot/$path";
2065 open my $fd, '<', "$git_dir/description"
2066 or return git_get_project_config
('description');
2069 if (defined $descr) {
2075 sub git_get_project_ctags
{
2079 $git_dir = "$projectroot/$path";
2080 opendir my $dh, "$git_dir/ctags"
2082 foreach (grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir($dh)) {
2083 open my $ct, '<', $_ or next;
2087 my $ctag = $_; $ctag =~ s
#.*/##;
2088 $ctags->{$ctag} = $val;
2094 sub git_populate_project_tagcloud
{
2097 # First, merge different-cased tags; tags vote on casing
2099 foreach (keys %$ctags) {
2100 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
2101 if (not $ctags_lc{lc $_}->{topcount
}
2102 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
2103 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
2104 $ctags_lc{lc $_}->{topname
} = $_;
2109 if (eval { require HTML
::TagCloud
; 1; }) {
2110 $cloud = HTML
::TagCloud
->new;
2111 foreach (sort keys %ctags_lc) {
2112 # Pad the title with spaces so that the cloud looks
2114 my $title = $ctags_lc{$_}->{topname
};
2115 $title =~ s/ / /g;
2116 $title =~ s/^/ /g;
2117 $title =~ s/$/ /g;
2118 $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count
});
2121 $cloud = \
%ctags_lc;
2126 sub git_show_project_tagcloud
{
2127 my ($cloud, $count) = @_;
2128 print STDERR
ref($cloud)."..\n";
2129 if (ref $cloud eq 'HTML::TagCloud') {
2130 return $cloud->html_and_css($count);
2132 my @tags = sort { $cloud->{$a}->{count
} <=> $cloud->{$b}->{count
} } keys %$cloud;
2133 return '<p align="center">' . join (', ', map {
2134 "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
2135 } splice(@tags, 0, $count)) . '</p>';
2139 sub git_get_project_url_list
{
2142 $git_dir = "$projectroot/$path";
2143 open my $fd, '<', "$git_dir/cloneurl"
2144 or return wantarray ?
2145 @
{ config_to_multi
(git_get_project_config
('url')) } :
2146 config_to_multi
(git_get_project_config
('url'));
2147 my @git_project_url_list = map { chomp; $_ } <$fd>;
2150 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2153 sub git_get_projects_list
{
2158 $filter =~ s/\.git$//;
2160 my $check_forks = gitweb_check_feature
('forks');
2162 if (-d
$projects_list) {
2163 # search in directory
2164 my $dir = $projects_list . ($filter ?
"/$filter" : '');
2165 # remove the trailing "/"
2167 my $pfxlen = length("$dir");
2168 my $pfxdepth = ($dir =~ tr!/!!);
2171 follow_fast
=> 1, # follow symbolic links
2172 follow_skip
=> 2, # ignore duplicates
2173 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2175 # skip project-list toplevel, if we get it.
2176 return if (m!^[/.]$!);
2177 # only directories can be git repositories
2178 return unless (-d
$_);
2179 # don't traverse too deep (Find is super slow on os x)
2180 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2181 $File::Find
::prune
= 1;
2185 my $subdir = substr($File::Find
::name
, $pfxlen + 1);
2186 # we check related file in $projectroot
2187 my $path = ($filter ?
"$filter/" : '') . $subdir;
2188 if (check_export_ok
("$projectroot/$path")) {
2189 push @list, { path
=> $path };
2190 $File::Find
::prune
= 1;
2195 } elsif (-f
$projects_list) {
2196 # read from file(url-encoded):
2197 # 'git%2Fgit.git Linus+Torvalds'
2198 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2199 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2201 open my $fd, '<', $projects_list or return;
2203 while (my $line = <$fd>) {
2205 my ($path, $owner) = split ' ', $line;
2206 $path = unescape
($path);
2207 $owner = unescape
($owner);
2208 if (!defined $path) {
2211 if ($filter ne '') {
2212 # looking for forks;
2213 my $pfx = substr($path, 0, length($filter));
2214 if ($pfx ne $filter) {
2217 my $sfx = substr($path, length($filter));
2218 if ($sfx !~ /^\/.*\
.git
$/) {
2221 } elsif ($check_forks) {
2223 foreach my $filter (keys %paths) {
2224 # looking for forks;
2225 my $pfx = substr($path, 0, length($filter));
2226 if ($pfx ne $filter) {
2229 my $sfx = substr($path, length($filter));
2230 if ($sfx !~ /^\/.*\
.git
$/) {
2233 # is a fork, don't include it in
2238 if (check_export_ok
("$projectroot/$path")) {
2241 owner
=> to_utf8
($owner),
2244 (my $forks_path = $path) =~ s/\.git$//;
2245 $paths{$forks_path}++;
2253 our $gitweb_project_owner = undef;
2254 sub git_get_project_list_from_file
{
2256 return if (defined $gitweb_project_owner);
2258 $gitweb_project_owner = {};
2259 # read from file (url-encoded):
2260 # 'git%2Fgit.git Linus+Torvalds'
2261 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2262 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2263 if (-f
$projects_list) {
2264 open(my $fd, '<', $projects_list);
2265 while (my $line = <$fd>) {
2267 my ($pr, $ow) = split ' ', $line;
2268 $pr = unescape
($pr);
2269 $ow = unescape
($ow);
2270 $gitweb_project_owner->{$pr} = to_utf8
($ow);
2276 sub git_get_project_owner
{
2277 my $project = shift;
2280 return undef unless $project;
2281 $git_dir = "$projectroot/$project";
2283 if (!defined $gitweb_project_owner) {
2284 git_get_project_list_from_file
();
2287 if (exists $gitweb_project_owner->{$project}) {
2288 $owner = $gitweb_project_owner->{$project};
2290 if (!defined $owner){
2291 $owner = git_get_project_config
('owner');
2293 if (!defined $owner) {
2294 $owner = get_file_owner
("$git_dir");
2300 sub git_get_last_activity
{
2304 $git_dir = "$projectroot/$path";
2305 open($fd, "-|", git_cmd
(), 'for-each-ref',
2306 '--format=%(committer)',
2307 '--sort=-committerdate',
2309 'refs/heads') or return;
2310 my $most_recent = <$fd>;
2311 close $fd or return;
2312 if (defined $most_recent &&
2313 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2315 my $age = time - $timestamp;
2316 return ($age, age_string
($age));
2318 return (undef, undef);
2321 sub git_get_references
{
2322 my $type = shift || "";
2324 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2325 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2326 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
2327 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
2330 while (my $line = <$fd>) {
2332 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2333 if (defined $refs{$1}) {
2334 push @
{$refs{$1}}, $2;
2340 close $fd or return;
2344 sub git_get_rev_name_tags
{
2345 my $hash = shift || return undef;
2347 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
2349 my $name_rev = <$fd>;
2352 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
2355 # catches also '$hash undefined' output
2360 ## ----------------------------------------------------------------------
2361 ## parse to hash functions
2365 my $tz = shift || "-0000";
2368 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2369 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2370 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2371 $date{'hour'} = $hour;
2372 $date{'minute'} = $min;
2373 $date{'mday'} = $mday;
2374 $date{'day'} = $days[$wday];
2375 $date{'month'} = $months[$mon];
2376 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2377 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2378 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2379 $mday, $months[$mon], $hour ,$min;
2380 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2381 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2383 $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2384 my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2385 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2386 $date{'hour_local'} = $hour;
2387 $date{'minute_local'} = $min;
2388 $date{'tz_local'} = $tz;
2389 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2390 1900+$year, $mon+1, $mday,
2391 $hour, $min, $sec, $tz);
2400 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
2401 $tag{'id'} = $tag_id;
2402 while (my $line = <$fd>) {
2404 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2405 $tag{'object'} = $1;
2406 } elsif ($line =~ m/^type (.+)$/) {
2408 } elsif ($line =~ m/^tag (.+)$/) {
2410 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2411 $tag{'author'} = $1;
2414 } elsif ($line =~ m/--BEGIN/) {
2415 push @comment, $line;
2417 } elsif ($line eq "") {
2421 push @comment, <$fd>;
2422 $tag{'comment'} = \
@comment;
2423 close $fd or return;
2424 if (!defined $tag{'name'}) {
2430 sub parse_commit_text
{
2431 my ($commit_text, $withparents) = @_;
2432 my @commit_lines = split '\n', $commit_text;
2435 pop @commit_lines; # Remove '\0'
2437 if (! @commit_lines) {
2441 my $header = shift @commit_lines;
2442 if ($header !~ m/^[0-9a-fA-F]{40}/) {
2445 ($co{'id'}, my @parents) = split ' ', $header;
2446 while (my $line = shift @commit_lines) {
2447 last if $line eq "\n";
2448 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2450 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2452 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2454 $co{'author_epoch'} = $2;
2455 $co{'author_tz'} = $3;
2456 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2457 $co{'author_name'} = $1;
2458 $co{'author_email'} = $2;
2460 $co{'author_name'} = $co{'author'};
2462 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2463 $co{'committer'} = $1;
2464 $co{'committer_epoch'} = $2;
2465 $co{'committer_tz'} = $3;
2466 $co{'committer_name'} = $co{'committer'};
2467 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2468 $co{'committer_name'} = $1;
2469 $co{'committer_email'} = $2;
2471 $co{'committer_name'} = $co{'committer'};
2475 if (!defined $co{'tree'}) {
2478 $co{'parents'} = \
@parents;
2479 $co{'parent'} = $parents[0];
2481 foreach my $title (@commit_lines) {
2484 $co{'title'} = chop_str
($title, 80, 5);
2485 # remove leading stuff of merges to make the interesting part visible
2486 if (length($title) > 50) {
2487 $title =~ s/^Automatic //;
2488 $title =~ s/^merge (of|with) /Merge ... /i;
2489 if (length($title) > 50) {
2490 $title =~ s/(http|rsync):\/\///;
2492 if (length($title) > 50) {
2493 $title =~ s/(master|www|rsync)\.//;
2495 if (length($title) > 50) {
2496 $title =~ s/kernel.org:?//;
2498 if (length($title) > 50) {
2499 $title =~ s/\/pub\/scm//;
2502 $co{'title_short'} = chop_str
($title, 50, 5);
2506 if (! defined $co{'title'} || $co{'title'} eq "") {
2507 $co{'title'} = $co{'title_short'} = '(no commit message)';
2509 # remove added spaces
2510 foreach my $line (@commit_lines) {
2513 $co{'comment'} = \
@commit_lines;
2515 my $age = time - $co{'committer_epoch'};
2517 $co{'age_string'} = age_string
($age);
2518 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2519 if ($age > 60*60*24*7*2) {
2520 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2521 $co{'age_string_age'} = $co{'age_string'};
2523 $co{'age_string_date'} = $co{'age_string'};
2524 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2530 my ($commit_id) = @_;
2535 open my $fd, "-|", git_cmd
(), "rev-list",
2541 or die_error
(500, "Open git-rev-list failed");
2542 %co = parse_commit_text
(<$fd>, 1);
2549 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
2557 open my $fd, "-|", git_cmd
(), "rev-list",
2560 ("--max-count=" . $maxcount),
2561 ("--skip=" . $skip),
2565 ($filename ?
($filename) : ())
2566 or die_error
(500, "Open git-rev-list failed");
2567 while (my $line = <$fd>) {
2568 my %co = parse_commit_text
($line);
2573 return wantarray ?
@cos : \
@cos;
2576 # parse line of git-diff-tree "raw" output
2577 sub parse_difftree_raw_line
{
2581 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
2582 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
2583 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
2584 $res{'from_mode'} = $1;
2585 $res{'to_mode'} = $2;
2586 $res{'from_id'} = $3;
2588 $res{'status'} = $5;
2589 $res{'similarity'} = $6;
2590 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
2591 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
2593 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
2596 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
2597 # combined diff (for merge commit)
2598 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
2599 $res{'nparents'} = length($1);
2600 $res{'from_mode'} = [ split(' ', $2) ];
2601 $res{'to_mode'} = pop @
{$res{'from_mode'}};
2602 $res{'from_id'} = [ split(' ', $3) ];
2603 $res{'to_id'} = pop @
{$res{'from_id'}};
2604 $res{'status'} = [ split('', $4) ];
2605 $res{'to_file'} = unquote
($5);
2607 # 'c512b523472485aef4fff9e57b229d9d243c967f'
2608 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
2609 $res{'commit'} = $1;
2612 return wantarray ?
%res : \
%res;
2615 # wrapper: return parsed line of git-diff-tree "raw" output
2616 # (the argument might be raw line, or parsed info)
2617 sub parsed_difftree_line
{
2618 my $line_or_ref = shift;
2620 if (ref($line_or_ref) eq "HASH") {
2621 # pre-parsed (or generated by hand)
2622 return $line_or_ref;
2624 return parse_difftree_raw_line
($line_or_ref);
2628 # parse line of git-ls-tree output
2629 sub parse_ls_tree_line
{
2634 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2635 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
2643 $res{'name'} = unquote
($4);
2646 return wantarray ?
%res : \
%res;
2649 # generates _two_ hashes, references to which are passed as 2 and 3 argument
2650 sub parse_from_to_diffinfo
{
2651 my ($diffinfo, $from, $to, @parents) = @_;
2653 if ($diffinfo->{'nparents'}) {
2655 $from->{'file'} = [];
2656 $from->{'href'} = [];
2657 fill_from_file_info
($diffinfo, @parents)
2658 unless exists $diffinfo->{'from_file'};
2659 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2660 $from->{'file'}[$i] =
2661 defined $diffinfo->{'from_file'}[$i] ?
2662 $diffinfo->{'from_file'}[$i] :
2663 $diffinfo->{'to_file'};
2664 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
2665 $from->{'href'}[$i] = href
(action
=>"blob",
2666 hash_base
=>$parents[$i],
2667 hash
=>$diffinfo->{'from_id'}[$i],
2668 file_name
=>$from->{'file'}[$i]);
2670 $from->{'href'}[$i] = undef;
2674 # ordinary (not combined) diff
2675 $from->{'file'} = $diffinfo->{'from_file'};
2676 if ($diffinfo->{'status'} ne "A") { # not new (added) file
2677 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
2678 hash
=>$diffinfo->{'from_id'},
2679 file_name
=>$from->{'file'});
2681 delete $from->{'href'};
2685 $to->{'file'} = $diffinfo->{'to_file'};
2686 if (!is_deleted
($diffinfo)) { # file exists in result
2687 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
2688 hash
=>$diffinfo->{'to_id'},
2689 file_name
=>$to->{'file'});
2691 delete $to->{'href'};
2695 ## ......................................................................
2696 ## parse to array of hashes functions
2698 sub git_get_heads_list
{
2702 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2703 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
2704 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
2707 while (my $line = <$fd>) {
2711 my ($refinfo, $committerinfo) = split(/\0/, $line);
2712 my ($hash, $name, $title) = split(' ', $refinfo, 3);
2713 my ($committer, $epoch, $tz) =
2714 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
2715 $ref_item{'fullname'} = $name;
2716 $name =~ s!^refs/heads/!!;
2718 $ref_item{'name'} = $name;
2719 $ref_item{'id'} = $hash;
2720 $ref_item{'title'} = $title || '(no commit message)';
2721 $ref_item{'epoch'} = $epoch;
2723 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2725 $ref_item{'age'} = "unknown";
2728 push @headslist, \
%ref_item;
2732 return wantarray ?
@headslist : \
@headslist;
2735 sub git_get_tags_list
{
2739 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2740 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
2741 '--format=%(objectname) %(objecttype) %(refname) '.
2742 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
2745 while (my $line = <$fd>) {
2749 my ($refinfo, $creatorinfo) = split(/\0/, $line);
2750 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
2751 my ($creator, $epoch, $tz) =
2752 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
2753 $ref_item{'fullname'} = $name;
2754 $name =~ s!^refs/tags/!!;
2756 $ref_item{'type'} = $type;
2757 $ref_item{'id'} = $id;
2758 $ref_item{'name'} = $name;
2759 if ($type eq "tag") {
2760 $ref_item{'subject'} = $title;
2761 $ref_item{'reftype'} = $reftype;
2762 $ref_item{'refid'} = $refid;
2764 $ref_item{'reftype'} = $type;
2765 $ref_item{'refid'} = $id;
2768 if ($type eq "tag" || $type eq "commit") {
2769 $ref_item{'epoch'} = $epoch;
2771 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2773 $ref_item{'age'} = "unknown";
2777 push @tagslist, \
%ref_item;
2781 return wantarray ?
@tagslist : \
@tagslist;
2784 ## ----------------------------------------------------------------------
2785 ## filesystem-related functions
2787 sub get_file_owner
{
2790 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
2791 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
2792 if (!defined $gcos) {
2796 $owner =~ s/[,;].*$//;
2797 return to_utf8
($owner);
2800 # assume that file exists
2802 my $filename = shift;
2804 open my $fd, '<', $filename;
2805 print map { to_utf8
($_) } <$fd>;
2809 ## ......................................................................
2810 ## mimetype related functions
2812 sub mimetype_guess_file
{
2813 my $filename = shift;
2814 my $mimemap = shift;
2815 -r
$mimemap or return undef;
2818 open(my $mh, '<', $mimemap) or return undef;
2820 next if m/^#/; # skip comments
2821 my ($mimetype, $exts) = split(/\t+/);
2822 if (defined $exts) {
2823 my @exts = split(/\s+/, $exts);
2824 foreach my $ext (@exts) {
2825 $mimemap{$ext} = $mimetype;
2831 $filename =~ /\.([^.]*)$/;
2832 return $mimemap{$1};
2835 sub mimetype_guess
{
2836 my $filename = shift;
2838 $filename =~ /\./ or return undef;
2840 if ($mimetypes_file) {
2841 my $file = $mimetypes_file;
2842 if ($file !~ m!^/!) { # if it is relative path
2843 # it is relative to project
2844 $file = "$projectroot/$project/$file";
2846 $mime = mimetype_guess_file
($filename, $file);
2848 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
2854 my $filename = shift;
2857 my $mime = mimetype_guess
($filename);
2858 $mime and return $mime;
2862 return $default_blob_plain_mimetype unless $fd;
2865 return 'text/plain';
2866 } elsif (! $filename) {
2867 return 'application/octet-stream';
2868 } elsif ($filename =~ m/\.png$/i) {
2870 } elsif ($filename =~ m/\.gif$/i) {
2872 } elsif ($filename =~ m/\.jpe?g$/i) {
2873 return 'image/jpeg';
2875 return 'application/octet-stream';
2879 sub blob_contenttype
{
2880 my ($fd, $file_name, $type) = @_;
2882 $type ||= blob_mimetype
($fd, $file_name);
2883 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
2884 $type .= "; charset=$default_text_plain_charset";
2890 ## ======================================================================
2891 ## functions printing HTML: header, footer, error page
2893 sub git_header_html
{
2894 my $status = shift || "200 OK";
2895 my $expires = shift;
2897 my $title = "$site_name";
2898 if (defined $project) {
2899 $title .= " - " . to_utf8
($project);
2900 if (defined $action) {
2901 $title .= "/$action";
2902 if (defined $file_name) {
2903 $title .= " - " . esc_path
($file_name);
2904 if ($action eq "tree" && $file_name !~ m
|/$|) {
2911 # require explicit support from the UA if we are to send the page as
2912 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
2913 # we have to do this because MSIE sometimes globs '*/*', pretending to
2914 # support xhtml+xml but choking when it gets what it asked for.
2915 if (defined $cgi->http('HTTP_ACCEPT') &&
2916 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
2917 $cgi->Accept('application/xhtml+xml') != 0) {
2918 $content_type = 'application/xhtml+xml';
2920 $content_type = 'text/html';
2922 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
2923 -status
=> $status, -expires
=> $expires);
2924 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
2926 <?xml version="1.0" encoding="utf-8"?>
2927 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2928 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
2929 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
2930 <!-- git core binaries version $git_version -->
2932 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
2933 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
2934 <meta name="robots" content="index, nofollow"/>
2935 <title>$title</title>
2937 # the stylesheet, favicon etc urls won't work correctly with path_info
2938 # unless we set the appropriate base URL
2939 if ($ENV{'PATH_INFO'}) {
2940 print "<base href=\"".esc_url
($base_url)."\" />\n";
2942 # print out each stylesheet that exist, providing backwards capability
2943 # for those people who defined $stylesheet in a config file
2944 if (defined $stylesheet) {
2945 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2947 foreach my $stylesheet (@stylesheets) {
2948 next unless $stylesheet;
2949 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2952 if (defined $project) {
2953 my %href_params = get_feed_info
();
2954 if (!exists $href_params{'-title'}) {
2955 $href_params{'-title'} = 'log';
2958 foreach my $format qw(RSS Atom) {
2959 my $type = lc($format);
2961 '-rel' => 'alternate',
2962 '-title' => "$project - $href_params{'-title'} - $format feed",
2963 '-type' => "application/$type+xml"
2966 $href_params{'action'} = $type;
2967 $link_attr{'-href'} = href
(%href_params);
2969 "rel=\"$link_attr{'-rel'}\" ".
2970 "title=\"$link_attr{'-title'}\" ".
2971 "href=\"$link_attr{'-href'}\" ".
2972 "type=\"$link_attr{'-type'}\" ".
2975 $href_params{'extra_options'} = '--no-merges';
2976 $link_attr{'-href'} = href
(%href_params);
2977 $link_attr{'-title'} .= ' (no merges)';
2979 "rel=\"$link_attr{'-rel'}\" ".
2980 "title=\"$link_attr{'-title'}\" ".
2981 "href=\"$link_attr{'-href'}\" ".
2982 "type=\"$link_attr{'-type'}\" ".
2987 printf('<link rel="alternate" title="%s projects list" '.
2988 'href="%s" type="text/plain; charset=utf-8" />'."\n",
2989 $site_name, href
(project
=>undef, action
=>"project_index"));
2990 printf('<link rel="alternate" title="%s projects feeds" '.
2991 'href="%s" type="text/x-opml" />'."\n",
2992 $site_name, href
(project
=>undef, action
=>"opml"));
2994 if (defined $favicon) {
2995 print qq(<link rel
="shortcut icon" href
="$favicon" type
="image/png" />\n);
3001 if (-f
$site_header) {
3002 insert_file
($site_header);
3005 print "<div class=\"page_header\">\n" .
3006 $cgi->a({-href
=> esc_url
($logo_url),
3007 -title
=> $logo_label},
3008 qq(<img src
="$logo" width
="72" height
="27" alt
="git" class="logo"/>));
3009 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
3010 if (defined $project) {
3011 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
3012 if (defined $action) {
3019 my $have_search = gitweb_check_feature
('search');
3020 if (defined $project && $have_search) {
3021 if (!defined $searchtext) {
3025 if (defined $hash_base) {
3026 $search_hash = $hash_base;
3027 } elsif (defined $hash) {
3028 $search_hash = $hash;
3030 $search_hash = "HEAD";
3032 my $action = $my_uri;
3033 my $use_pathinfo = gitweb_check_feature
('pathinfo');
3034 if ($use_pathinfo) {
3035 $action .= "/".esc_url
($project);
3037 print $cgi->startform(-method
=> "get", -action
=> $action) .
3038 "<div class=\"search\">\n" .
3040 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
3041 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
3042 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
3043 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
3044 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
3045 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
3047 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
3048 "<span title=\"Extended regular expression\">" .
3049 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
3050 -checked
=> $search_use_regexp) .
3053 $cgi->end_form() . "\n";
3057 sub git_footer_html
{
3058 my $feed_class = 'rss_logo';
3060 print "<div class=\"page_footer\">\n";
3061 if (defined $project) {
3062 my $descr = git_get_project_description
($project);
3063 if (defined $descr) {
3064 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
3067 my %href_params = get_feed_info
();
3068 if (!%href_params) {
3069 $feed_class .= ' generic';
3071 $href_params{'-title'} ||= 'log';
3073 foreach my $format qw(RSS Atom) {
3074 $href_params{'action'} = lc($format);
3075 print $cgi->a({-href
=> href
(%href_params),
3076 -title
=> "$href_params{'-title'} $format feed",
3077 -class => $feed_class}, $format)."\n";
3081 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
3082 -class => $feed_class}, "OPML") . " ";
3083 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
3084 -class => $feed_class}, "TXT") . "\n";
3086 print "</div>\n"; # class="page_footer"
3088 if (-f
$site_footer) {
3089 insert_file
($site_footer);
3096 # die_error(<http_status_code>, <error_message>)
3097 # Example: die_error(404, 'Hash not found')
3098 # By convention, use the following status codes (as defined in RFC 2616):
3099 # 400: Invalid or missing CGI parameters, or
3100 # requested object exists but has wrong type.
3101 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
3102 # this server or project.
3103 # 404: Requested object/revision/project doesn't exist.
3104 # 500: The server isn't configured properly, or
3105 # an internal error occurred (e.g. failed assertions caused by bugs), or
3106 # an unknown error occurred (e.g. the git binary died unexpectedly).
3108 my $status = shift || 500;
3109 my $error = shift || "Internal server error";
3111 my %http_responses = (400 => '400 Bad Request',
3112 403 => '403 Forbidden',
3113 404 => '404 Not Found',
3114 500 => '500 Internal Server Error');
3115 git_header_html
($http_responses{$status});
3117 <div class="page_body">
3127 ## ----------------------------------------------------------------------
3128 ## functions printing or outputting HTML: navigation
3130 sub git_print_page_nav
{
3131 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3132 $extra = '' if !defined $extra; # pager or formats
3134 my @navs = qw(summary shortlog log commit commitdiff tree);
3136 @navs = grep { $_ ne $suppress } @navs;
3139 my %arg = map { $_ => {action
=>$_} } @navs;
3140 if (defined $head) {
3141 for (qw(commit commitdiff)) {
3142 $arg{$_}{'hash'} = $head;
3144 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3145 for (qw(shortlog log)) {
3146 $arg{$_}{'hash'} = $head;
3151 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3152 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3154 my @actions = gitweb_get_feature
('actions');
3157 'n' => $project, # project name
3158 'f' => $git_dir, # project path within filesystem
3159 'h' => $treehead || '', # current hash ('h' parameter)
3160 'b' => $treebase || '', # hash base ('hb' parameter)
3163 my ($label, $link, $pos) = splice(@actions,0,3);
3165 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
3167 $link =~ s/%([%nfhb])/$repl{$1}/g;
3168 $arg{$label}{'_href'} = $link;
3171 print "<div class=\"page_nav\">\n" .
3173 map { $_ eq $current ?
3174 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
3176 print "<br/>\n$extra<br/>\n" .
3180 sub format_paging_nav
{
3181 my ($action, $hash, $head, $page, $has_next_link) = @_;
3185 if ($hash ne $head || $page) {
3186 $paging_nav .= $cgi->a({-href
=> href
(action
=>$action)}, "HEAD");
3188 $paging_nav .= "HEAD";
3192 $paging_nav .= " ⋅ " .
3193 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
3194 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
3196 $paging_nav .= " ⋅ prev";
3199 if ($has_next_link) {
3200 $paging_nav .= " ⋅ " .
3201 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
3202 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
3204 $paging_nav .= " ⋅ next";
3210 ## ......................................................................
3211 ## functions printing or outputting HTML: div
3213 sub git_print_header_div
{
3214 my ($action, $title, $hash, $hash_base) = @_;
3217 $args{'action'} = $action;
3218 $args{'hash'} = $hash if $hash;
3219 $args{'hash_base'} = $hash_base if $hash_base;
3221 print "<div class=\"header\">\n" .
3222 $cgi->a({-href
=> href
(%args), -class => "title"},
3223 $title ?
$title : $action) .
3227 sub print_local_time
{
3229 if ($date{'hour_local'} < 6) {
3230 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3231 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3233 printf(" (%02d:%02d %s)",
3234 $date{'hour_local'}, $date{'minute_local'}, $date{'tz_local'});
3238 # Outputs the author name and date in long form
3239 sub git_print_authorship
{
3242 my $tag = $opts{-tag
} || 'div';
3244 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
3245 print "<$tag class=\"author_date\">" .
3246 esc_html
($co->{'author_name'}) .
3248 print_local_time
(%ad) if ($opts{-localtime});
3252 # Outputs table rows containing the full author or committer information,
3253 # in the format expected for 'commit' view (& similia).
3254 # Parameters are a commit hash reference, followed by the list of people
3255 # to output information for. If the list is empty it defalts to both
3256 # author and committer.
3257 sub git_print_authorship_rows
{
3259 # too bad we can't use @people = @_ || ('author', 'committer')
3261 @people = ('author', 'committer') unless @people;
3262 foreach my $who (@people) {
3263 my %wd = parse_date
($co->{"${who}_epoch"}, $co->{"${who}_tz"});
3264 print "<tr><td>$who</td><td>" . esc_html
($co->{$who}) . "</td></tr>\n".
3266 "<td></td><td> $wd{'rfc2822'}";
3267 print_local_time
(%wd);
3273 sub git_print_page_path
{
3279 print "<div class=\"page_path\">";
3280 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
3281 -title
=> 'tree root'}, to_utf8
("[$project]"));
3283 if (defined $name) {
3284 my @dirname = split '/', $name;
3285 my $basename = pop @dirname;
3288 foreach my $dir (@dirname) {
3289 $fullname .= ($fullname ?
'/' : '') . $dir;
3290 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
3292 -title
=> $fullname}, esc_path
($dir));
3295 if (defined $type && $type eq 'blob') {
3296 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
3298 -title
=> $name}, esc_path
($basename));
3299 } elsif (defined $type && $type eq 'tree') {
3300 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
3302 -title
=> $name}, esc_path
($basename));
3305 print esc_path
($basename);
3308 print "<br/></div>\n";
3315 if ($opts{'-remove_title'}) {
3316 # remove title, i.e. first line of log
3319 # remove leading empty lines
3320 while (defined $log->[0] && $log->[0] eq "") {
3327 foreach my $line (@
$log) {
3328 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3331 if (! $opts{'-remove_signoff'}) {
3332 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
3335 # remove signoff lines
3342 # print only one empty line
3343 # do not print empty line after signoff
3345 next if ($empty || $signoff);
3351 print format_log_line_html
($line) . "<br/>\n";
3354 if ($opts{'-final_empty_line'}) {
3355 # end with single empty line
3356 print "<br/>\n" unless $empty;
3360 # return link target (what link points to)
3361 sub git_get_link_target
{
3366 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
3370 $link_target = <$fd>;
3375 return $link_target;
3378 # given link target, and the directory (basedir) the link is in,
3379 # return target of link relative to top directory (top tree);
3380 # return undef if it is not possible (including absolute links).
3381 sub normalize_link_target
{
3382 my ($link_target, $basedir) = @_;
3384 # absolute symlinks (beginning with '/') cannot be normalized
3385 return if (substr($link_target, 0, 1) eq '/');
3387 # normalize link target to path from top (root) tree (dir)
3390 $path = $basedir . '/' . $link_target;
3392 # we are in top (root) tree (dir)
3393 $path = $link_target;
3396 # remove //, /./, and /../
3398 foreach my $part (split('/', $path)) {
3399 # discard '.' and ''
3400 next if (!$part || $part eq '.');
3402 if ($part eq '..') {
3406 # link leads outside repository (outside top dir)
3410 push @path_parts, $part;
3413 $path = join('/', @path_parts);
3418 # print tree entry (row of git_tree), but without encompassing <tr> element
3419 sub git_print_tree_entry
{
3420 my ($t, $basedir, $hash_base, $have_blame) = @_;
3423 $base_key{'hash_base'} = $hash_base if defined $hash_base;
3425 # The format of a table row is: mode list link. Where mode is
3426 # the mode of the entry, list is the name of the entry, an href,
3427 # and link is the action links of the entry.
3429 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
3430 if ($t->{'type'} eq "blob") {
3431 print "<td class=\"list\">" .
3432 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3433 file_name
=>"$basedir$t->{'name'}", %base_key),
3434 -class => "list"}, esc_path
($t->{'name'}));
3435 if (S_ISLNK
(oct $t->{'mode'})) {
3436 my $link_target = git_get_link_target
($t->{'hash'});
3438 my $norm_target = normalize_link_target
($link_target, $basedir);
3439 if (defined $norm_target) {
3441 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
3442 file_name
=>$norm_target),
3443 -title
=> $norm_target}, esc_path
($link_target));
3445 print " -> " . esc_path
($link_target);
3450 print "<td class=\"link\">";
3451 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3452 file_name
=>"$basedir$t->{'name'}", %base_key)},
3456 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
3457 file_name
=>"$basedir$t->{'name'}", %base_key)},
3460 if (defined $hash_base) {
3462 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3463 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
3467 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
3468 file_name
=>"$basedir$t->{'name'}")},
3472 } elsif ($t->{'type'} eq "tree") {
3473 print "<td class=\"list\">";
3474 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3475 file_name
=>"$basedir$t->{'name'}", %base_key)},
3476 esc_path
($t->{'name'}));
3478 print "<td class=\"link\">";
3479 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3480 file_name
=>"$basedir$t->{'name'}", %base_key)},
3482 if (defined $hash_base) {
3484 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3485 file_name
=>"$basedir$t->{'name'}")},
3490 # unknown object: we can only present history for it
3491 # (this includes 'commit' object, i.e. submodule support)
3492 print "<td class=\"list\">" .
3493 esc_path
($t->{'name'}) .
3495 print "<td class=\"link\">";
3496 if (defined $hash_base) {
3497 print $cgi->a({-href
=> href
(action
=>"history",
3498 hash_base
=>$hash_base,
3499 file_name
=>"$basedir$t->{'name'}")},
3506 ## ......................................................................
3507 ## functions printing large fragments of HTML
3509 # get pre-image filenames for merge (combined) diff
3510 sub fill_from_file_info
{
3511 my ($diff, @parents) = @_;
3513 $diff->{'from_file'} = [ ];
3514 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
3515 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3516 if ($diff->{'status'}[$i] eq 'R' ||
3517 $diff->{'status'}[$i] eq 'C') {
3518 $diff->{'from_file'}[$i] =
3519 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
3526 # is current raw difftree line of file deletion
3528 my $diffinfo = shift;
3530 return $diffinfo->{'to_id'} eq ('0' x
40);
3533 # does patch correspond to [previous] difftree raw line
3534 # $diffinfo - hashref of parsed raw diff format
3535 # $patchinfo - hashref of parsed patch diff format
3536 # (the same keys as in $diffinfo)
3537 sub is_patch_split
{
3538 my ($diffinfo, $patchinfo) = @_;
3540 return defined $diffinfo && defined $patchinfo
3541 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
3545 sub git_difftree_body
{
3546 my ($difftree, $hash, @parents) = @_;
3547 my ($parent) = $parents[0];
3548 my $have_blame = gitweb_check_feature
('blame');
3549 print "<div class=\"list_head\">\n";
3550 if ($#{$difftree} > 10) {
3551 print(($#{$difftree} + 1) . " files changed:\n");
3555 print "<table class=\"" .
3556 (@parents > 1 ?
"combined " : "") .
3559 # header only for combined diff in 'commitdiff' view
3560 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
3563 print "<thead><tr>\n" .
3564 "<th></th><th></th>\n"; # filename, patchN link
3565 for (my $i = 0; $i < @parents; $i++) {
3566 my $par = $parents[$i];
3568 $cgi->a({-href
=> href
(action
=>"commitdiff",
3569 hash
=>$hash, hash_parent
=>$par),
3570 -title
=> 'commitdiff to parent number ' .
3571 ($i+1) . ': ' . substr($par,0,7)},
3575 print "</tr></thead>\n<tbody>\n";
3580 foreach my $line (@
{$difftree}) {
3581 my $diff = parsed_difftree_line
($line);
3584 print "<tr class=\"dark\">\n";
3586 print "<tr class=\"light\">\n";
3590 if (exists $diff->{'nparents'}) { # combined diff
3592 fill_from_file_info
($diff, @parents)
3593 unless exists $diff->{'from_file'};
3595 if (!is_deleted
($diff)) {
3596 # file exists in the result (child) commit
3598 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3599 file_name
=>$diff->{'to_file'},
3601 -class => "list"}, esc_path
($diff->{'to_file'})) .
3605 esc_path
($diff->{'to_file'}) .
3609 if ($action eq 'commitdiff') {
3612 print "<td class=\"link\">" .
3613 $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3618 my $has_history = 0;
3619 my $not_deleted = 0;
3620 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3621 my $hash_parent = $parents[$i];
3622 my $from_hash = $diff->{'from_id'}[$i];
3623 my $from_path = $diff->{'from_file'}[$i];
3624 my $status = $diff->{'status'}[$i];
3626 $has_history ||= ($status ne 'A');
3627 $not_deleted ||= ($status ne 'D');
3629 if ($status eq 'A') {
3630 print "<td class=\"link\" align=\"right\"> | </td>\n";
3631 } elsif ($status eq 'D') {
3632 print "<td class=\"link\">" .
3633 $cgi->a({-href
=> href
(action
=>"blob",
3636 file_name
=>$from_path)},
3640 if ($diff->{'to_id'} eq $from_hash) {
3641 print "<td class=\"link nochange\">";
3643 print "<td class=\"link\">";
3645 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3646 hash
=>$diff->{'to_id'},
3647 hash_parent
=>$from_hash,
3649 hash_parent_base
=>$hash_parent,
3650 file_name
=>$diff->{'to_file'},
3651 file_parent
=>$from_path)},
3657 print "<td class=\"link\">";
3659 print $cgi->a({-href
=> href
(action
=>"blob",
3660 hash
=>$diff->{'to_id'},
3661 file_name
=>$diff->{'to_file'},
3664 print " | " if ($has_history);
3667 print $cgi->a({-href
=> href
(action
=>"history",
3668 file_name
=>$diff->{'to_file'},
3675 next; # instead of 'else' clause, to avoid extra indent
3677 # else ordinary diff
3679 my ($to_mode_oct, $to_mode_str, $to_file_type);
3680 my ($from_mode_oct, $from_mode_str, $from_file_type);
3681 if ($diff->{'to_mode'} ne ('0' x
6)) {
3682 $to_mode_oct = oct $diff->{'to_mode'};
3683 if (S_ISREG
($to_mode_oct)) { # only for regular file
3684 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
3686 $to_file_type = file_type
($diff->{'to_mode'});
3688 if ($diff->{'from_mode'} ne ('0' x
6)) {
3689 $from_mode_oct = oct $diff->{'from_mode'};
3690 if (S_ISREG
($to_mode_oct)) { # only for regular file
3691 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
3693 $from_file_type = file_type
($diff->{'from_mode'});
3696 if ($diff->{'status'} eq "A") { # created
3697 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
3698 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
3699 $mode_chng .= "]</span>";
3701 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3702 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3703 -class => "list"}, esc_path
($diff->{'file'}));
3705 print "<td>$mode_chng</td>\n";
3706 print "<td class=\"link\">";
3707 if ($action eq 'commitdiff') {
3710 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3713 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3714 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3718 } elsif ($diff->{'status'} eq "D") { # deleted
3719 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
3721 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3722 hash_base
=>$parent, file_name
=>$diff->{'file'}),
3723 -class => "list"}, esc_path
($diff->{'file'}));
3725 print "<td>$mode_chng</td>\n";
3726 print "<td class=\"link\">";
3727 if ($action eq 'commitdiff') {
3730 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3733 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3734 hash_base
=>$parent, file_name
=>$diff->{'file'})},
3737 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
3738 file_name
=>$diff->{'file'})},
3741 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
3742 file_name
=>$diff->{'file'})},
3746 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
3747 my $mode_chnge = "";
3748 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3749 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
3750 if ($from_file_type ne $to_file_type) {
3751 $mode_chnge .= " from $from_file_type to $to_file_type";
3753 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
3754 if ($from_mode_str && $to_mode_str) {
3755 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
3756 } elsif ($to_mode_str) {
3757 $mode_chnge .= " mode: $to_mode_str";
3760 $mode_chnge .= "]</span>\n";
3763 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3764 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3765 -class => "list"}, esc_path
($diff->{'file'}));
3767 print "<td>$mode_chnge</td>\n";
3768 print "<td class=\"link\">";
3769 if ($action eq 'commitdiff') {
3772 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3774 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3775 # "commit" view and modified file (not onlu mode changed)
3776 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3777 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3778 hash_base
=>$hash, hash_parent_base
=>$parent,
3779 file_name
=>$diff->{'file'})},
3783 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3784 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3787 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3788 file_name
=>$diff->{'file'})},
3791 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3792 file_name
=>$diff->{'file'})},
3796 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
3797 my %status_name = ('R' => 'moved', 'C' => 'copied');
3798 my $nstatus = $status_name{$diff->{'status'}};
3800 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3801 # mode also for directories, so we cannot use $to_mode_str
3802 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
3805 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
3806 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
3807 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
3808 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
3809 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
3810 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
3811 -class => "list"}, esc_path
($diff->{'from_file'})) .
3812 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
3813 "<td class=\"link\">";
3814 if ($action eq 'commitdiff') {
3817 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3819 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3820 # "commit" view and modified file (not only pure rename or copy)
3821 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3822 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3823 hash_base
=>$hash, hash_parent_base
=>$parent,
3824 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
3828 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3829 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
3832 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3833 file_name
=>$diff->{'to_file'})},
3836 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3837 file_name
=>$diff->{'to_file'})},
3841 } # we should not encounter Unmerged (U) or Unknown (X) status
3844 print "</tbody>" if $has_header;
3848 sub git_patchset_body
{
3849 my ($fd, $difftree, $hash, @hash_parents) = @_;
3850 my ($hash_parent) = $hash_parents[0];
3852 my $is_combined = (@hash_parents > 1);
3854 my $patch_number = 0;
3860 print "<div class=\"patchset\">\n";
3862 # skip to first patch
3863 while ($patch_line = <$fd>) {
3866 last if ($patch_line =~ m/^diff /);
3870 while ($patch_line) {
3872 # parse "git diff" header line
3873 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
3874 # $1 is from_name, which we do not use
3875 $to_name = unquote
($2);
3876 $to_name =~ s!^b/!!;
3877 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
3878 # $1 is 'cc' or 'combined', which we do not use
3879 $to_name = unquote
($2);
3884 # check if current patch belong to current raw line
3885 # and parse raw git-diff line if needed
3886 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
3887 # this is continuation of a split patch
3888 print "<div class=\"patch cont\">\n";
3890 # advance raw git-diff output if needed
3891 $patch_idx++ if defined $diffinfo;
3893 # read and prepare patch information
3894 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3896 # compact combined diff output can have some patches skipped
3897 # find which patch (using pathname of result) we are at now;
3899 while ($to_name ne $diffinfo->{'to_file'}) {
3900 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3901 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3902 "</div>\n"; # class="patch"
3907 last if $patch_idx > $#$difftree;
3908 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3912 # modifies %from, %to hashes
3913 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
3915 # this is first patch for raw difftree line with $patch_idx index
3916 # we index @$difftree array from 0, but number patches from 1
3917 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
3921 #assert($patch_line =~ m/^diff /) if DEBUG;
3922 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
3924 # print "git diff" header
3925 print format_git_diff_header_line
($patch_line, $diffinfo,
3928 # print extended diff header
3929 print "<div class=\"diff extended_header\">\n";
3931 while ($patch_line = <$fd>) {
3934 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
3936 print format_extended_diff_header_line
($patch_line, $diffinfo,
3939 print "</div>\n"; # class="diff extended_header"
3941 # from-file/to-file diff header
3942 if (! $patch_line) {
3943 print "</div>\n"; # class="patch"
3946 next PATCH
if ($patch_line =~ m/^diff /);
3947 #assert($patch_line =~ m/^---/) if DEBUG;
3949 my $last_patch_line = $patch_line;
3950 $patch_line = <$fd>;
3952 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
3954 print format_diff_from_to_header
($last_patch_line, $patch_line,
3955 $diffinfo, \
%from, \
%to,
3960 while ($patch_line = <$fd>) {
3963 next PATCH
if ($patch_line =~ m/^diff /);
3965 print format_diff_line
($patch_line, \
%from, \
%to);
3969 print "</div>\n"; # class="patch"
3972 # for compact combined (--cc) format, with chunk and patch simpliciaction
3973 # patchset might be empty, but there might be unprocessed raw lines
3974 for (++$patch_idx if $patch_number > 0;
3975 $patch_idx < @
$difftree;
3977 # read and prepare patch information
3978 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3980 # generate anchor for "patch" links in difftree / whatchanged part
3981 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3982 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3983 "</div>\n"; # class="patch"
3988 if ($patch_number == 0) {
3989 if (@hash_parents > 1) {
3990 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
3992 print "<div class=\"diff nodifferences\">No differences found</div>\n";
3996 print "</div>\n"; # class="patchset"
3999 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4001 # fills project list info (age, description, owner, forks) for each
4002 # project in the list, removing invalid projects from returned list
4003 # NOTE: modifies $projlist, but does not remove entries from it
4004 sub fill_project_list_info
{
4005 my ($projlist, $check_forks) = @_;
4008 my $show_ctags = gitweb_check_feature
('ctags');
4010 foreach my $pr (@
$projlist) {
4011 my (@activity) = git_get_last_activity
($pr->{'path'});
4012 unless (@activity) {
4015 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
4016 if (!defined $pr->{'descr'}) {
4017 my $descr = git_get_project_description
($pr->{'path'}) || "";
4018 $descr = to_utf8
($descr);
4019 $pr->{'descr_long'} = $descr;
4020 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
4022 if (!defined $pr->{'owner'}) {
4023 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
4026 my $pname = $pr->{'path'};
4027 if (($pname =~ s/\.git$//) &&
4028 ($pname !~ /\/$/) &&
4029 (-d
"$projectroot/$pname")) {
4030 $pr->{'forks'} = "-d $projectroot/$pname";
4035 $show_ctags and $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
4036 push @projects, $pr;
4042 # print 'sort by' <th> element, generating 'sort by $name' replay link
4043 # if that order is not selected
4045 my ($name, $order, $header) = @_;
4046 $header ||= ucfirst($name);
4048 if ($order eq $name) {
4049 print "<th>$header</th>\n";
4052 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
4053 -class => "header"}, $header) .
4058 sub git_project_list_body
{
4059 # actually uses global variable $project
4060 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
4062 my $check_forks = gitweb_check_feature
('forks');
4063 my @projects = fill_project_list_info
($projlist, $check_forks);
4065 $order ||= $default_projects_order;
4066 $from = 0 unless defined $from;
4067 $to = $#projects if (!defined $to || $#projects < $to);
4070 project
=> { key
=> 'path', type
=> 'str' },
4071 descr
=> { key
=> 'descr_long', type
=> 'str' },
4072 owner
=> { key
=> 'owner', type
=> 'str' },
4073 age
=> { key
=> 'age', type
=> 'num' }
4075 my $oi = $order_info{$order};
4076 if ($oi->{'type'} eq 'str') {
4077 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
4079 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
4082 my $show_ctags = gitweb_check_feature
('ctags');
4085 foreach my $p (@projects) {
4086 foreach my $ct (keys %{$p->{'ctags'}}) {
4087 $ctags{$ct} += $p->{'ctags'}->{$ct};
4090 my $cloud = git_populate_project_tagcloud
(\
%ctags);
4091 print git_show_project_tagcloud
($cloud, 64);
4094 print "<table class=\"project_list\">\n";
4095 unless ($no_header) {
4098 print "<th></th>\n";
4100 print_sort_th
('project', $order, 'Project');
4101 print_sort_th
('descr', $order, 'Description');
4102 print_sort_th
('owner', $order, 'Owner');
4103 print_sort_th
('age', $order, 'Last Change');
4104 print "<th></th>\n" . # for links
4108 my $tagfilter = $cgi->param('by_tag');
4109 for (my $i = $from; $i <= $to; $i++) {
4110 my $pr = $projects[$i];
4112 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
4113 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
4114 and not $pr->{'descr_long'} =~ /$searchtext/;
4115 # Weed out forks or non-matching entries of search
4117 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s
#\.git$#/#;
4118 $forkbase="^$forkbase" if $forkbase;
4119 next if not $searchtext and not $tagfilter and $show_ctags
4120 and $pr->{'path'} =~ m
#$forkbase.*/.*#; # regexp-safe
4124 print "<tr class=\"dark\">\n";
4126 print "<tr class=\"light\">\n";
4131 if ($pr->{'forks'}) {
4132 print "<!-- $pr->{'forks'} -->\n";
4133 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "+");
4137 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4138 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
4139 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
4140 -class => "list", -title
=> $pr->{'descr_long'}},
4141 esc_html
($pr->{'descr'})) . "</td>\n" .
4142 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
4143 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
4144 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
4145 "<td class=\"link\">" .
4146 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
4147 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
4148 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
4149 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
4150 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
4154 if (defined $extra) {
4157 print "<td></td>\n";
4159 print "<td colspan=\"5\">$extra</td>\n" .
4165 sub git_shortlog_body
{
4166 # uses global variable $project
4167 my ($commitlist, $from, $to, $refs, $extra) = @_;
4169 $from = 0 unless defined $from;
4170 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4172 print "<table class=\"shortlog\">\n";
4174 for (my $i = $from; $i <= $to; $i++) {
4175 my %co = %{$commitlist->[$i]};
4176 my $commit = $co{'id'};
4177 my $ref = format_ref_marker
($refs, $commit);
4179 print "<tr class=\"dark\">\n";
4181 print "<tr class=\"light\">\n";
4184 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4185 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4186 format_author_html
('td', \
%co, 10) . "<td>";
4187 print format_subject_html
($co{'title'}, $co{'title_short'},
4188 href
(action
=>"commit", hash
=>$commit), $ref);
4190 "<td class=\"link\">" .
4191 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
4192 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
4193 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
4194 my $snapshot_links = format_snapshot_links
($commit);
4195 if (defined $snapshot_links) {
4196 print " | " . $snapshot_links;
4201 if (defined $extra) {
4203 "<td colspan=\"4\">$extra</td>\n" .
4209 sub git_history_body
{
4210 # Warning: assumes constant type (blob or tree) during history
4211 my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
4213 $from = 0 unless defined $from;
4214 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
4216 print "<table class=\"history\">\n";
4218 for (my $i = $from; $i <= $to; $i++) {
4219 my %co = %{$commitlist->[$i]};
4223 my $commit = $co{'id'};
4225 my $ref = format_ref_marker
($refs, $commit);
4228 print "<tr class=\"dark\">\n";
4230 print "<tr class=\"light\">\n";
4233 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4234 # shortlog: format_author_html('td', \%co, 10)
4235 format_author_html
('td', \
%co, 15, 3) . "<td>";
4236 # originally git_history used chop_str($co{'title'}, 50)
4237 print format_subject_html
($co{'title'}, $co{'title_short'},
4238 href
(action
=>"commit", hash
=>$commit), $ref);
4240 "<td class=\"link\">" .
4241 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
4242 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
4244 if ($ftype eq 'blob') {
4245 my $blob_current = git_get_hash_by_path
($hash_base, $file_name);
4246 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
4247 if (defined $blob_current && defined $blob_parent &&
4248 $blob_current ne $blob_parent) {
4250 $cgi->a({-href
=> href
(action
=>"blobdiff",
4251 hash
=>$blob_current, hash_parent
=>$blob_parent,
4252 hash_base
=>$hash_base, hash_parent_base
=>$commit,
4253 file_name
=>$file_name)},
4260 if (defined $extra) {
4262 "<td colspan=\"4\">$extra</td>\n" .
4269 # uses global variable $project
4270 my ($taglist, $from, $to, $extra) = @_;
4271 $from = 0 unless defined $from;
4272 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
4274 print "<table class=\"tags\">\n";
4276 for (my $i = $from; $i <= $to; $i++) {
4277 my $entry = $taglist->[$i];
4279 my $comment = $tag{'subject'};
4281 if (defined $comment) {
4282 $comment_short = chop_str
($comment, 30, 5);
4285 print "<tr class=\"dark\">\n";
4287 print "<tr class=\"light\">\n";
4290 if (defined $tag{'age'}) {
4291 print "<td><i>$tag{'age'}</i></td>\n";
4293 print "<td></td>\n";
4296 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
4297 -class => "list name"}, esc_html
($tag{'name'})) .
4300 if (defined $comment) {
4301 print format_subject_html
($comment, $comment_short,
4302 href
(action
=>"tag", hash
=>$tag{'id'}));
4305 "<td class=\"selflink\">";
4306 if ($tag{'type'} eq "tag") {
4307 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
4312 "<td class=\"link\">" . " | " .
4313 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
4314 if ($tag{'reftype'} eq "commit") {
4315 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
4316 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
4317 } elsif ($tag{'reftype'} eq "blob") {
4318 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
4323 if (defined $extra) {
4325 "<td colspan=\"5\">$extra</td>\n" .
4331 sub git_heads_body
{
4332 # uses global variable $project
4333 my ($headlist, $head, $from, $to, $extra) = @_;
4334 $from = 0 unless defined $from;
4335 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4337 print "<table class=\"heads\">\n";
4339 for (my $i = $from; $i <= $to; $i++) {
4340 my $entry = $headlist->[$i];
4342 my $curr = $ref{'id'} eq $head;
4344 print "<tr class=\"dark\">\n";
4346 print "<tr class=\"light\">\n";
4349 print "<td><i>$ref{'age'}</i></td>\n" .
4350 ($curr ?
"<td class=\"current_head\">" : "<td>") .
4351 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
4352 -class => "list name"},esc_html
($ref{'name'})) .
4354 "<td class=\"link\">" .
4355 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
4356 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
4357 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'name'})}, "tree") .
4361 if (defined $extra) {
4363 "<td colspan=\"3\">$extra</td>\n" .
4369 sub git_search_grep_body
{
4370 my ($commitlist, $from, $to, $extra) = @_;
4371 $from = 0 unless defined $from;
4372 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4374 print "<table class=\"commit_search\">\n";
4376 for (my $i = $from; $i <= $to; $i++) {
4377 my %co = %{$commitlist->[$i]};
4381 my $commit = $co{'id'};
4383 print "<tr class=\"dark\">\n";
4385 print "<tr class=\"light\">\n";
4388 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4389 format_author_html
('td', \
%co, 15, 5) .
4391 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
4392 -class => "list subject"},
4393 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
4394 my $comment = $co{'comment'};
4395 foreach my $line (@
$comment) {
4396 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
4397 my ($lead, $match, $trail) = ($1, $2, $3);
4398 $match = chop_str
($match, 70, 5, 'center');
4399 my $contextlen = int((80 - length($match))/2);
4400 $contextlen = 30 if ($contextlen > 30);
4401 $lead = chop_str
($lead, $contextlen, 10, 'left');
4402 $trail = chop_str
($trail, $contextlen, 10, 'right');
4404 $lead = esc_html
($lead);
4405 $match = esc_html
($match);
4406 $trail = esc_html
($trail);
4408 print "$lead<span class=\"match\">$match</span>$trail<br />";
4412 "<td class=\"link\">" .
4413 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
4415 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
4417 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
4421 if (defined $extra) {
4423 "<td colspan=\"3\">$extra</td>\n" .
4429 ## ======================================================================
4430 ## ======================================================================
4433 sub git_project_list
{
4434 my $order = $input_params{'order'};
4435 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4436 die_error
(400, "Unknown order parameter");
4439 my @list = git_get_projects_list
();
4441 die_error
(404, "No projects found");
4445 if (-f
$home_text) {
4446 print "<div class=\"index_include\">\n";
4447 insert_file
($home_text);
4450 print $cgi->startform(-method
=> "get") .
4451 "<p class=\"projsearch\">Search:\n" .
4452 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
4454 $cgi->end_form() . "\n";
4455 git_project_list_body
(\
@list, $order);
4460 my $order = $input_params{'order'};
4461 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4462 die_error
(400, "Unknown order parameter");
4465 my @list = git_get_projects_list
($project);
4467 die_error
(404, "No forks found");
4471 git_print_page_nav
('','');
4472 git_print_header_div
('summary', "$project forks");
4473 git_project_list_body
(\
@list, $order);
4477 sub git_project_index
{
4478 my @projects = git_get_projects_list
($project);
4481 -type
=> 'text/plain',
4482 -charset
=> 'utf-8',
4483 -content_disposition
=> 'inline; filename="index.aux"');
4485 foreach my $pr (@projects) {
4486 if (!exists $pr->{'owner'}) {
4487 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
4490 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
4491 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
4492 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4493 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4497 print "$path $owner\n";
4502 my $descr = git_get_project_description
($project) || "none";
4503 my %co = parse_commit
("HEAD");
4504 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
4505 my $head = $co{'id'};
4507 my $owner = git_get_project_owner
($project);
4509 my $refs = git_get_references
();
4510 # These get_*_list functions return one more to allow us to see if
4511 # there are more ...
4512 my @taglist = git_get_tags_list
(16);
4513 my @headlist = git_get_heads_list
(16);
4515 my $check_forks = gitweb_check_feature
('forks');
4518 @forklist = git_get_projects_list
($project);
4522 git_print_page_nav
('summary','', $head);
4524 print "<div class=\"title\"> </div>\n";
4525 print "<table class=\"projects_list\">\n" .
4526 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
4527 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
4528 if (defined $cd{'rfc2822'}) {
4529 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
4532 # use per project git URL list in $projectroot/$project/cloneurl
4533 # or make project git URL from git base URL and project name
4534 my $url_tag = "URL";
4535 my @url_list = git_get_project_url_list
($project);
4536 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
4537 foreach my $git_url (@url_list) {
4538 next unless $git_url;
4539 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
4544 my $show_ctags = gitweb_check_feature
('ctags');
4546 my $ctags = git_get_project_ctags
($project);
4547 my $cloud = git_populate_project_tagcloud
($ctags);
4548 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
4549 print "</td>\n<td>" unless %$ctags;
4550 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
4551 print "</td>\n<td>" if %$ctags;
4552 print git_show_project_tagcloud
($cloud, 48);
4558 # If XSS prevention is on, we don't include README.html.
4559 # TODO: Allow a readme in some safe format.
4560 if (!$prevent_xss && -s
"$projectroot/$project/README.html") {
4561 print "<div class=\"title\">readme</div>\n" .
4562 "<div class=\"readme\">\n";
4563 insert_file
("$projectroot/$project/README.html");
4564 print "\n</div>\n"; # class="readme"
4567 # we need to request one more than 16 (0..15) to check if
4569 my @commitlist = $head ? parse_commits
($head, 17) : ();
4571 git_print_header_div
('shortlog');
4572 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
4573 $#commitlist <= 15 ?
undef :
4574 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
4578 git_print_header_div
('tags');
4579 git_tags_body
(\
@taglist, 0, 15,
4580 $#taglist <= 15 ?
undef :
4581 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
4585 git_print_header_div
('heads');
4586 git_heads_body
(\
@headlist, $head, 0, 15,
4587 $#headlist <= 15 ?
undef :
4588 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
4592 git_print_header_div
('forks');
4593 git_project_list_body
(\
@forklist, 'age', 0, 15,
4594 $#forklist <= 15 ?
undef :
4595 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
4603 my $head = git_get_head_hash
($project);
4605 git_print_page_nav
('','', $head,undef,$head);
4606 my %tag = parse_tag
($hash);
4609 die_error
(404, "Unknown tag object");
4612 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
4613 print "<div class=\"title_text\">\n" .
4614 "<table class=\"object_header\">\n" .
4616 "<td>object</td>\n" .
4617 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4618 $tag{'object'}) . "</td>\n" .
4619 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4620 $tag{'type'}) . "</td>\n" .
4622 if (defined($tag{'author'})) {
4623 my %ad = parse_date
($tag{'epoch'}, $tag{'tz'});
4624 print "<tr><td>author</td><td>" . esc_html
($tag{'author'}) . "</td></tr>\n";
4625 print "<tr><td></td><td>" . $ad{'rfc2822'} .
4626 sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
4629 print "</table>\n\n" .
4631 print "<div class=\"page_body\">";
4632 my $comment = $tag{'comment'};
4633 foreach my $line (@
$comment) {
4635 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
4643 gitweb_check_feature
('blame')
4644 or die_error
(403, "Blame view not allowed");
4647 die_error
(400, "No file name given") unless $file_name;
4648 $hash_base ||= git_get_head_hash
($project);
4649 die_error
(404, "Couldn't find base commit") unless $hash_base;
4650 my %co = parse_commit
($hash_base)
4651 or die_error
(404, "Commit not found");
4653 if (!defined $hash) {
4654 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
4655 or die_error
(404, "Error looking up file");
4657 $ftype = git_get_type
($hash);
4658 if ($ftype !~ "blob") {
4659 die_error
(400, "Object is not a blob");
4663 # run git-blame --porcelain
4664 open my $fd, "-|", git_cmd
(), "blame", '-p',
4665 $hash_base, '--', $file_name
4666 or die_error
(500, "Open git-blame failed");
4671 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
4674 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4677 $cgi->a({-href
=> href
(action
=>"blame", file_name
=>$file_name)},
4679 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4680 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4681 git_print_page_path
($file_name, $ftype, $hash_base);
4684 my @rev_color = qw(light2 dark2);
4685 my $num_colors = scalar(@rev_color);
4686 my $current_color = 0;
4690 <div class="page_body">
4691 <table class="blame">
4692 <tr><th>Commit</th><th>Line</th><th>Data</th></tr>
4695 while (my $line = <$fd>) {
4697 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
4698 # no <lines in group> for subsequent lines in group of lines
4699 my ($full_rev, $orig_lineno, $lineno, $group_size) =
4700 ($line =~ /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/);
4701 if (!exists $metainfo{$full_rev}) {
4702 $metainfo{$full_rev} = {};
4704 my $meta = $metainfo{$full_rev};
4706 while ($data = <$fd>) {
4708 last if ($data =~ s/^\t//); # contents of line
4709 if ($data =~ /^(\S+) (.*)$/) {
4713 my $short_rev = substr($full_rev, 0, 8);
4714 my $author = $meta->{'author'};
4716 parse_date
($meta->{'author-time'}, $meta->{'author-tz'});
4717 my $date = $date{'iso-tz'};
4719 $current_color = ($current_color + 1) % $num_colors;
4721 print "<tr id=\"l$lineno\" class=\"$rev_color[$current_color]\">\n";
4723 print "<td class=\"sha1\"";
4724 print " title=\"". esc_html
($author) . ", $date\"";
4725 print " rowspan=\"$group_size\"" if ($group_size > 1);
4727 print $cgi->a({-href
=> href
(action
=>"commit",
4729 file_name
=>$file_name)},
4730 esc_html
($short_rev));
4734 if (!exists $meta->{'parent'}) {
4735 open (my $dd, "-|", git_cmd
(), "rev-parse", "$full_rev^")
4736 or die_error
(500, "Open git-rev-parse failed");
4737 $parent_commit = <$dd>;
4739 chomp($parent_commit);
4740 $meta->{'parent'} = $parent_commit;
4742 $parent_commit = $meta->{'parent'};
4744 my $blamed = href
(action
=> 'blame',
4745 file_name
=> $meta->{'filename'},
4746 hash_base
=> $parent_commit);
4747 print "<td class=\"linenr\">";
4748 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
4749 -class => "linenr" },
4752 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
4758 or print "Reading blob failed\n";
4765 my $head = git_get_head_hash
($project);
4767 git_print_page_nav
('','', $head,undef,$head);
4768 git_print_header_div
('summary', $project);
4770 my @tagslist = git_get_tags_list
();
4772 git_tags_body
(\
@tagslist);
4778 my $head = git_get_head_hash
($project);
4780 git_print_page_nav
('','', $head,undef,$head);
4781 git_print_header_div
('summary', $project);
4783 my @headslist = git_get_heads_list
();
4785 git_heads_body
(\
@headslist, $head);
4790 sub git_blob_plain
{
4794 if (!defined $hash) {
4795 if (defined $file_name) {
4796 my $base = $hash_base || git_get_head_hash
($project);
4797 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4798 or die_error
(404, "Cannot find file");
4800 die_error
(400, "No file name defined");
4802 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4803 # blobs defined by non-textual hash id's can be cached
4807 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4808 or die_error
(500, "Open git-cat-file blob '$hash' failed");
4810 # content-type (can include charset)
4811 $type = blob_contenttype
($fd, $file_name, $type);
4813 # "save as" filename, even when no $file_name is given
4814 my $save_as = "$hash";
4815 if (defined $file_name) {
4816 $save_as = $file_name;
4817 } elsif ($type =~ m/^text\//) {
4821 # With XSS prevention on, blobs of all types except a few known safe
4822 # ones are served with "Content-Disposition: attachment" to make sure
4823 # they don't run in our security domain. For certain image types,
4824 # blob view writes an <img> tag referring to blob_plain view, and we
4825 # want to be sure not to break that by serving the image as an
4826 # attachment (though Firefox 3 doesn't seem to care).
4827 my $sandbox = $prevent_xss &&
4828 $type !~ m!^(?:text/plain|image/(?:gif|png|jpeg))$!;
4832 -expires
=> $expires,
4833 -content_disposition
=>
4834 ($sandbox ?
'attachment' : 'inline')
4835 . '; filename="' . $save_as . '"');
4837 binmode STDOUT
, ':raw';
4839 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
4846 if (!defined $hash) {
4847 if (defined $file_name) {
4848 my $base = $hash_base || git_get_head_hash
($project);
4849 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4850 or die_error
(404, "Cannot find file");
4852 die_error
(400, "No file name defined");
4854 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4855 # blobs defined by non-textual hash id's can be cached
4859 my $have_blame = gitweb_check_feature
('blame');
4860 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4861 or die_error
(500, "Couldn't cat $file_name, $hash");
4862 my $mimetype = blob_mimetype
($fd, $file_name);
4863 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
4865 return git_blob_plain
($mimetype);
4867 # we can have blame only for text/* mimetype
4868 $have_blame &&= ($mimetype =~ m!^text/!);
4870 git_header_html
(undef, $expires);
4871 my $formats_nav = '';
4872 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4873 if (defined $file_name) {
4876 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
4881 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4884 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4887 $cgi->a({-href
=> href
(action
=>"blob",
4888 hash_base
=>"HEAD", file_name
=>$file_name)},
4892 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4895 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4896 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4898 print "<div class=\"page_nav\">\n" .
4899 "<br/><br/></div>\n" .
4900 "<div class=\"title\">$hash</div>\n";
4902 git_print_page_path
($file_name, "blob", $hash_base);
4903 print "<div class=\"page_body\">\n";
4904 if ($mimetype =~ m!^image/!) {
4905 print qq!<img type
="$mimetype"!;
4907 print qq! alt
="$file_name" title
="$file_name"!;
4910 href(action=>"blob_plain
", hash=>$hash,
4911 hash_base=>$hash_base, file_name=>$file_name) .
4915 while (my $line = <$fd>) {
4918 $line = untabify
($line);
4919 printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
4920 $nr, $nr, $nr, esc_html
($line, -nbsp
=>1);
4924 or print "Reading blob failed.\n";
4930 if (!defined $hash_base) {
4931 $hash_base = "HEAD";
4933 if (!defined $hash) {
4934 if (defined $file_name) {
4935 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
4940 die_error
(404, "No such tree") unless defined($hash);
4945 open my $fd, "-|", git_cmd
(), "ls-tree", '-z', $hash
4946 or die_error
(500, "Open git-ls-tree failed");
4947 @entries = map { chomp; $_ } <$fd>;
4949 or die_error
(404, "Reading tree failed");
4952 my $refs = git_get_references
();
4953 my $ref = format_ref_marker
($refs, $hash_base);
4956 my $have_blame = gitweb_check_feature
('blame');
4957 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4959 if (defined $file_name) {
4961 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4963 $cgi->a({-href
=> href
(action
=>"tree",
4964 hash_base
=>"HEAD", file_name
=>$file_name)},
4967 my $snapshot_links = format_snapshot_links
($hash);
4968 if (defined $snapshot_links) {
4969 # FIXME: Should be available when we have no hash base as well.
4970 push @views_nav, $snapshot_links;
4972 git_print_page_nav
('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
4973 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
4976 print "<div class=\"page_nav\">\n";
4977 print "<br/><br/></div>\n";
4978 print "<div class=\"title\">$hash</div>\n";
4980 if (defined $file_name) {
4981 $basedir = $file_name;
4982 if ($basedir ne '' && substr($basedir, -1) ne '/') {
4985 git_print_page_path
($file_name, 'tree', $hash_base);
4987 print "<div class=\"page_body\">\n";
4988 print "<table class=\"tree\">\n";
4990 # '..' (top directory) link if possible
4991 if (defined $hash_base &&
4992 defined $file_name && $file_name =~ m![^/]+$!) {
4994 print "<tr class=\"dark\">\n";
4996 print "<tr class=\"light\">\n";
5000 my $up = $file_name;
5001 $up =~ s!/?[^/]+$!!;
5002 undef $up unless $up;
5003 # based on git_print_tree_entry
5004 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
5005 print '<td class="list">';
5006 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hash_base,
5010 print "<td class=\"link\"></td>\n";
5014 foreach my $line (@entries) {
5015 my %t = parse_ls_tree_line
($line, -z
=> 1);
5018 print "<tr class=\"dark\">\n";
5020 print "<tr class=\"light\">\n";
5024 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
5028 print "</table>\n" .
5034 my $format = $input_params{'snapshot_format'};
5035 if (!@snapshot_fmts) {
5036 die_error
(403, "Snapshots not allowed");
5038 # default to first supported snapshot format
5039 $format ||= $snapshot_fmts[0];
5040 if ($format !~ m/^[a-z0-9]+$/) {
5041 die_error
(400, "Invalid snapshot format parameter");
5042 } elsif (!exists($known_snapshot_formats{$format})) {
5043 die_error
(400, "Unknown snapshot format");
5044 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
5045 die_error
(403, "Unsupported snapshot format");
5048 if (!defined $hash) {
5049 $hash = git_get_head_hash
($project);
5052 my $name = $project;
5053 $name =~ s
,([^/])/*\
.git
$,$1,;
5054 $name = basename
($name);
5055 my $filename = to_utf8
($name);
5056 $name =~ s/\047/\047\\\047\047/g;
5058 $filename .= "-$hash$known_snapshot_formats{$format}{'suffix'}";
5059 $cmd = quote_command
(
5060 git_cmd
(), 'archive',
5061 "--format=$known_snapshot_formats{$format}{'format'}",
5062 "--prefix=$name/", $hash);
5063 if (exists $known_snapshot_formats{$format}{'compressor'}) {
5064 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
5068 -type
=> $known_snapshot_formats{$format}{'type'},
5069 -content_disposition
=> 'inline; filename="' . "$filename" . '"',
5070 -status
=> '200 OK');
5072 open my $fd, "-|", $cmd
5073 or die_error
(500, "Execute git-archive failed");
5074 binmode STDOUT
, ':raw';
5076 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
5081 my $head = git_get_head_hash
($project);
5082 if (!defined $hash) {
5085 if (!defined $page) {
5088 my $refs = git_get_references
();
5090 my @commitlist = parse_commits
($hash, 101, (100 * $page));
5092 my $paging_nav = format_paging_nav
('log', $hash, $head, $page, $#commitlist >= 100);
5094 my ($patch_max) = gitweb_get_feature
('patches');
5096 if ($patch_max < 0 || @commitlist <= $patch_max) {
5097 $paging_nav .= " ⋅ " .
5098 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
5104 git_print_page_nav
('log','', $hash,undef,undef, $paging_nav);
5107 my %co = parse_commit
($hash);
5109 git_print_header_div
('summary', $project);
5110 print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
5112 my $to = ($#commitlist >= 99) ?
(99) : ($#commitlist);
5113 for (my $i = 0; $i <= $to; $i++) {
5114 my %co = %{$commitlist[$i]};
5116 my $commit = $co{'id'};
5117 my $ref = format_ref_marker
($refs, $commit);
5118 my %ad = parse_date
($co{'author_epoch'});
5119 git_print_header_div
('commit',
5120 "<span class=\"age\">$co{'age_string'}</span>" .
5121 esc_html
($co{'title'}) . $ref,
5123 print "<div class=\"title_text\">\n" .
5124 "<div class=\"log_link\">\n" .
5125 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
5127 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
5129 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
5132 git_print_authorship
(\
%co, -tag
=> 'span');
5133 print "<br/>\n</div>\n";
5135 print "<div class=\"log_body\">\n";
5136 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
5139 if ($#commitlist >= 100) {
5140 print "<div class=\"page_nav\">\n";
5141 print $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5142 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5149 $hash ||= $hash_base || "HEAD";
5150 my %co = parse_commit
($hash)
5151 or die_error
(404, "Unknown commit object");
5153 my $parent = $co{'parent'};
5154 my $parents = $co{'parents'}; # listref
5156 # we need to prepare $formats_nav before any parameter munging
5158 if (!defined $parent) {
5160 $formats_nav .= '(initial)';
5161 } elsif (@
$parents == 1) {
5162 # single parent commit
5165 $cgi->a({-href
=> href
(action
=>"commit",
5167 esc_html
(substr($parent, 0, 7))) .
5174 $cgi->a({-href
=> href
(action
=>"commit",
5176 esc_html
(substr($_, 0, 7)));
5180 if (gitweb_check_feature
('patches')) {
5181 $formats_nav .= " | " .
5182 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
5186 if (!defined $parent) {
5190 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
5192 (@
$parents <= 1 ?
$parent : '-c'),
5194 or die_error
(500, "Open git-diff-tree failed");
5195 @difftree = map { chomp; $_ } <$fd>;
5196 close $fd or die_error
(404, "Reading git-diff-tree failed");
5198 # non-textual hash id's can be cached
5200 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5203 my $refs = git_get_references
();
5204 my $ref = format_ref_marker
($refs, $co{'id'});
5206 git_header_html
(undef, $expires);
5207 git_print_page_nav
('commit', '',
5208 $hash, $co{'tree'}, $hash,
5211 if (defined $co{'parent'}) {
5212 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
5214 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
5216 print "<div class=\"title_text\">\n" .
5217 "<table class=\"object_header\">\n";
5218 git_print_authorship_rows
(\
%co);
5219 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
5222 "<td class=\"sha1\">" .
5223 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
5224 class => "list"}, $co{'tree'}) .
5226 "<td class=\"link\">" .
5227 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
5229 my $snapshot_links = format_snapshot_links
($hash);
5230 if (defined $snapshot_links) {
5231 print " | " . $snapshot_links;
5236 foreach my $par (@
$parents) {
5239 "<td class=\"sha1\">" .
5240 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
5241 class => "list"}, $par) .
5243 "<td class=\"link\">" .
5244 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
5246 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
5253 print "<div class=\"page_body\">\n";
5254 git_print_log
($co{'comment'});
5257 git_difftree_body
(\
@difftree, $hash, @
$parents);
5263 # object is defined by:
5264 # - hash or hash_base alone
5265 # - hash_base and file_name
5268 # - hash or hash_base alone
5269 if ($hash || ($hash_base && !defined $file_name)) {
5270 my $object_id = $hash || $hash_base;
5272 open my $fd, "-|", quote_command
(
5273 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
5274 or die_error
(404, "Object does not exist");
5278 or die_error
(404, "Object does not exist");
5280 # - hash_base and file_name
5281 } elsif ($hash_base && defined $file_name) {
5282 $file_name =~ s
,/+$,,;
5284 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
5285 or die_error
(404, "Base object does not exist");
5287 # here errors should not hapen
5288 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
5289 or die_error
(500, "Open git-ls-tree failed");
5293 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
5294 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
5295 die_error
(404, "File or directory for given base does not exist");
5300 die_error
(400, "Not enough information to find object");
5303 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
5304 hash
=>$hash, hash_base
=>$hash_base,
5305 file_name
=>$file_name),
5306 -status
=> '302 Found');
5310 my $format = shift || 'html';
5317 # preparing $fd and %diffinfo for git_patchset_body
5319 if (defined $hash_base && defined $hash_parent_base) {
5320 if (defined $file_name) {
5322 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5323 $hash_parent_base, $hash_base,
5324 "--", (defined $file_parent ?
$file_parent : ()), $file_name
5325 or die_error
(500, "Open git-diff-tree failed");
5326 @difftree = map { chomp; $_ } <$fd>;
5328 or die_error
(404, "Reading git-diff-tree failed");
5330 or die_error
(404, "Blob diff not found");
5332 } elsif (defined $hash &&
5333 $hash =~ /[0-9a-fA-F]{40}/) {
5334 # try to find filename from $hash
5336 # read filtered raw output
5337 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5338 $hash_parent_base, $hash_base, "--"
5339 or die_error
(500, "Open git-diff-tree failed");
5341 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
5343 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
5344 map { chomp; $_ } <$fd>;
5346 or die_error
(404, "Reading git-diff-tree failed");
5348 or die_error
(404, "Blob diff not found");
5351 die_error
(400, "Missing one of the blob diff parameters");
5354 if (@difftree > 1) {
5355 die_error
(400, "Ambiguous blob diff specification");
5358 %diffinfo = parse_difftree_raw_line
($difftree[0]);
5359 $file_parent ||= $diffinfo{'from_file'} || $file_name;
5360 $file_name ||= $diffinfo{'to_file'};
5362 $hash_parent ||= $diffinfo{'from_id'};
5363 $hash ||= $diffinfo{'to_id'};
5365 # non-textual hash id's can be cached
5366 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
5367 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
5372 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5373 '-p', ($format eq 'html' ?
"--full-index" : ()),
5374 $hash_parent_base, $hash_base,
5375 "--", (defined $file_parent ?
$file_parent : ()), $file_name
5376 or die_error
(500, "Open git-diff-tree failed");
5379 # old/legacy style URI -- not generated anymore since 1.4.3.
5381 die_error
('404 Not Found', "Missing one of the blob diff parameters")
5385 if ($format eq 'html') {
5387 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
5389 git_header_html
(undef, $expires);
5390 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5391 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5392 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5394 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
5395 print "<div class=\"title\">$hash vs $hash_parent</div>\n";
5397 if (defined $file_name) {
5398 git_print_page_path
($file_name, "blob", $hash_base);
5400 print "<div class=\"page_path\"></div>\n";
5403 } elsif ($format eq 'plain') {
5405 -type
=> 'text/plain',
5406 -charset
=> 'utf-8',
5407 -expires
=> $expires,
5408 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
5410 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5413 die_error
(400, "Unknown blobdiff format");
5417 if ($format eq 'html') {
5418 print "<div class=\"page_body\">\n";
5420 git_patchset_body
($fd, [ \
%diffinfo ], $hash_base, $hash_parent_base);
5423 print "</div>\n"; # class="page_body"
5427 while (my $line = <$fd>) {
5428 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
5429 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
5433 last if $line =~ m!^\+\+\+!;
5441 sub git_blobdiff_plain
{
5442 git_blobdiff
('plain');
5445 sub git_commitdiff
{
5447 my $format = $params{-format
} || 'html';
5449 my ($patch_max) = gitweb_get_feature
('patches');
5450 if ($format eq 'patch') {
5451 die_error
(403, "Patch view not allowed") unless $patch_max;
5454 $hash ||= $hash_base || "HEAD";
5455 my %co = parse_commit
($hash)
5456 or die_error
(404, "Unknown commit object");
5458 # choose format for commitdiff for merge
5459 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
5460 $hash_parent = '--cc';
5462 # we need to prepare $formats_nav before almost any parameter munging
5464 if ($format eq 'html') {
5466 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
5469 $formats_nav .= " | " .
5470 $cgi->a({-href
=> href
(action
=>"patch", -replay
=>1)},
5474 if (defined $hash_parent &&
5475 $hash_parent ne '-c' && $hash_parent ne '--cc') {
5476 # commitdiff with two commits given
5477 my $hash_parent_short = $hash_parent;
5478 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5479 $hash_parent_short = substr($hash_parent, 0, 7);
5483 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
5484 if ($co{'parents'}[$i] eq $hash_parent) {
5485 $formats_nav .= ' parent ' . ($i+1);
5489 $formats_nav .= ': ' .
5490 $cgi->a({-href
=> href
(action
=>"commitdiff",
5491 hash
=>$hash_parent)},
5492 esc_html
($hash_parent_short)) .
5494 } elsif (!$co{'parent'}) {
5496 $formats_nav .= ' (initial)';
5497 } elsif (scalar @
{$co{'parents'}} == 1) {
5498 # single parent commit
5501 $cgi->a({-href
=> href
(action
=>"commitdiff",
5502 hash
=>$co{'parent'})},
5503 esc_html
(substr($co{'parent'}, 0, 7))) .
5507 if ($hash_parent eq '--cc') {
5508 $formats_nav .= ' | ' .
5509 $cgi->a({-href
=> href
(action
=>"commitdiff",
5510 hash
=>$hash, hash_parent
=>'-c')},
5512 } else { # $hash_parent eq '-c'
5513 $formats_nav .= ' | ' .
5514 $cgi->a({-href
=> href
(action
=>"commitdiff",
5515 hash
=>$hash, hash_parent
=>'--cc')},
5521 $cgi->a({-href
=> href
(action
=>"commitdiff",
5523 esc_html
(substr($_, 0, 7)));
5524 } @
{$co{'parents'}} ) .
5529 my $hash_parent_param = $hash_parent;
5530 if (!defined $hash_parent_param) {
5531 # --cc for multiple parents, --root for parentless
5532 $hash_parent_param =
5533 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
5539 if ($format eq 'html') {
5540 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5541 "--no-commit-id", "--patch-with-raw", "--full-index",
5542 $hash_parent_param, $hash, "--"
5543 or die_error
(500, "Open git-diff-tree failed");
5545 while (my $line = <$fd>) {
5547 # empty line ends raw part of diff-tree output
5549 push @difftree, scalar parse_difftree_raw_line
($line);
5552 } elsif ($format eq 'plain') {
5553 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5554 '-p', $hash_parent_param, $hash, "--"
5555 or die_error
(500, "Open git-diff-tree failed");
5556 } elsif ($format eq 'patch') {
5557 # For commit ranges, we limit the output to the number of
5558 # patches specified in the 'patches' feature.
5559 # For single commits, we limit the output to a single patch,
5560 # diverging from the git-format-patch default.
5561 my @commit_spec = ();
5563 if ($patch_max > 0) {
5564 push @commit_spec, "-$patch_max";
5566 push @commit_spec, '-n', "$hash_parent..$hash";
5568 if ($params{-single
}) {
5569 push @commit_spec, '-1';
5571 if ($patch_max > 0) {
5572 push @commit_spec, "-$patch_max";
5574 push @commit_spec, "-n";
5576 push @commit_spec, '--root', $hash;
5578 open $fd, "-|", git_cmd
(), "format-patch", '--encoding=utf8',
5579 '--stdout', @commit_spec
5580 or die_error
(500, "Open git-format-patch failed");
5582 die_error
(400, "Unknown commitdiff format");
5585 # non-textual hash id's can be cached
5587 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5591 # write commit message
5592 if ($format eq 'html') {
5593 my $refs = git_get_references
();
5594 my $ref = format_ref_marker
($refs, $co{'id'});
5596 git_header_html
(undef, $expires);
5597 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
5598 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
5599 print "<div class=\"title_text\">\n" .
5600 "<table class=\"object_header\">\n";
5601 git_print_authorship_rows
(\
%co);
5604 print "<div class=\"page_body\">\n";
5605 if (@
{$co{'comment'}} > 1) {
5606 print "<div class=\"log\">\n";
5607 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
5608 print "</div>\n"; # class="log"
5611 } elsif ($format eq 'plain') {
5612 my $refs = git_get_references
("tags");
5613 my $tagname = git_get_rev_name_tags
($hash);
5614 my $filename = basename
($project) . "-$hash.patch";
5617 -type
=> 'text/plain',
5618 -charset
=> 'utf-8',
5619 -expires
=> $expires,
5620 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
5621 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
5622 print "From: " . to_utf8
($co{'author'}) . "\n";
5623 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
5624 print "Subject: " . to_utf8
($co{'title'}) . "\n";
5626 print "X-Git-Tag: $tagname\n" if $tagname;
5627 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5629 foreach my $line (@
{$co{'comment'}}) {
5630 print to_utf8
($line) . "\n";
5633 } elsif ($format eq 'patch') {
5634 my $filename = basename
($project) . "-$hash.patch";
5637 -type
=> 'text/plain',
5638 -charset
=> 'utf-8',
5639 -expires
=> $expires,
5640 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
5644 if ($format eq 'html') {
5645 my $use_parents = !defined $hash_parent ||
5646 $hash_parent eq '-c' || $hash_parent eq '--cc';
5647 git_difftree_body
(\
@difftree, $hash,
5648 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5651 git_patchset_body
($fd, \
@difftree, $hash,
5652 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5654 print "</div>\n"; # class="page_body"
5657 } elsif ($format eq 'plain') {
5661 or print "Reading git-diff-tree failed\n";
5662 } elsif ($format eq 'patch') {
5666 or print "Reading git-format-patch failed\n";
5670 sub git_commitdiff_plain
{
5671 git_commitdiff
(-format
=> 'plain');
5674 # format-patch-style patches
5676 git_commitdiff
(-format
=> 'patch', -single
=> 1);
5680 git_commitdiff
(-format
=> 'patch');
5684 if (!defined $hash_base) {
5685 $hash_base = git_get_head_hash
($project);
5687 if (!defined $page) {
5691 my %co = parse_commit
($hash_base)
5692 or die_error
(404, "Unknown commit object");
5694 my $refs = git_get_references
();
5695 my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
5697 my @commitlist = parse_commits
($hash_base, 101, (100 * $page),
5698 $file_name, "--full-history")
5699 or die_error
(404, "No such file or directory on given branch");
5701 if (!defined $hash && defined $file_name) {
5702 # some commits could have deleted file in question,
5703 # and not have it in tree, but one of them has to have it
5704 for (my $i = 0; $i <= @commitlist; $i++) {
5705 $hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
5706 last if defined $hash;
5709 if (defined $hash) {
5710 $ftype = git_get_type
($hash);
5712 if (!defined $ftype) {
5713 die_error
(500, "Unknown type of object");
5716 my $paging_nav = '';
5719 $cgi->a({-href
=> href
(action
=>"history", hash
=>$hash, hash_base
=>$hash_base,
5720 file_name
=>$file_name)},
5722 $paging_nav .= " ⋅ " .
5723 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5724 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5726 $paging_nav .= "first";
5727 $paging_nav .= " ⋅ prev";
5730 if ($#commitlist >= 100) {
5732 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5733 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5734 $paging_nav .= " ⋅ $next_link";
5736 $paging_nav .= " ⋅ next";
5740 git_print_page_nav
('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
5741 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5742 git_print_page_path
($file_name, $ftype, $hash_base);
5744 git_history_body
(\
@commitlist, 0, 99,
5745 $refs, $hash_base, $ftype, $next_link);
5751 gitweb_check_feature
('search') or die_error
(403, "Search is disabled");
5752 if (!defined $searchtext) {
5753 die_error
(400, "Text field is empty");
5755 if (!defined $hash) {
5756 $hash = git_get_head_hash
($project);
5758 my %co = parse_commit
($hash);
5760 die_error
(404, "Unknown commit object");
5762 if (!defined $page) {
5766 $searchtype ||= 'commit';
5767 if ($searchtype eq 'pickaxe') {
5768 # pickaxe may take all resources of your box and run for several minutes
5769 # with every query - so decide by yourself how public you make this feature
5770 gitweb_check_feature
('pickaxe')
5771 or die_error
(403, "Pickaxe is disabled");
5773 if ($searchtype eq 'grep') {
5774 gitweb_check_feature
('grep')
5775 or die_error
(403, "Grep is disabled");
5780 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
5782 if ($searchtype eq 'commit') {
5783 $greptype = "--grep=";
5784 } elsif ($searchtype eq 'author') {
5785 $greptype = "--author=";
5786 } elsif ($searchtype eq 'committer') {
5787 $greptype = "--committer=";
5789 $greptype .= $searchtext;
5790 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5791 $greptype, '--regexp-ignore-case',
5792 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5794 my $paging_nav = '';
5797 $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
5798 searchtext
=>$searchtext,
5799 searchtype
=>$searchtype)},
5801 $paging_nav .= " ⋅ " .
5802 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5803 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5805 $paging_nav .= "first";
5806 $paging_nav .= " ⋅ prev";
5809 if ($#commitlist >= 100) {
5811 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5812 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5813 $paging_nav .= " ⋅ $next_link";
5815 $paging_nav .= " ⋅ next";
5818 if ($#commitlist >= 100) {
5821 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5822 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5823 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5826 if ($searchtype eq 'pickaxe') {
5827 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5828 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5830 print "<table class=\"pickaxe search\">\n";
5833 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5834 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5835 ($search_use_regexp ?
'--pickaxe-regex' : ());
5838 while (my $line = <$fd>) {
5842 my %set = parse_difftree_raw_line
($line);
5843 if (defined $set{'commit'}) {
5844 # finish previous commit
5847 "<td class=\"link\">" .
5848 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5850 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5856 print "<tr class=\"dark\">\n";
5858 print "<tr class=\"light\">\n";
5861 %co = parse_commit
($set{'commit'});
5862 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5863 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5864 "<td><i>$author</i></td>\n" .
5866 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5867 -class => "list subject"},
5868 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5869 } elsif (defined $set{'to_id'}) {
5870 next if ($set{'to_id'} =~ m/^0{40}$/);
5872 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5873 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5875 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5881 # finish last commit (warning: repetition!)
5884 "<td class=\"link\">" .
5885 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5887 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5895 if ($searchtype eq 'grep') {
5896 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5897 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5899 print "<table class=\"grep_search\">\n";
5903 open my $fd, "-|", git_cmd
(), 'grep', '-n',
5904 $search_use_regexp ?
('-E', '-i') : '-F',
5905 $searchtext, $co{'tree'};
5907 while (my $line = <$fd>) {
5909 my ($file, $lno, $ltext, $binary);
5910 last if ($matches++ > 1000);
5911 if ($line =~ /^Binary file (.+) matches$/) {
5915 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5917 if ($file ne $lastfile) {
5918 $lastfile and print "</td></tr>\n";
5920 print "<tr class=\"dark\">\n";
5922 print "<tr class=\"light\">\n";
5924 print "<td class=\"list\">".
5925 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5926 file_name
=>"$file"),
5927 -class => "list"}, esc_path
($file));
5928 print "</td><td>\n";
5932 print "<div class=\"binary\">Binary file</div>\n";
5934 $ltext = untabify
($ltext);
5935 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5936 $ltext = esc_html
($1, -nbsp
=>1);
5937 $ltext .= '<span class="match">';
5938 $ltext .= esc_html
($2, -nbsp
=>1);
5939 $ltext .= '</span>';
5940 $ltext .= esc_html
($3, -nbsp
=>1);
5942 $ltext = esc_html
($ltext, -nbsp
=>1);
5944 print "<div class=\"pre\">" .
5945 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5946 file_name
=>"$file").'#l'.$lno,
5947 -class => "linenr"}, sprintf('%4i', $lno))
5948 . ' ' . $ltext . "</div>\n";
5952 print "</td></tr>\n";
5953 if ($matches > 1000) {
5954 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5957 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5966 sub git_search_help
{
5968 git_print_page_nav
('','', $hash,$hash,$hash);
5970 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
5971 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
5972 the pattern entered is recognized as the POSIX extended
5973 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
5976 <dt><b>commit</b></dt>
5977 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
5979 my $have_grep = gitweb_check_feature
('grep');
5982 <dt><b>grep</b></dt>
5983 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
5984 a different one) are searched for the given pattern. On large trees, this search can take
5985 a while and put some strain on the server, so please use it with some consideration. Note that
5986 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
5987 case-sensitive.</dd>
5991 <dt><b>author</b></dt>
5992 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
5993 <dt><b>committer</b></dt>
5994 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
5996 my $have_pickaxe = gitweb_check_feature
('pickaxe');
5997 if ($have_pickaxe) {
5999 <dt><b>pickaxe</b></dt>
6000 <dd>All commits that caused the string to appear or disappear from any file (changes that
6001 added, removed or "modified" the string) will be listed. This search can take a while and
6002 takes a lot of strain on the server, so please use it wisely. Note that since you may be
6003 interested even in changes just changing the case as well, this search is case sensitive.</dd>
6011 my $head = git_get_head_hash
($project);
6012 if (!defined $hash) {
6015 if (!defined $page) {
6018 my $refs = git_get_references
();
6020 my $commit_hash = $hash;
6021 if (defined $hash_parent) {
6022 $commit_hash = "$hash_parent..$hash";
6024 my @commitlist = parse_commits
($commit_hash, 101, (100 * $page));
6026 my $paging_nav = format_paging_nav
('shortlog', $hash, $head, $page, $#commitlist >= 100);
6028 if ($#commitlist >= 100) {
6030 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
6031 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
6033 my $patch_max = gitweb_check_feature
('patches');
6035 if ($patch_max < 0 || @commitlist <= $patch_max) {
6036 $paging_nav .= " ⋅ " .
6037 $cgi->a({-href
=> href
(action
=>"patches", -replay
=>1)},
6043 git_print_page_nav
('shortlog','', $hash,$hash,$hash, $paging_nav);
6044 git_print_header_div
('summary', $project);
6046 git_shortlog_body
(\
@commitlist, 0, 99, $refs, $next_link);
6051 ## ......................................................................
6052 ## feeds (RSS, Atom; OPML)
6055 my $format = shift || 'atom';
6056 my $have_blame = gitweb_check_feature
('blame');
6058 # Atom: http://www.atomenabled.org/developers/syndication/
6059 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
6060 if ($format ne 'rss' && $format ne 'atom') {
6061 die_error
(400, "Unknown web feed format");
6064 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
6065 my $head = $hash || 'HEAD';
6066 my @commitlist = parse_commits
($head, 150, 0, $file_name);
6070 my $content_type = "application/$format+xml";
6071 if (defined $cgi->http('HTTP_ACCEPT') &&
6072 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
6073 # browser (feed reader) prefers text/xml
6074 $content_type = 'text/xml';
6076 if (defined($commitlist[0])) {
6077 %latest_commit = %{$commitlist[0]};
6078 my $latest_epoch = $latest_commit{'committer_epoch'};
6079 %latest_date = parse_date
($latest_epoch);
6080 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
6081 if (defined $if_modified) {
6083 if (eval { require HTTP
::Date
; 1; }) {
6084 $since = HTTP
::Date
::str2time
($if_modified);
6085 } elsif (eval { require Time
::ParseDate
; 1; }) {
6086 $since = Time
::ParseDate
::parsedate
($if_modified, GMT
=> 1);
6088 if (defined $since && $latest_epoch <= $since) {
6090 -type
=> $content_type,
6091 -charset
=> 'utf-8',
6092 -last_modified
=> $latest_date{'rfc2822'},
6093 -status
=> '304 Not Modified');
6098 -type
=> $content_type,
6099 -charset
=> 'utf-8',
6100 -last_modified
=> $latest_date{'rfc2822'});
6103 -type
=> $content_type,
6104 -charset
=> 'utf-8');
6107 # Optimization: skip generating the body if client asks only
6108 # for Last-Modified date.
6109 return if ($cgi->request_method() eq 'HEAD');
6112 my $title = "$site_name - $project/$action";
6113 my $feed_type = 'log';
6114 if (defined $hash) {
6115 $title .= " - '$hash'";
6116 $feed_type = 'branch log';
6117 if (defined $file_name) {
6118 $title .= " :: $file_name";
6119 $feed_type = 'history';
6121 } elsif (defined $file_name) {
6122 $title .= " - $file_name";
6123 $feed_type = 'history';
6125 $title .= " $feed_type";
6126 my $descr = git_get_project_description
($project);
6127 if (defined $descr) {
6128 $descr = esc_html
($descr);
6130 $descr = "$project " .
6131 ($format eq 'rss' ?
'RSS' : 'Atom') .
6134 my $owner = git_get_project_owner
($project);
6135 $owner = esc_html
($owner);
6139 if (defined $file_name) {
6140 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
6141 } elsif (defined $hash) {
6142 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
6144 $alt_url = href
(-full
=>1, action
=>"summary");
6146 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
6147 if ($format eq 'rss') {
6149 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
6152 print "<title>$title</title>\n" .
6153 "<link>$alt_url</link>\n" .
6154 "<description>$descr</description>\n" .
6155 "<language>en</language>\n" .
6156 # project owner is responsible for 'editorial' content
6157 "<managingEditor>$owner</managingEditor>\n";
6158 if (defined $logo || defined $favicon) {
6159 # prefer the logo to the favicon, since RSS
6160 # doesn't allow both
6161 my $img = esc_url
($logo || $favicon);
6163 "<url>$img</url>\n" .
6164 "<title>$title</title>\n" .
6165 "<link>$alt_url</link>\n" .
6169 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
6170 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
6172 print "<generator>gitweb v.$version/$git_version</generator>\n";
6173 } elsif ($format eq 'atom') {
6175 <feed xmlns="http://www.w3.org/2005/Atom">
6177 print "<title>$title</title>\n" .
6178 "<subtitle>$descr</subtitle>\n" .
6179 '<link rel="alternate" type="text/html" href="' .
6180 $alt_url . '" />' . "\n" .
6181 '<link rel="self" type="' . $content_type . '" href="' .
6182 $cgi->self_url() . '" />' . "\n" .
6183 "<id>" . href
(-full
=>1) . "</id>\n" .
6184 # use project owner for feed author
6185 "<author><name>$owner</name></author>\n";
6186 if (defined $favicon) {
6187 print "<icon>" . esc_url
($favicon) . "</icon>\n";
6189 if (defined $logo_url) {
6190 # not twice as wide as tall: 72 x 27 pixels
6191 print "<logo>" . esc_url
($logo) . "</logo>\n";
6193 if (! %latest_date) {
6194 # dummy date to keep the feed valid until commits trickle in:
6195 print "<updated>1970-01-01T00:00:00Z</updated>\n";
6197 print "<updated>$latest_date{'iso-8601'}</updated>\n";
6199 print "<generator version='$version/$git_version'>gitweb</generator>\n";
6203 for (my $i = 0; $i <= $#commitlist; $i++) {
6204 my %co = %{$commitlist[$i]};
6205 my $commit = $co{'id'};
6206 # we read 150, we always show 30 and the ones more recent than 48 hours
6207 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
6210 my %cd = parse_date
($co{'author_epoch'});
6212 # get list of changed files
6213 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
6214 $co{'parent'} || "--root",
6215 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
6217 my @difftree = map { chomp; $_ } <$fd>;
6221 # print element (entry, item)
6222 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
6223 if ($format eq 'rss') {
6225 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
6226 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
6227 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
6228 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
6229 "<link>$co_url</link>\n" .
6230 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
6231 "<content:encoded>" .
6233 } elsif ($format eq 'atom') {
6235 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
6236 "<updated>$cd{'iso-8601'}</updated>\n" .
6238 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
6239 if ($co{'author_email'}) {
6240 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
6242 print "</author>\n" .
6243 # use committer for contributor
6245 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
6246 if ($co{'committer_email'}) {
6247 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
6249 print "</contributor>\n" .
6250 "<published>$cd{'iso-8601'}</published>\n" .
6251 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
6252 "<id>$co_url</id>\n" .
6253 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
6254 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
6256 my $comment = $co{'comment'};
6258 foreach my $line (@
$comment) {
6259 $line = esc_html
($line);
6262 print "</pre><ul>\n";
6263 foreach my $difftree_line (@difftree) {
6264 my %difftree = parse_difftree_raw_line
($difftree_line);
6265 next if !$difftree{'from_id'};
6267 my $file = $difftree{'file'} || $difftree{'to_file'};
6271 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
6272 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
6273 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
6274 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
6275 -title
=> "diff"}, 'D');
6277 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
6278 file_name
=>$file, hash_base
=>$commit),
6279 -title
=> "blame"}, 'B');
6281 # if this is not a feed of a file history
6282 if (!defined $file_name || $file_name ne $file) {
6283 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
6284 file_name
=>$file, hash
=>$commit),
6285 -title
=> "history"}, 'H');
6287 $file = esc_path
($file);
6291 if ($format eq 'rss') {
6292 print "</ul>]]>\n" .
6293 "</content:encoded>\n" .
6295 } elsif ($format eq 'atom') {
6296 print "</ul>\n</div>\n" .
6303 if ($format eq 'rss') {
6304 print "</channel>\n</rss>\n";
6305 } elsif ($format eq 'atom') {
6319 my @list = git_get_projects_list
();
6322 -type
=> 'text/xml',
6323 -charset
=> 'utf-8',
6324 -content_disposition
=> 'inline; filename="opml.xml"');
6327 <?xml version="1.0" encoding="utf-8"?>
6328 <opml version="1.0">
6330 <title>$site_name OPML Export</title>
6333 <outline text="git RSS feeds">
6336 foreach my $pr (@list) {
6338 my $head = git_get_head_hash
($proj{'path'});
6339 if (!defined $head) {
6342 $git_dir = "$projectroot/$proj{'path'}";
6343 my %co = parse_commit
($head);
6348 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
6349 my $rss = href
('project' => $proj{'path'}, 'action' => 'rss', -full
=> 1);
6350 my $html = href
('project' => $proj{'path'}, 'action' => 'summary', -full
=> 1);
6351 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";