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 # if we're called with PATH_INFO, we have to strip that
31 # from the URL to find our real URL
32 # we make $path_info global because it's also used later on
33 our $path_info = $ENV{"PATH_INFO"};
35 $my_url =~ s
,\Q
$path_info\E
$,,;
36 $my_uri =~ s
,\Q
$path_info\E
$,,;
39 # core git executable to use
40 # this can just be "git" if your webserver has a sensible PATH
41 our $GIT = "++GIT_BINDIR++/git";
43 # absolute fs-path which will be prepended to the project path
44 #our $projectroot = "/pub/scm";
45 our $projectroot = "++GITWEB_PROJECTROOT++";
47 # fs traversing limit for getting project list
48 # the number is relative to the projectroot
49 our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
51 # target of the home link on top of all pages
52 our $home_link = $my_uri || "/";
54 # string of the home link on top of all pages
55 our $home_link_str = "++GITWEB_HOME_LINK_STR++";
57 # name of your site or organization to appear in page titles
58 # replace this with something more descriptive for clearer bookmarks
59 our $site_name = "++GITWEB_SITENAME++"
60 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
62 # filename of html text to include at top of each page
63 our $site_header = "++GITWEB_SITE_HEADER++";
64 # html text to include at home page
65 our $home_text = "++GITWEB_HOMETEXT++";
66 # filename of html text to include at bottom of each page
67 our $site_footer = "++GITWEB_SITE_FOOTER++";
70 our @stylesheets = ("++GITWEB_CSS++");
71 # URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
72 our $stylesheet = undef;
73 # URI of GIT logo (72x27 size)
74 our $logo = "++GITWEB_LOGO++";
75 # URI of GIT favicon, assumed to be image/png type
76 our $favicon = "++GITWEB_FAVICON++";
78 # URI and label (title) of GIT logo link
79 #our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
80 #our $logo_label = "git documentation";
81 our $logo_url = "http://git.or.cz/";
82 our $logo_label = "git homepage";
84 # source of projects list
85 our $projects_list = "++GITWEB_LIST++";
87 # the width (in characters) of the projects list "Description" column
88 our $projects_list_description_width = 25;
90 # default order of projects list
91 # valid values are none, project, descr, owner, and age
92 our $default_projects_order = "project";
94 # show repository only if this file exists
95 # (only effective if this variable evaluates to true)
96 our $export_ok = "++GITWEB_EXPORT_OK++";
98 # show repository only if this subroutine returns true
99 # when given the path to the project, for example:
100 # sub { return -e "$_[0]/git-daemon-export-ok"; }
101 our $export_auth_hook = undef;
103 # only allow viewing of repositories also shown on the overview page
104 our $strict_export = "++GITWEB_STRICT_EXPORT++";
106 # list of git base URLs used for URL to where fetch project from,
107 # i.e. full URL is "$git_base_url/$project"
108 our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
110 # default blob_plain mimetype and default charset for text/plain blob
111 our $default_blob_plain_mimetype = 'text/plain';
112 our $default_text_plain_charset = undef;
114 # file to use for guessing MIME types before trying /etc/mime.types
115 # (relative to the current git repository)
116 our $mimetypes_file = undef;
118 # assume this charset if line contains non-UTF-8 characters;
119 # it should be valid encoding (see Encoding::Supported(3pm) for list),
120 # for which encoding all byte sequences are valid, for example
121 # 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
122 # could be even 'utf-8' for the old behavior)
123 our $fallback_encoding = 'latin1';
125 # rename detection options for git-diff and git-diff-tree
126 # - default is '-M', with the cost proportional to
127 # (number of removed files) * (number of new files).
128 # - more costly is '-C' (which implies '-M'), with the cost proportional to
129 # (number of changed files + number of removed files) * (number of new files)
130 # - even more costly is '-C', '--find-copies-harder' with cost
131 # (number of files in the original tree) * (number of new files)
132 # - one might want to include '-B' option, e.g. '-B', '-M'
133 our @diff_opts = ('-M'); # taken from git_commit
135 # information about snapshot formats that gitweb is capable of serving
136 our %known_snapshot_formats = (
138 # 'display' => display name,
139 # 'type' => mime type,
140 # 'suffix' => filename suffix,
141 # 'format' => --format for git-archive,
142 # 'compressor' => [compressor command and arguments]
143 # (array reference, optional)}
146 'display' => 'tar.gz',
147 'type' => 'application/x-gzip',
148 'suffix' => '.tar.gz',
150 'compressor' => ['gzip']},
153 'display' => 'tar.bz2',
154 'type' => 'application/x-bzip2',
155 'suffix' => '.tar.bz2',
157 'compressor' => ['bzip2']},
161 'type' => 'application/x-zip',
166 # Aliases so we understand old gitweb.snapshot values in repository
168 our %known_snapshot_format_aliases = (
172 # backward compatibility: legacy gitweb config support
173 'x-gzip' => undef, 'gz' => undef,
174 'x-bzip2' => undef, 'bz2' => undef,
175 'x-zip' => undef, '' => undef,
178 # You define site-wide feature defaults here; override them with
179 # $GITWEB_CONFIG as necessary.
182 # 'sub' => feature-sub (subroutine),
183 # 'override' => allow-override (boolean),
184 # 'default' => [ default options...] (array reference)}
186 # if feature is overridable (it means that allow-override has true value),
187 # then feature-sub will be called with default options as parameters;
188 # return value of feature-sub indicates if to enable specified feature
190 # if there is no 'sub' key (no feature-sub), then feature cannot be
193 # use gitweb_check_feature(<feature>) to check if <feature> is enabled
195 # Enable the 'blame' blob view, showing the last commit that modified
196 # each line in the file. This can be very CPU-intensive.
198 # To enable system wide have in $GITWEB_CONFIG
199 # $feature{'blame'}{'default'} = [1];
200 # To have project specific config enable override in $GITWEB_CONFIG
201 # $feature{'blame'}{'override'} = 1;
202 # and in project config gitweb.blame = 0|1;
204 'sub' => \
&feature_blame
,
208 # Enable the 'snapshot' link, providing a compressed archive of any
209 # tree. This can potentially generate high traffic if you have large
212 # Value is a list of formats defined in %known_snapshot_formats that
214 # To disable system wide have in $GITWEB_CONFIG
215 # $feature{'snapshot'}{'default'} = [];
216 # To have project specific config enable override in $GITWEB_CONFIG
217 # $feature{'snapshot'}{'override'} = 1;
218 # and in project config, a comma-separated list of formats or "none"
219 # to disable. Example: gitweb.snapshot = tbz2,zip;
221 'sub' => \
&feature_snapshot
,
223 'default' => ['tgz']},
225 # Enable text search, which will list the commits which match author,
226 # committer or commit text to a given string. Enabled by default.
227 # Project specific override is not supported.
232 # Enable grep search, which will list the files in currently selected
233 # tree containing the given string. Enabled by default. This can be
234 # potentially CPU-intensive, of course.
236 # To enable system wide have in $GITWEB_CONFIG
237 # $feature{'grep'}{'default'} = [1];
238 # To have project specific config enable override in $GITWEB_CONFIG
239 # $feature{'grep'}{'override'} = 1;
240 # and in project config gitweb.grep = 0|1;
245 # Enable the pickaxe search, which will list the commits that modified
246 # a given string in a file. This can be practical and quite faster
247 # alternative to 'blame', but still potentially CPU-intensive.
249 # To enable system wide have in $GITWEB_CONFIG
250 # $feature{'pickaxe'}{'default'} = [1];
251 # To have project specific config enable override in $GITWEB_CONFIG
252 # $feature{'pickaxe'}{'override'} = 1;
253 # and in project config gitweb.pickaxe = 0|1;
255 'sub' => \
&feature_pickaxe
,
259 # Make gitweb use an alternative format of the URLs which can be
260 # more readable and natural-looking: project name is embedded
261 # directly in the path and the query string contains other
262 # auxiliary information. All gitweb installations recognize
263 # URL in either format; this configures in which formats gitweb
266 # To enable system wide have in $GITWEB_CONFIG
267 # $feature{'pathinfo'}{'default'} = [1];
268 # Project specific override is not supported.
270 # Note that you will need to change the default location of CSS,
271 # favicon, logo and possibly other files to an absolute URL. Also,
272 # if gitweb.cgi serves as your indexfile, you will need to force
273 # $my_uri to contain the script name in your $GITWEB_CONFIG.
278 # Make gitweb consider projects in project root subdirectories
279 # to be forks of existing projects. Given project $projname.git,
280 # projects matching $projname/*.git will not be shown in the main
281 # projects list, instead a '+' mark will be added to $projname
282 # there and a 'forks' view will be enabled for the project, listing
283 # all the forks. If project list is taken from a file, forks have
284 # to be listed after the main project.
286 # To enable system wide have in $GITWEB_CONFIG
287 # $feature{'forks'}{'default'} = [1];
288 # Project specific override is not supported.
293 # Insert custom links to the action bar of all project pages.
294 # This enables you mainly to link to third-party scripts integrating
295 # into gitweb; e.g. git-browser for graphical history representation
296 # or custom web-based repository administration interface.
298 # The 'default' value consists of a list of triplets in the form
299 # (label, link, position) where position is the label after which
300 # to inster the link and link is a format string where %n expands
301 # to the project name, %f to the project path within the filesystem,
302 # %h to the current hash (h gitweb parameter) and %b to the current
303 # hash base (hb gitweb parameter).
305 # To enable system wide have in $GITWEB_CONFIG e.g.
306 # $feature{'actions'}{'default'} = [('graphiclog',
307 # '/git-browser/by-commit.html?r=%n', 'summary')];
308 # Project specific override is not supported.
313 # Allow gitweb scan project content tags described in ctags/
314 # of project repository, and display the popular Web 2.0-ish
315 # "tag cloud" near the project list. Note that this is something
316 # COMPLETELY different from the normal Git tags.
318 # gitweb by itself can show existing tags, but it does not handle
319 # tagging itself; you need an external application for that.
320 # For an example script, check Girocco's cgi/tagproj.cgi.
321 # You may want to install the HTML::TagCloud Perl module to get
322 # a pretty tag cloud instead of just a list of tags.
324 # To enable system wide have in $GITWEB_CONFIG
325 # $feature{'ctags'}{'default'} = ['path_to_tag_script'];
326 # Project specific override is not supported.
332 sub gitweb_check_feature
{
334 return unless exists $feature{$name};
335 my ($sub, $override, @defaults) = (
336 $feature{$name}{'sub'},
337 $feature{$name}{'override'},
338 @
{$feature{$name}{'default'}});
339 if (!$override) { return @defaults; }
341 warn "feature $name is not overrideable";
344 return $sub->(@defaults);
348 my ($val) = git_get_project_config
('blame', '--bool');
350 if ($val eq 'true') {
352 } elsif ($val eq 'false') {
359 sub feature_snapshot
{
362 my ($val) = git_get_project_config
('snapshot');
365 @fmts = ($val eq 'none' ?
() : split /\s*[,\s]\s*/, $val);
372 my ($val) = git_get_project_config
('grep', '--bool');
374 if ($val eq 'true') {
376 } elsif ($val eq 'false') {
383 sub feature_pickaxe
{
384 my ($val) = git_get_project_config
('pickaxe', '--bool');
386 if ($val eq 'true') {
388 } elsif ($val eq 'false') {
395 # checking HEAD file with -e is fragile if the repository was
396 # initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
398 sub check_head_link
{
400 my $headfile = "$dir/HEAD";
401 return ((-e
$headfile) ||
402 (-l
$headfile && readlink($headfile) =~ /^refs\/heads\
//));
405 sub check_export_ok
{
407 return (check_head_link
($dir) &&
408 (!$export_ok || -e
"$dir/$export_ok") &&
409 (!$export_auth_hook || $export_auth_hook->($dir)));
412 # process alternate names for backward compatibility
413 # filter out unsupported (unknown) snapshot formats
414 sub filter_snapshot_fmts
{
418 exists $known_snapshot_format_aliases{$_} ?
419 $known_snapshot_format_aliases{$_} : $_} @fmts;
420 @fmts = grep(exists $known_snapshot_formats{$_}, @fmts);
424 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
425 if (-e
$GITWEB_CONFIG) {
428 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
429 do $GITWEB_CONFIG_SYSTEM if -e
$GITWEB_CONFIG_SYSTEM;
432 # version of the core git binary
433 our $git_version = qx("$GIT" --version
) =~ m/git version (.*)$/ ?
$1 : "unknown";
435 $projects_list ||= $projectroot;
437 # ======================================================================
438 # input validation and dispatch
440 # input parameters can be collected from a variety of sources (presently, CGI
441 # and PATH_INFO), so we define an %input_params hash that collects them all
442 # together during validation: this allows subsequent uses (e.g. href()) to be
443 # agnostic of the parameter origin
445 our %input_params = ();
447 # input parameters are stored with the long parameter name as key. This will
448 # also be used in the href subroutine to convert parameters to their CGI
449 # equivalent, and since the href() usage is the most frequent one, we store
450 # the name -> CGI key mapping here, instead of the reverse.
452 # XXX: Warning: If you touch this, check the search form for updating,
455 our @cgi_param_mapping = (
463 hash_parent_base
=> "hpb",
468 snapshot_format
=> "sf",
469 extra_options
=> "opt",
470 search_use_regexp
=> "sr",
472 our %cgi_param_mapping = @cgi_param_mapping;
474 # we will also need to know the possible actions, for validation
476 "blame" => \
&git_blame
,
477 "blobdiff" => \
&git_blobdiff
,
478 "blobdiff_plain" => \
&git_blobdiff_plain
,
479 "blob" => \
&git_blob
,
480 "blob_plain" => \
&git_blob_plain
,
481 "commitdiff" => \
&git_commitdiff
,
482 "commitdiff_plain" => \
&git_commitdiff_plain
,
483 "commit" => \
&git_commit
,
484 "forks" => \
&git_forks
,
485 "heads" => \
&git_heads
,
486 "history" => \
&git_history
,
489 "atom" => \
&git_atom
,
490 "search" => \
&git_search
,
491 "search_help" => \
&git_search_help
,
492 "shortlog" => \
&git_shortlog
,
493 "summary" => \
&git_summary
,
495 "tags" => \
&git_tags
,
496 "tree" => \
&git_tree
,
497 "snapshot" => \
&git_snapshot
,
498 "object" => \
&git_object
,
499 # those below don't need $project
500 "opml" => \
&git_opml
,
501 "project_list" => \
&git_project_list
,
502 "project_index" => \
&git_project_index
,
505 # finally, we have the hash of allowed extra_options for the commands that
507 our %allowed_options = (
508 "--no-merges" => [ qw(rss atom log shortlog history) ],
511 # fill %input_params with the CGI parameters. All values except for 'opt'
512 # should be single values, but opt can be an array. We should probably
513 # build an array of parameters that can be multi-valued, but since for the time
514 # being it's only this one, we just single it out
515 while (my ($name, $symbol) = each %cgi_param_mapping) {
516 if ($symbol eq 'opt') {
517 $input_params{$name} = [ $cgi->param($symbol) ];
519 $input_params{$name} = $cgi->param($symbol);
523 # now read PATH_INFO and update the parameter list for missing parameters
524 sub evaluate_path_info
{
525 return if defined $input_params{'project'};
526 return if !$path_info;
527 $path_info =~ s
,^/+,,;
528 return if !$path_info;
530 # find which part of PATH_INFO is project
531 my $project = $path_info;
533 while ($project && !check_head_link
("$projectroot/$project")) {
534 $project =~ s
,/*[^/]*$,,;
536 return unless $project;
537 $input_params{'project'} = $project;
539 # do not change any parameters if an action is given using the query string
540 return if $input_params{'action'};
541 $path_info =~ s
,^\Q
$project\E
/*,,;
543 # next, check if we have an action
544 my $action = $path_info;
546 if (exists $actions{$action}) {
547 $path_info =~ s
,^$action/*,,;
548 $input_params{'action'} = $action;
551 # list of actions that want hash_base instead of hash, but can have no
552 # pathname (f) parameter
559 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
560 my ($parentrefname, $parentpathname, $refname, $pathname) =
561 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?(.+?)(?::(.+))?$/);
563 # first, analyze the 'current' part
564 if (defined $pathname) {
565 # we got "branch:filename" or "branch:dir/"
566 # we could use git_get_type(branch:pathname), but:
567 # - it needs $git_dir
568 # - it does a git() call
569 # - the convention of terminating directories with a slash
570 # makes it superfluous
571 # - embedding the action in the PATH_INFO would make it even
573 $pathname =~ s
,^/+,,;
574 if (!$pathname || substr($pathname, -1) eq "/") {
575 $input_params{'action'} ||= "tree";
578 # the default action depends on whether we had parent info
580 if ($parentrefname) {
581 $input_params{'action'} ||= "blobdiff_plain";
583 $input_params{'action'} ||= "blob_plain";
586 $input_params{'hash_base'} ||= $refname;
587 $input_params{'file_name'} ||= $pathname;
588 } elsif (defined $refname) {
589 # we got "branch". In this case we have to choose if we have to
590 # set hash or hash_base.
592 # Most of the actions without a pathname only want hash to be
593 # set, except for the ones specified in @wants_base that want
594 # hash_base instead. It should also be noted that hand-crafted
595 # links having 'history' as an action and no pathname or hash
596 # set will fail, but that happens regardless of PATH_INFO.
597 $input_params{'action'} ||= "shortlog";
598 if (grep { $_ eq $input_params{'action'} } @wants_base) {
599 $input_params{'hash_base'} ||= $refname;
601 $input_params{'hash'} ||= $refname;
605 # next, handle the 'parent' part, if present
606 if (defined $parentrefname) {
607 # a missing pathspec defaults to the 'current' filename, allowing e.g.
608 # someproject/blobdiff/oldrev..newrev:/filename
609 if ($parentpathname) {
610 $parentpathname =~ s
,^/+,,;
611 $parentpathname =~ s
,/$,,;
612 $input_params{'file_parent'} ||= $parentpathname;
614 $input_params{'file_parent'} ||= $input_params{'file_name'};
616 # we assume that hash_parent_base is wanted if a path was specified,
617 # or if the action wants hash_base instead of hash
618 if (defined $input_params{'file_parent'} ||
619 grep { $_ eq $input_params{'action'} } @wants_base) {
620 $input_params{'hash_parent_base'} ||= $parentrefname;
622 $input_params{'hash_parent'} ||= $parentrefname;
626 evaluate_path_info
();
628 our $action = $input_params{'action'};
629 if (defined $action) {
630 if (!validate_action
($action)) {
631 die_error
(400, "Invalid action parameter");
635 # parameters which are pathnames
636 our $project = $input_params{'project'};
637 if (defined $project) {
638 if (!validate_project
($project)) {
640 die_error
(404, "No such project");
644 our $file_name = $input_params{'file_name'};
645 if (defined $file_name) {
646 if (!validate_pathname
($file_name)) {
647 die_error
(400, "Invalid file parameter");
651 our $file_parent = $input_params{'file_parent'};
652 if (defined $file_parent) {
653 if (!validate_pathname
($file_parent)) {
654 die_error
(400, "Invalid file parent parameter");
658 # parameters which are refnames
659 our $hash = $input_params{'hash'};
661 if (!validate_refname
($hash)) {
662 die_error
(400, "Invalid hash parameter");
666 our $hash_parent = $input_params{'hash_parent'};
667 if (defined $hash_parent) {
668 if (!validate_refname
($hash_parent)) {
669 die_error
(400, "Invalid hash parent parameter");
673 our $hash_base = $input_params{'hash_base'};
674 if (defined $hash_base) {
675 if (!validate_refname
($hash_base)) {
676 die_error
(400, "Invalid hash base parameter");
680 our @extra_options = @
{$input_params{'extra_options'}};
681 # @extra_options is always defined, since it can only be (currently) set from
682 # CGI, and $cgi->param() returns the empty array in array context if the param
684 foreach my $opt (@extra_options) {
685 if (not exists $allowed_options{$opt}) {
686 die_error
(400, "Invalid option parameter");
688 if (not grep(/^$action$/, @
{$allowed_options{$opt}})) {
689 die_error
(400, "Invalid option parameter for this action");
693 our $hash_parent_base = $input_params{'hash_parent_base'};
694 if (defined $hash_parent_base) {
695 if (!validate_refname
($hash_parent_base)) {
696 die_error
(400, "Invalid hash parent base parameter");
701 our $page = $input_params{'page'};
703 if ($page =~ m/[^0-9]/) {
704 die_error
(400, "Invalid page parameter");
708 our $searchtype = $input_params{'searchtype'};
709 if (defined $searchtype) {
710 if ($searchtype =~ m/[^a-z]/) {
711 die_error
(400, "Invalid searchtype parameter");
715 our $search_use_regexp = $input_params{'search_use_regexp'};
717 our $searchtext = $input_params{'searchtext'};
719 if (defined $searchtext) {
720 if (length($searchtext) < 2) {
721 die_error
(403, "At least two characters are required for search parameter");
723 $search_regexp = $search_use_regexp ?
$searchtext : quotemeta $searchtext;
726 # path to the current git repository
728 $git_dir = "$projectroot/$project" if $project;
731 if (!defined $action) {
733 $action = git_get_type
($hash);
734 } elsif (defined $hash_base && defined $file_name) {
735 $action = git_get_type
("$hash_base:$file_name");
736 } elsif (defined $project) {
739 $action = 'project_list';
742 if (!defined($actions{$action})) {
743 die_error
(400, "Unknown action");
745 if ($action !~ m/^(opml|project_list|project_index)$/ &&
747 die_error
(400, "Project needed");
749 $actions{$action}->();
752 ## ======================================================================
757 # default is to use -absolute url() i.e. $my_uri
758 my $href = $params{-full
} ?
$my_url : $my_uri;
760 $params{'project'} = $project unless exists $params{'project'};
762 if ($params{-replay
}) {
763 while (my ($name, $symbol) = each %cgi_param_mapping) {
764 if (!exists $params{$name}) {
765 $params{$name} = $input_params{$name};
770 my ($use_pathinfo) = gitweb_check_feature
('pathinfo');
772 # try to put as many parameters as possible in PATH_INFO:
775 # - hash_parent or hash_parent_base:/file_parent
776 # - hash or hash_base:/filename
778 # When the script is the root DirectoryIndex for the domain,
779 # $href here would be something like http://gitweb.example.com/
780 # Thus, we strip any trailing / from $href, to spare us double
781 # slashes in the final URL
784 # Then add the project name, if present
785 $href .= "/".esc_url
($params{'project'}) if defined $params{'project'};
786 delete $params{'project'};
788 # Summary just uses the project path URL, any other action is
790 if (defined $params{'action'}) {
791 $href .= "/".esc_url
($params{'action'}) unless $params{'action'} eq 'summary';
792 delete $params{'action'};
795 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
796 # stripping nonexistent or useless pieces
797 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
798 || $params{'hash_parent'} || $params{'hash'});
799 if (defined $params{'hash_base'}) {
800 if (defined $params{'hash_parent_base'}) {
801 $href .= esc_url
($params{'hash_parent_base'});
802 # skip the file_parent if it's the same as the file_name
803 delete $params{'file_parent'} if $params{'file_parent'} eq $params{'file_name'};
804 if (defined $params{'file_parent'} && $params{'file_parent'} !~ /\.\./) {
805 $href .= ":/".esc_url
($params{'file_parent'});
806 delete $params{'file_parent'};
809 delete $params{'hash_parent'};
810 delete $params{'hash_parent_base'};
811 } elsif (defined $params{'hash_parent'}) {
812 $href .= esc_url
($params{'hash_parent'}). "..";
813 delete $params{'hash_parent'};
816 $href .= esc_url
($params{'hash_base'});
817 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
818 $href .= ":/".esc_url
($params{'file_name'});
819 delete $params{'file_name'};
821 delete $params{'hash'};
822 delete $params{'hash_base'};
823 } elsif (defined $params{'hash'}) {
824 $href .= esc_url
($params{'hash'});
825 delete $params{'hash'};
829 # now encode the parameters explicitly
831 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
832 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
833 if (defined $params{$name}) {
834 if (ref($params{$name}) eq "ARRAY") {
835 foreach my $par (@
{$params{$name}}) {
836 push @result, $symbol . "=" . esc_param
($par);
839 push @result, $symbol . "=" . esc_param
($params{$name});
843 $href .= "?" . join(';', @result) if scalar @result;
849 ## ======================================================================
850 ## validation, quoting/unquoting and escaping
852 sub validate_action
{
853 my $input = shift || return undef;
854 return undef unless exists $actions{$input};
858 sub validate_project
{
859 my $input = shift || return undef;
860 if (!validate_pathname
($input) ||
861 !(-d
"$projectroot/$input") ||
862 !check_export_ok
("$projectroot/$input") ||
863 ($strict_export && !project_in_list
($input))) {
870 sub validate_pathname
{
871 my $input = shift || return undef;
873 # no '.' or '..' as elements of path, i.e. no '.' nor '..'
874 # at the beginning, at the end, and between slashes.
875 # also this catches doubled slashes
876 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
880 if ($input =~ m!\0!) {
886 sub validate_refname
{
887 my $input = shift || return undef;
889 # textual hashes are O.K.
890 if ($input =~ m/^[0-9a-fA-F]{40}$/) {
893 # it must be correct pathname
894 $input = validate_pathname
($input)
896 # restrictions on ref name according to git-check-ref-format
897 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
903 # decode sequences of octets in utf8 into Perl's internal form,
904 # which is utf-8 with utf8 flag set if needed. gitweb writes out
905 # in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
908 if (utf8
::valid
($str)) {
912 return decode
($fallback_encoding, $str, Encode
::FB_DEFAULT
);
916 # quote unsafe chars, but keep the slash, even when it's not
917 # correct, but quoted slashes look too horrible in bookmarks
920 $str =~ s/([^A-Za-z0-9\-_.~()\/:@])/sprintf
("%%%02X", ord($1))/eg
;
926 # quote unsafe chars in whole URL, so some charactrs cannot be quoted
929 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&=])/sprintf
("%%%02X", ord($1))/eg
;
935 # replace invalid utf8 character with SUBSTITUTION sequence
940 $str = to_utf8
($str);
941 $str = $cgi->escapeHTML($str);
942 if ($opts{'-nbsp'}) {
943 $str =~ s/ / /g;
945 $str =~ s
|([[:cntrl
:]])|(($1 ne "\t") ? quot_cec
($1) : $1)|eg
;
949 # quote control characters and escape filename to HTML
954 $str = to_utf8
($str);
955 $str = $cgi->escapeHTML($str);
956 if ($opts{'-nbsp'}) {
957 $str =~ s/ / /g;
959 $str =~ s
|([[:cntrl
:]])|quot_cec
($1)|eg
;
963 # Make control characters "printable", using character escape codes (CEC)
967 my %es = ( # character escape codes, aka escape sequences
968 "\t" => '\t', # tab (HT)
969 "\n" => '\n', # line feed (LF)
970 "\r" => '\r', # carrige return (CR)
971 "\f" => '\f', # form feed (FF)
972 "\b" => '\b', # backspace (BS)
973 "\a" => '\a', # alarm (bell) (BEL)
974 "\e" => '\e', # escape (ESC)
975 "\013" => '\v', # vertical tab (VT)
976 "\000" => '\0', # nul character (NUL)
978 my $chr = ( (exists $es{$cntrl})
980 : sprintf('\%2x', ord($cntrl)) );
981 if ($opts{-nohtml
}) {
984 return "<span class=\"cntrl\">$chr</span>";
988 # Alternatively use unicode control pictures codepoints,
989 # Unicode "printable representation" (PR)
994 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
995 if ($opts{-nohtml
}) {
998 return "<span class=\"cntrl\">$chr</span>";
1002 # git may return quoted and escaped filenames
1008 my %es = ( # character escape codes, aka escape sequences
1009 't' => "\t", # tab (HT, TAB)
1010 'n' => "\n", # newline (NL)
1011 'r' => "\r", # return (CR)
1012 'f' => "\f", # form feed (FF)
1013 'b' => "\b", # backspace (BS)
1014 'a' => "\a", # alarm (bell) (BEL)
1015 'e' => "\e", # escape (ESC)
1016 'v' => "\013", # vertical tab (VT)
1019 if ($seq =~ m/^[0-7]{1,3}$/) {
1020 # octal char sequence
1021 return chr(oct($seq));
1022 } elsif (exists $es{$seq}) {
1023 # C escape sequence, aka character escape code
1026 # quoted ordinary character
1030 if ($str =~ m/^"(.*)"$/) {
1033 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
1038 # escape tabs (convert tabs to spaces)
1042 while ((my $pos = index($line, "\t")) != -1) {
1043 if (my $count = (8 - ($pos % 8))) {
1044 my $spaces = ' ' x
$count;
1045 $line =~ s/\t/$spaces/;
1052 sub project_in_list
{
1053 my $project = shift;
1054 my @list = git_get_projects_list
();
1055 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1058 ## ----------------------------------------------------------------------
1059 ## HTML aware string manipulation
1061 # Try to chop given string on a word boundary between position
1062 # $len and $len+$add_len. If there is no word boundary there,
1063 # chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1064 # (marking chopped part) would be longer than given string.
1068 my $add_len = shift || 10;
1069 my $where = shift || 'right'; # 'left' | 'center' | 'right'
1071 # Make sure perl knows it is utf8 encoded so we don't
1072 # cut in the middle of a utf8 multibyte char.
1073 $str = to_utf8
($str);
1075 # allow only $len chars, but don't cut a word if it would fit in $add_len
1076 # if it doesn't fit, cut it if it's still longer than the dots we would add
1077 # remove chopped character entities entirely
1079 # when chopping in the middle, distribute $len into left and right part
1080 # return early if chopping wouldn't make string shorter
1081 if ($where eq 'center') {
1082 return $str if ($len + 5 >= length($str)); # filler is length 5
1085 return $str if ($len + 4 >= length($str)); # filler is length 4
1088 # regexps: ending and beginning with word part up to $add_len
1089 my $endre = qr/.{$len}\w{0,$add_len}/;
1090 my $begre = qr/\w{0,$add_len}.{$len}/;
1092 if ($where eq 'left') {
1093 $str =~ m/^(.*?)($begre)$/;
1094 my ($lead, $body) = ($1, $2);
1095 if (length($lead) > 4) {
1096 $body =~ s/^[^;]*;// if ($lead =~ m/&[^;]*$/);
1099 return "$lead$body";
1101 } elsif ($where eq 'center') {
1102 $str =~ m/^($endre)(.*)$/;
1103 my ($left, $str) = ($1, $2);
1104 $str =~ m/^(.*?)($begre)$/;
1105 my ($mid, $right) = ($1, $2);
1106 if (length($mid) > 5) {
1107 $left =~ s/&[^;]*$//;
1108 $right =~ s/^[^;]*;// if ($mid =~ m/&[^;]*$/);
1111 return "$left$mid$right";
1114 $str =~ m/^($endre)(.*)$/;
1117 if (length($tail) > 4) {
1118 $body =~ s/&[^;]*$//;
1121 return "$body$tail";
1125 # takes the same arguments as chop_str, but also wraps a <span> around the
1126 # result with a title attribute if it does get chopped. Additionally, the
1127 # string is HTML-escaped.
1128 sub chop_and_escape_str
{
1131 my $chopped = chop_str
(@_);
1132 if ($chopped eq $str) {
1133 return esc_html
($chopped);
1135 $str =~ s/([[:cntrl:]])/?/g;
1136 return $cgi->span({-title
=>$str}, esc_html
($chopped));
1140 ## ----------------------------------------------------------------------
1141 ## functions returning short strings
1143 # CSS class for given age value (in seconds)
1147 if (!defined $age) {
1149 } elsif ($age < 60*60*2) {
1151 } elsif ($age < 60*60*24*2) {
1158 # convert age in seconds to "nn units ago" string
1163 if ($age > 60*60*24*365*2) {
1164 $age_str = (int $age/60/60/24/365);
1165 $age_str .= " years ago";
1166 } elsif ($age > 60*60*24*(365/12)*2) {
1167 $age_str = int $age/60/60/24/(365/12);
1168 $age_str .= " months ago";
1169 } elsif ($age > 60*60*24*7*2) {
1170 $age_str = int $age/60/60/24/7;
1171 $age_str .= " weeks ago";
1172 } elsif ($age > 60*60*24*2) {
1173 $age_str = int $age/60/60/24;
1174 $age_str .= " days ago";
1175 } elsif ($age > 60*60*2) {
1176 $age_str = int $age/60/60;
1177 $age_str .= " hours ago";
1178 } elsif ($age > 60*2) {
1179 $age_str = int $age/60;
1180 $age_str .= " min ago";
1181 } elsif ($age > 2) {
1182 $age_str = int $age;
1183 $age_str .= " sec ago";
1185 $age_str .= " right now";
1191 S_IFINVALID
=> 0030000,
1192 S_IFGITLINK
=> 0160000,
1195 # submodule/subproject, a commit object reference
1196 sub S_ISGITLINK
($) {
1199 return (($mode & S_IFMT
) == S_IFGITLINK
)
1202 # convert file mode in octal to symbolic file mode string
1204 my $mode = oct shift;
1206 if (S_ISGITLINK
($mode)) {
1207 return 'm---------';
1208 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1209 return 'drwxr-xr-x';
1210 } elsif (S_ISLNK
($mode)) {
1211 return 'lrwxrwxrwx';
1212 } elsif (S_ISREG
($mode)) {
1213 # git cares only about the executable bit
1214 if ($mode & S_IXUSR
) {
1215 return '-rwxr-xr-x';
1217 return '-rw-r--r--';
1220 return '----------';
1224 # convert file mode in octal to file type string
1228 if ($mode !~ m/^[0-7]+$/) {
1234 if (S_ISGITLINK
($mode)) {
1236 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1238 } elsif (S_ISLNK
($mode)) {
1240 } elsif (S_ISREG
($mode)) {
1247 # convert file mode in octal to file type description string
1248 sub file_type_long
{
1251 if ($mode !~ m/^[0-7]+$/) {
1257 if (S_ISGITLINK
($mode)) {
1259 } elsif (S_ISDIR
($mode & S_IFMT
)) {
1261 } elsif (S_ISLNK
($mode)) {
1263 } elsif (S_ISREG
($mode)) {
1264 if ($mode & S_IXUSR
) {
1265 return "executable";
1275 ## ----------------------------------------------------------------------
1276 ## functions returning short HTML fragments, or transforming HTML fragments
1277 ## which don't belong to other sections
1279 # format line of commit message.
1280 sub format_log_line_html
{
1283 $line = esc_html
($line, -nbsp
=>1);
1284 if ($line =~ m/([0-9a-fA-F]{8,40})/) {
1287 $cgi->a({-href
=> href
(action
=>"object", hash
=>$hash_text),
1288 -class => "text"}, $hash_text);
1289 $line =~ s/$hash_text/$link/;
1294 # format marker of refs pointing to given object
1296 # the destination action is chosen based on object type and current context:
1297 # - for annotated tags, we choose the tag view unless it's the current view
1298 # already, in which case we go to shortlog view
1299 # - for other refs, we keep the current view if we're in history, shortlog or
1300 # log view, and select shortlog otherwise
1301 sub format_ref_marker
{
1302 my ($refs, $id) = @_;
1305 if (defined $refs->{$id}) {
1306 foreach my $ref (@
{$refs->{$id}}) {
1307 # this code exploits the fact that non-lightweight tags are the
1308 # only indirect objects, and that they are the only objects for which
1309 # we want to use tag instead of shortlog as action
1310 my ($type, $name) = qw();
1311 my $indirect = ($ref =~ s/\^\{\}$//);
1312 # e.g. tags/v2.6.11 or heads/next
1313 if ($ref =~ m!^(.*?)s?/(.*)$!) {
1322 $class .= " indirect" if $indirect;
1324 my $dest_action = "shortlog";
1327 $dest_action = "tag" unless $action eq "tag";
1328 } elsif ($action =~ /^(history|(short)?log)$/) {
1329 $dest_action = $action;
1333 $dest .= "refs/" unless $ref =~ m
!^refs
/!;
1336 my $link = $cgi->a({
1338 action
=>$dest_action,
1342 $markers .= " <span class=\"$class\" title=\"$ref\">" .
1348 return ' <span class="refs">'. $markers . '</span>';
1354 # format, perhaps shortened and with markers, title line
1355 sub format_subject_html
{
1356 my ($long, $short, $href, $extra) = @_;
1357 $extra = '' unless defined($extra);
1359 if (length($short) < length($long)) {
1360 return $cgi->a({-href
=> $href, -class => "list subject",
1361 -title
=> to_utf8
($long)},
1362 esc_html
($short) . $extra);
1364 return $cgi->a({-href
=> $href, -class => "list subject"},
1365 esc_html
($long) . $extra);
1369 # format git diff header line, i.e. "diff --(git|combined|cc) ..."
1370 sub format_git_diff_header_line
{
1372 my $diffinfo = shift;
1373 my ($from, $to) = @_;
1375 if ($diffinfo->{'nparents'}) {
1377 $line =~ s!^(diff (.*?) )"?.*$!$1!;
1378 if ($to->{'href'}) {
1379 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1380 esc_path
($to->{'file'}));
1381 } else { # file was deleted (no href)
1382 $line .= esc_path
($to->{'file'});
1386 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
1387 if ($from->{'href'}) {
1388 $line .= $cgi->a({-href
=> $from->{'href'}, -class => "path"},
1389 'a/' . esc_path
($from->{'file'}));
1390 } else { # file was added (no href)
1391 $line .= 'a/' . esc_path
($from->{'file'});
1394 if ($to->{'href'}) {
1395 $line .= $cgi->a({-href
=> $to->{'href'}, -class => "path"},
1396 'b/' . esc_path
($to->{'file'}));
1397 } else { # file was deleted
1398 $line .= 'b/' . esc_path
($to->{'file'});
1402 return "<div class=\"diff header\">$line</div>\n";
1405 # format extended diff header line, before patch itself
1406 sub format_extended_diff_header_line
{
1408 my $diffinfo = shift;
1409 my ($from, $to) = @_;
1412 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
1413 $line .= $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1414 esc_path
($from->{'file'}));
1416 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
1417 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1418 esc_path
($to->{'file'}));
1420 # match single <mode>
1421 if ($line =~ m/\s(\d{6})$/) {
1422 $line .= '<span class="info"> (' .
1423 file_type_long
($1) .
1427 if ($line =~ m/^index [0-9a-fA-F]{40},[0-9a-fA-F]{40}/) {
1428 # can match only for combined diff
1430 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1431 if ($from->{'href'}[$i]) {
1432 $line .= $cgi->a({-href
=>$from->{'href'}[$i],
1434 substr($diffinfo->{'from_id'}[$i],0,7));
1439 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
1442 if ($to->{'href'}) {
1443 $line .= $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1444 substr($diffinfo->{'to_id'},0,7));
1449 } elsif ($line =~ m/^index [0-9a-fA-F]{40}..[0-9a-fA-F]{40}/) {
1450 # can match only for ordinary diff
1451 my ($from_link, $to_link);
1452 if ($from->{'href'}) {
1453 $from_link = $cgi->a({-href
=>$from->{'href'}, -class=>"hash"},
1454 substr($diffinfo->{'from_id'},0,7));
1456 $from_link = '0' x
7;
1458 if ($to->{'href'}) {
1459 $to_link = $cgi->a({-href
=>$to->{'href'}, -class=>"hash"},
1460 substr($diffinfo->{'to_id'},0,7));
1464 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
1465 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
1468 return $line . "<br/>\n";
1471 # format from-file/to-file diff header
1472 sub format_diff_from_to_header
{
1473 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
1478 #assert($line =~ m/^---/) if DEBUG;
1479 # no extra formatting for "^--- /dev/null"
1480 if (! $diffinfo->{'nparents'}) {
1481 # ordinary (single parent) diff
1482 if ($line =~ m!^--- "?a/!) {
1483 if ($from->{'href'}) {
1485 $cgi->a({-href
=>$from->{'href'}, -class=>"path"},
1486 esc_path
($from->{'file'}));
1489 esc_path
($from->{'file'});
1492 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1495 # combined diff (merge commit)
1496 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
1497 if ($from->{'href'}[$i]) {
1499 $cgi->a({-href
=>href
(action
=>"blobdiff",
1500 hash_parent
=>$diffinfo->{'from_id'}[$i],
1501 hash_parent_base
=>$parents[$i],
1502 file_parent
=>$from->{'file'}[$i],
1503 hash
=>$diffinfo->{'to_id'},
1505 file_name
=>$to->{'file'}),
1507 -title
=>"diff" . ($i+1)},
1510 $cgi->a({-href
=>$from->{'href'}[$i], -class=>"path"},
1511 esc_path
($from->{'file'}[$i]));
1513 $line = '--- /dev/null';
1515 $result .= qq!<div
class="diff from_file">$line</div
>\n!;
1520 #assert($line =~ m/^\+\+\+/) if DEBUG;
1521 # no extra formatting for "^+++ /dev/null"
1522 if ($line =~ m!^\+\+\+ "?b/!) {
1523 if ($to->{'href'}) {
1525 $cgi->a({-href
=>$to->{'href'}, -class=>"path"},
1526 esc_path
($to->{'file'}));
1529 esc_path
($to->{'file'});
1532 $result .= qq!<div
class="diff to_file">$line</div
>\n!;
1537 # create note for patch simplified by combined diff
1538 sub format_diff_cc_simplified
{
1539 my ($diffinfo, @parents) = @_;
1542 $result .= "<div class=\"diff header\">" .
1544 if (!is_deleted
($diffinfo)) {
1545 $result .= $cgi->a({-href
=> href
(action
=>"blob",
1547 hash
=>$diffinfo->{'to_id'},
1548 file_name
=>$diffinfo->{'to_file'}),
1550 esc_path
($diffinfo->{'to_file'}));
1552 $result .= esc_path
($diffinfo->{'to_file'});
1554 $result .= "</div>\n" . # class="diff header"
1555 "<div class=\"diff nodifferences\">" .
1557 "</div>\n"; # class="diff nodifferences"
1562 # format patch (diff) line (not to be used for diff headers)
1563 sub format_diff_line
{
1565 my ($from, $to) = @_;
1566 my $diff_class = "";
1570 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
1572 my $prefix = substr($line, 0, scalar @
{$from->{'href'}});
1573 if ($line =~ m/^\@{3}/) {
1574 $diff_class = " chunk_header";
1575 } elsif ($line =~ m/^\\/) {
1576 $diff_class = " incomplete";
1577 } elsif ($prefix =~ tr/+/+/) {
1578 $diff_class = " add";
1579 } elsif ($prefix =~ tr/-/-/) {
1580 $diff_class = " rem";
1583 # assume ordinary diff
1584 my $char = substr($line, 0, 1);
1586 $diff_class = " add";
1587 } elsif ($char eq '-') {
1588 $diff_class = " rem";
1589 } elsif ($char eq '@') {
1590 $diff_class = " chunk_header";
1591 } elsif ($char eq "\\") {
1592 $diff_class = " incomplete";
1595 $line = untabify
($line);
1596 if ($from && $to && $line =~ m/^\@{2} /) {
1597 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
1598 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
1600 $from_lines = 0 unless defined $from_lines;
1601 $to_lines = 0 unless defined $to_lines;
1603 if ($from->{'href'}) {
1604 $from_text = $cgi->a({-href
=>"$from->{'href'}#l$from_start",
1605 -class=>"list"}, $from_text);
1607 if ($to->{'href'}) {
1608 $to_text = $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1609 -class=>"list"}, $to_text);
1611 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
1612 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1613 return "<div class=\"diff$diff_class\">$line</div>\n";
1614 } elsif ($from && $to && $line =~ m/^\@{3}/) {
1615 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
1616 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
1618 @from_text = split(' ', $ranges);
1619 for (my $i = 0; $i < @from_text; ++$i) {
1620 ($from_start[$i], $from_nlines[$i]) =
1621 (split(',', substr($from_text[$i], 1)), 0);
1624 $to_text = pop @from_text;
1625 $to_start = pop @from_start;
1626 $to_nlines = pop @from_nlines;
1628 $line = "<span class=\"chunk_info\">$prefix ";
1629 for (my $i = 0; $i < @from_text; ++$i) {
1630 if ($from->{'href'}[$i]) {
1631 $line .= $cgi->a({-href
=>"$from->{'href'}[$i]#l$from_start[$i]",
1632 -class=>"list"}, $from_text[$i]);
1634 $line .= $from_text[$i];
1638 if ($to->{'href'}) {
1639 $line .= $cgi->a({-href
=>"$to->{'href'}#l$to_start",
1640 -class=>"list"}, $to_text);
1644 $line .= " $prefix</span>" .
1645 "<span class=\"section\">" . esc_html
($section, -nbsp
=>1) . "</span>";
1646 return "<div class=\"diff$diff_class\">$line</div>\n";
1648 return "<div class=\"diff$diff_class\">" . esc_html
($line, -nbsp
=>1) . "</div>\n";
1651 # Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
1652 # linked. Pass the hash of the tree/commit to snapshot.
1653 sub format_snapshot_links
{
1655 my @snapshot_fmts = gitweb_check_feature
('snapshot');
1656 @snapshot_fmts = filter_snapshot_fmts
(@snapshot_fmts);
1657 my $num_fmts = @snapshot_fmts;
1658 if ($num_fmts > 1) {
1659 # A parenthesized list of links bearing format names.
1660 # e.g. "snapshot (_tar.gz_ _zip_)"
1661 return "snapshot (" . join(' ', map
1668 }, $known_snapshot_formats{$_}{'display'})
1669 , @snapshot_fmts) . ")";
1670 } elsif ($num_fmts == 1) {
1671 # A single "snapshot" link whose tooltip bears the format name.
1673 my ($fmt) = @snapshot_fmts;
1679 snapshot_format
=>$fmt
1681 -title
=> "in format: $known_snapshot_formats{$fmt}{'display'}"
1683 } else { # $num_fmts == 0
1688 ## ......................................................................
1689 ## functions returning values to be passed, perhaps after some
1690 ## transformation, to other functions; e.g. returning arguments to href()
1692 # returns hash to be passed to href to generate gitweb URL
1693 # in -title key it returns description of link
1695 my $format = shift || 'Atom';
1696 my %res = (action
=> lc($format));
1698 # feed links are possible only for project views
1699 return unless (defined $project);
1700 # some views should link to OPML, or to generic project feed,
1701 # or don't have specific feed yet (so they should use generic)
1702 return if ($action =~ /^(?:tags|heads|forks|tag|search)$/x);
1705 # branches refs uses 'refs/heads/' prefix (fullname) to differentiate
1706 # from tag links; this also makes possible to detect branch links
1707 if ((defined $hash_base && $hash_base =~ m!^refs/heads/(.*)$!) ||
1708 (defined $hash && $hash =~ m!^refs/heads/(.*)$!)) {
1711 # find log type for feed description (title)
1713 if (defined $file_name) {
1714 $type = "history of $file_name";
1715 $type .= "/" if ($action eq 'tree');
1716 $type .= " on '$branch'" if (defined $branch);
1718 $type = "log of $branch" if (defined $branch);
1721 $res{-title
} = $type;
1722 $res{'hash'} = (defined $branch ?
"refs/heads/$branch" : undef);
1723 $res{'file_name'} = $file_name;
1728 ## ----------------------------------------------------------------------
1729 ## git utility subroutines, invoking git commands
1731 # returns path to the core git executable and the --git-dir parameter as list
1733 return $GIT, '--git-dir='.$git_dir;
1736 # quote the given arguments for passing them to the shell
1737 # quote_command("command", "arg 1", "arg with ' and ! characters")
1738 # => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
1739 # Try to avoid using this function wherever possible.
1742 map( { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ ));
1745 # get HEAD ref of given project as hash
1746 sub git_get_head_hash
{
1747 my $project = shift;
1748 my $o_git_dir = $git_dir;
1750 $git_dir = "$projectroot/$project";
1751 if (open my $fd, "-|", git_cmd
(), "rev-parse", "--verify", "HEAD") {
1754 if (defined $head && $head =~ /^([0-9a-fA-F]{40})$/) {
1758 if (defined $o_git_dir) {
1759 $git_dir = $o_git_dir;
1764 # get type of given object
1768 open my $fd, "-|", git_cmd
(), "cat-file", '-t', $hash or return;
1770 close $fd or return;
1775 # repository configuration
1776 our $config_file = '';
1779 # store multiple values for single key as anonymous array reference
1780 # single values stored directly in the hash, not as [ <value> ]
1781 sub hash_set_multi
{
1782 my ($hash, $key, $value) = @_;
1784 if (!exists $hash->{$key}) {
1785 $hash->{$key} = $value;
1786 } elsif (!ref $hash->{$key}) {
1787 $hash->{$key} = [ $hash->{$key}, $value ];
1789 push @
{$hash->{$key}}, $value;
1793 # return hash of git project configuration
1794 # optionally limited to some section, e.g. 'gitweb'
1795 sub git_parse_project_config
{
1796 my $section_regexp = shift;
1801 open my $fh, "-|", git_cmd
(), "config", '-z', '-l',
1804 while (my $keyval = <$fh>) {
1806 my ($key, $value) = split(/\n/, $keyval, 2);
1808 hash_set_multi
(\
%config, $key, $value)
1809 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
1816 # convert config value to boolean, 'true' or 'false'
1817 # no value, number > 0, 'true' and 'yes' values are true
1818 # rest of values are treated as false (never as error)
1819 sub config_to_bool
{
1822 # strip leading and trailing whitespace
1826 return (!defined $val || # section.key
1827 ($val =~ /^\d+$/ && $val) || # section.key = 1
1828 ($val =~ /^(?:true|yes)$/i)); # section.key = true
1831 # convert config value to simple decimal number
1832 # an optional value suffix of 'k', 'm', or 'g' will cause the value
1833 # to be multiplied by 1024, 1048576, or 1073741824
1837 # strip leading and trailing whitespace
1841 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
1843 # unknown unit is treated as 1
1844 return $num * ($unit eq 'g' ?
1073741824 :
1845 $unit eq 'm' ?
1048576 :
1846 $unit eq 'k' ?
1024 : 1);
1851 # convert config value to array reference, if needed
1852 sub config_to_multi
{
1855 return ref($val) ?
$val : (defined($val) ?
[ $val ] : []);
1858 sub git_get_project_config
{
1859 my ($key, $type) = @_;
1862 return unless ($key);
1863 $key =~ s/^gitweb\.//;
1864 return if ($key =~ m/\W/);
1867 if (defined $type) {
1870 unless ($type eq 'bool' || $type eq 'int');
1874 if (!defined $config_file ||
1875 $config_file ne "$git_dir/config") {
1876 %config = git_parse_project_config
('gitweb');
1877 $config_file = "$git_dir/config";
1881 if (!defined $type) {
1882 return $config{"gitweb.$key"};
1883 } elsif ($type eq 'bool') {
1884 # backward compatibility: 'git config --bool' returns true/false
1885 return config_to_bool
($config{"gitweb.$key"}) ?
'true' : 'false';
1886 } elsif ($type eq 'int') {
1887 return config_to_int
($config{"gitweb.$key"});
1889 return $config{"gitweb.$key"};
1892 # get hash of given path at given ref
1893 sub git_get_hash_by_path
{
1895 my $path = shift || return undef;
1900 open my $fd, "-|", git_cmd
(), "ls-tree", $base, "--", $path
1901 or die_error
(500, "Open git-ls-tree failed");
1903 close $fd or return undef;
1905 if (!defined $line) {
1906 # there is no tree or hash given by $path at $base
1910 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
1911 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
1912 if (defined $type && $type ne $2) {
1913 # type doesn't match
1919 # get path of entry with given hash at given tree-ish (ref)
1920 # used to get 'from' filename for combined diff (merge commit) for renames
1921 sub git_get_path_by_hash
{
1922 my $base = shift || return;
1923 my $hash = shift || return;
1927 open my $fd, "-|", git_cmd
(), "ls-tree", '-r', '-t', '-z', $base
1929 while (my $line = <$fd>) {
1932 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
1933 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
1934 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
1943 ## ......................................................................
1944 ## git utility functions, directly accessing git repository
1946 sub git_get_project_description
{
1949 $git_dir = "$projectroot/$path";
1950 open my $fd, "$git_dir/description"
1951 or return git_get_project_config
('description');
1954 if (defined $descr) {
1960 sub git_get_project_ctags
{
1964 $git_dir = "$projectroot/$path";
1965 unless (opendir D
, "$git_dir/ctags") {
1968 foreach (grep { -f
$_ } map { "$git_dir/ctags/$_" } readdir(D
)) {
1969 open CT
, $_ or next;
1973 my $ctag = $_; $ctag =~ s
#.*/##;
1974 $ctags->{$ctag} = $val;
1980 sub git_populate_project_tagcloud
{
1983 # First, merge different-cased tags; tags vote on casing
1985 foreach (keys %$ctags) {
1986 $ctags_lc{lc $_}->{count
} += $ctags->{$_};
1987 if (not $ctags_lc{lc $_}->{topcount
}
1988 or $ctags_lc{lc $_}->{topcount
} < $ctags->{$_}) {
1989 $ctags_lc{lc $_}->{topcount
} = $ctags->{$_};
1990 $ctags_lc{lc $_}->{topname
} = $_;
1995 if (eval { require HTML
::TagCloud
; 1; }) {
1996 $cloud = HTML
::TagCloud
->new;
1997 foreach (sort keys %ctags_lc) {
1998 # Pad the title with spaces so that the cloud looks
2000 my $title = $ctags_lc{$_}->{topname
};
2001 $title =~ s/ / /g;
2002 $title =~ s/^/ /g;
2003 $title =~ s/$/ /g;
2004 $cloud->add($title, $home_link."?by_tag=".$_, $ctags_lc{$_}->{count
});
2007 $cloud = \
%ctags_lc;
2012 sub git_show_project_tagcloud
{
2013 my ($cloud, $count) = @_;
2014 print STDERR
ref($cloud)."..\n";
2015 if (ref $cloud eq 'HTML::TagCloud') {
2016 return $cloud->html_and_css($count);
2018 my @tags = sort { $cloud->{$a}->{count
} <=> $cloud->{$b}->{count
} } keys %$cloud;
2019 return '<p align="center">' . join (', ', map {
2020 "<a href=\"$home_link?by_tag=$_\">$cloud->{$_}->{topname}</a>"
2021 } splice(@tags, 0, $count)) . '</p>';
2025 sub git_get_project_url_list
{
2028 $git_dir = "$projectroot/$path";
2029 open my $fd, "$git_dir/cloneurl"
2030 or return wantarray ?
2031 @
{ config_to_multi
(git_get_project_config
('url')) } :
2032 config_to_multi
(git_get_project_config
('url'));
2033 my @git_project_url_list = map { chomp; $_ } <$fd>;
2036 return wantarray ?
@git_project_url_list : \
@git_project_url_list;
2039 sub git_get_projects_list
{
2044 $filter =~ s/\.git$//;
2046 my ($check_forks) = gitweb_check_feature
('forks');
2048 if (-d
$projects_list) {
2049 # search in directory
2050 my $dir = $projects_list . ($filter ?
"/$filter" : '');
2051 # remove the trailing "/"
2053 my $pfxlen = length("$dir");
2054 my $pfxdepth = ($dir =~ tr!/!!);
2057 follow_fast
=> 1, # follow symbolic links
2058 follow_skip
=> 2, # ignore duplicates
2059 dangling_symlinks
=> 0, # ignore dangling symlinks, silently
2061 # skip project-list toplevel, if we get it.
2062 return if (m!^[/.]$!);
2063 # only directories can be git repositories
2064 return unless (-d
$_);
2065 # don't traverse too deep (Find is super slow on os x)
2066 if (($File::Find
::name
=~ tr!/!!) - $pfxdepth > $project_maxdepth) {
2067 $File::Find
::prune
= 1;
2071 my $subdir = substr($File::Find
::name
, $pfxlen + 1);
2072 # we check related file in $projectroot
2073 if (check_export_ok
("$projectroot/$filter/$subdir")) {
2074 push @list, { path
=> ($filter ?
"$filter/" : '') . $subdir };
2075 $File::Find
::prune
= 1;
2080 } elsif (-f
$projects_list) {
2081 # read from file(url-encoded):
2082 # 'git%2Fgit.git Linus+Torvalds'
2083 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2084 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2086 open my ($fd), $projects_list or return;
2088 while (my $line = <$fd>) {
2090 my ($path, $owner) = split ' ', $line;
2091 $path = unescape
($path);
2092 $owner = unescape
($owner);
2093 if (!defined $path) {
2096 if ($filter ne '') {
2097 # looking for forks;
2098 my $pfx = substr($path, 0, length($filter));
2099 if ($pfx ne $filter) {
2102 my $sfx = substr($path, length($filter));
2103 if ($sfx !~ /^\/.*\
.git
$/) {
2106 } elsif ($check_forks) {
2108 foreach my $filter (keys %paths) {
2109 # looking for forks;
2110 my $pfx = substr($path, 0, length($filter));
2111 if ($pfx ne $filter) {
2114 my $sfx = substr($path, length($filter));
2115 if ($sfx !~ /^\/.*\
.git
$/) {
2118 # is a fork, don't include it in
2123 if (check_export_ok
("$projectroot/$path")) {
2126 owner
=> to_utf8
($owner),
2129 (my $forks_path = $path) =~ s/\.git$//;
2130 $paths{$forks_path}++;
2138 our $gitweb_project_owner = undef;
2139 sub git_get_project_list_from_file
{
2141 return if (defined $gitweb_project_owner);
2143 $gitweb_project_owner = {};
2144 # read from file (url-encoded):
2145 # 'git%2Fgit.git Linus+Torvalds'
2146 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
2147 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
2148 if (-f
$projects_list) {
2149 open (my $fd , $projects_list);
2150 while (my $line = <$fd>) {
2152 my ($pr, $ow) = split ' ', $line;
2153 $pr = unescape
($pr);
2154 $ow = unescape
($ow);
2155 $gitweb_project_owner->{$pr} = to_utf8
($ow);
2161 sub git_get_project_owner
{
2162 my $project = shift;
2165 return undef unless $project;
2166 $git_dir = "$projectroot/$project";
2168 if (!defined $gitweb_project_owner) {
2169 git_get_project_list_from_file
();
2172 if (exists $gitweb_project_owner->{$project}) {
2173 $owner = $gitweb_project_owner->{$project};
2175 if (!defined $owner){
2176 $owner = git_get_project_config
('owner');
2178 if (!defined $owner) {
2179 $owner = get_file_owner
("$git_dir");
2185 sub git_get_last_activity
{
2189 $git_dir = "$projectroot/$path";
2190 open($fd, "-|", git_cmd
(), 'for-each-ref',
2191 '--format=%(committer)',
2192 '--sort=-committerdate',
2194 'refs/heads') or return;
2195 my $most_recent = <$fd>;
2196 close $fd or return;
2197 if (defined $most_recent &&
2198 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
2200 my $age = time - $timestamp;
2201 return ($age, age_string
($age));
2203 return (undef, undef);
2206 sub git_get_references
{
2207 my $type = shift || "";
2209 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
2210 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
2211 open my $fd, "-|", git_cmd
(), "show-ref", "--dereference",
2212 ($type ?
("--", "refs/$type") : ()) # use -- <pattern> if $type
2215 while (my $line = <$fd>) {
2217 if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type.*)$!) {
2218 if (defined $refs{$1}) {
2219 push @
{$refs{$1}}, $2;
2225 close $fd or return;
2229 sub git_get_rev_name_tags
{
2230 my $hash = shift || return undef;
2232 open my $fd, "-|", git_cmd
(), "name-rev", "--tags", $hash
2234 my $name_rev = <$fd>;
2237 if ($name_rev =~ m
|^$hash tags
/(.*)$|) {
2240 # catches also '$hash undefined' output
2245 ## ----------------------------------------------------------------------
2246 ## parse to hash functions
2250 my $tz = shift || "-0000";
2253 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
2254 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
2255 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
2256 $date{'hour'} = $hour;
2257 $date{'minute'} = $min;
2258 $date{'mday'} = $mday;
2259 $date{'day'} = $days[$wday];
2260 $date{'month'} = $months[$mon];
2261 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
2262 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
2263 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
2264 $mday, $months[$mon], $hour ,$min;
2265 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
2266 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
2268 $tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
2269 my $local = $epoch + ((int $1 + ($2/60)) * 3600);
2270 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
2271 $date{'hour_local'} = $hour;
2272 $date{'minute_local'} = $min;
2273 $date{'tz_local'} = $tz;
2274 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
2275 1900+$year, $mon+1, $mday,
2276 $hour, $min, $sec, $tz);
2285 open my $fd, "-|", git_cmd
(), "cat-file", "tag", $tag_id or return;
2286 $tag{'id'} = $tag_id;
2287 while (my $line = <$fd>) {
2289 if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
2290 $tag{'object'} = $1;
2291 } elsif ($line =~ m/^type (.+)$/) {
2293 } elsif ($line =~ m/^tag (.+)$/) {
2295 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
2296 $tag{'author'} = $1;
2299 } elsif ($line =~ m/--BEGIN/) {
2300 push @comment, $line;
2302 } elsif ($line eq "") {
2306 push @comment, <$fd>;
2307 $tag{'comment'} = \
@comment;
2308 close $fd or return;
2309 if (!defined $tag{'name'}) {
2315 sub parse_commit_text
{
2316 my ($commit_text, $withparents) = @_;
2317 my @commit_lines = split '\n', $commit_text;
2320 pop @commit_lines; # Remove '\0'
2322 if (! @commit_lines) {
2326 my $header = shift @commit_lines;
2327 if ($header !~ m/^[0-9a-fA-F]{40}/) {
2330 ($co{'id'}, my @parents) = split ' ', $header;
2331 while (my $line = shift @commit_lines) {
2332 last if $line eq "\n";
2333 if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
2335 } elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
2337 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
2339 $co{'author_epoch'} = $2;
2340 $co{'author_tz'} = $3;
2341 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
2342 $co{'author_name'} = $1;
2343 $co{'author_email'} = $2;
2345 $co{'author_name'} = $co{'author'};
2347 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
2348 $co{'committer'} = $1;
2349 $co{'committer_epoch'} = $2;
2350 $co{'committer_tz'} = $3;
2351 $co{'committer_name'} = $co{'committer'};
2352 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
2353 $co{'committer_name'} = $1;
2354 $co{'committer_email'} = $2;
2356 $co{'committer_name'} = $co{'committer'};
2360 if (!defined $co{'tree'}) {
2363 $co{'parents'} = \
@parents;
2364 $co{'parent'} = $parents[0];
2366 foreach my $title (@commit_lines) {
2369 $co{'title'} = chop_str
($title, 80, 5);
2370 # remove leading stuff of merges to make the interesting part visible
2371 if (length($title) > 50) {
2372 $title =~ s/^Automatic //;
2373 $title =~ s/^merge (of|with) /Merge ... /i;
2374 if (length($title) > 50) {
2375 $title =~ s/(http|rsync):\/\///;
2377 if (length($title) > 50) {
2378 $title =~ s/(master|www|rsync)\.//;
2380 if (length($title) > 50) {
2381 $title =~ s/kernel.org:?//;
2383 if (length($title) > 50) {
2384 $title =~ s/\/pub\/scm//;
2387 $co{'title_short'} = chop_str
($title, 50, 5);
2391 if (! defined $co{'title'} || $co{'title'} eq "") {
2392 $co{'title'} = $co{'title_short'} = '(no commit message)';
2394 # remove added spaces
2395 foreach my $line (@commit_lines) {
2398 $co{'comment'} = \
@commit_lines;
2400 my $age = time - $co{'committer_epoch'};
2402 $co{'age_string'} = age_string
($age);
2403 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
2404 if ($age > 60*60*24*7*2) {
2405 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2406 $co{'age_string_age'} = $co{'age_string'};
2408 $co{'age_string_date'} = $co{'age_string'};
2409 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
2415 my ($commit_id) = @_;
2420 open my $fd, "-|", git_cmd
(), "rev-list",
2426 or die_error
(500, "Open git-rev-list failed");
2427 %co = parse_commit_text
(<$fd>, 1);
2434 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
2442 open my $fd, "-|", git_cmd
(), "rev-list",
2445 ("--max-count=" . $maxcount),
2446 ("--skip=" . $skip),
2450 ($filename ?
($filename) : ())
2451 or die_error
(500, "Open git-rev-list failed");
2452 while (my $line = <$fd>) {
2453 my %co = parse_commit_text
($line);
2458 return wantarray ?
@cos : \
@cos;
2461 # parse line of git-diff-tree "raw" output
2462 sub parse_difftree_raw_line
{
2466 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
2467 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
2468 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
2469 $res{'from_mode'} = $1;
2470 $res{'to_mode'} = $2;
2471 $res{'from_id'} = $3;
2473 $res{'status'} = $5;
2474 $res{'similarity'} = $6;
2475 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
2476 ($res{'from_file'}, $res{'to_file'}) = map { unquote
($_) } split("\t", $7);
2478 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote
($7);
2481 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
2482 # combined diff (for merge commit)
2483 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:[0-9a-fA-F]{40} )+)([a-zA-Z]+)\t(.*)$//) {
2484 $res{'nparents'} = length($1);
2485 $res{'from_mode'} = [ split(' ', $2) ];
2486 $res{'to_mode'} = pop @
{$res{'from_mode'}};
2487 $res{'from_id'} = [ split(' ', $3) ];
2488 $res{'to_id'} = pop @
{$res{'from_id'}};
2489 $res{'status'} = [ split('', $4) ];
2490 $res{'to_file'} = unquote
($5);
2492 # 'c512b523472485aef4fff9e57b229d9d243c967f'
2493 elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
2494 $res{'commit'} = $1;
2497 return wantarray ?
%res : \
%res;
2500 # wrapper: return parsed line of git-diff-tree "raw" output
2501 # (the argument might be raw line, or parsed info)
2502 sub parsed_difftree_line
{
2503 my $line_or_ref = shift;
2505 if (ref($line_or_ref) eq "HASH") {
2506 # pre-parsed (or generated by hand)
2507 return $line_or_ref;
2509 return parse_difftree_raw_line
($line_or_ref);
2513 # parse line of git-ls-tree output
2514 sub parse_ls_tree_line
($;%) {
2519 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
2520 $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
2528 $res{'name'} = unquote
($4);
2531 return wantarray ?
%res : \
%res;
2534 # generates _two_ hashes, references to which are passed as 2 and 3 argument
2535 sub parse_from_to_diffinfo
{
2536 my ($diffinfo, $from, $to, @parents) = @_;
2538 if ($diffinfo->{'nparents'}) {
2540 $from->{'file'} = [];
2541 $from->{'href'} = [];
2542 fill_from_file_info
($diffinfo, @parents)
2543 unless exists $diffinfo->{'from_file'};
2544 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2545 $from->{'file'}[$i] =
2546 defined $diffinfo->{'from_file'}[$i] ?
2547 $diffinfo->{'from_file'}[$i] :
2548 $diffinfo->{'to_file'};
2549 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
2550 $from->{'href'}[$i] = href
(action
=>"blob",
2551 hash_base
=>$parents[$i],
2552 hash
=>$diffinfo->{'from_id'}[$i],
2553 file_name
=>$from->{'file'}[$i]);
2555 $from->{'href'}[$i] = undef;
2559 # ordinary (not combined) diff
2560 $from->{'file'} = $diffinfo->{'from_file'};
2561 if ($diffinfo->{'status'} ne "A") { # not new (added) file
2562 $from->{'href'} = href
(action
=>"blob", hash_base
=>$hash_parent,
2563 hash
=>$diffinfo->{'from_id'},
2564 file_name
=>$from->{'file'});
2566 delete $from->{'href'};
2570 $to->{'file'} = $diffinfo->{'to_file'};
2571 if (!is_deleted
($diffinfo)) { # file exists in result
2572 $to->{'href'} = href
(action
=>"blob", hash_base
=>$hash,
2573 hash
=>$diffinfo->{'to_id'},
2574 file_name
=>$to->{'file'});
2576 delete $to->{'href'};
2580 ## ......................................................................
2581 ## parse to array of hashes functions
2583 sub git_get_heads_list
{
2587 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2588 ($limit ?
'--count='.($limit+1) : ()), '--sort=-committerdate',
2589 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
2592 while (my $line = <$fd>) {
2596 my ($refinfo, $committerinfo) = split(/\0/, $line);
2597 my ($hash, $name, $title) = split(' ', $refinfo, 3);
2598 my ($committer, $epoch, $tz) =
2599 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
2600 $ref_item{'fullname'} = $name;
2601 $name =~ s!^refs/heads/!!;
2603 $ref_item{'name'} = $name;
2604 $ref_item{'id'} = $hash;
2605 $ref_item{'title'} = $title || '(no commit message)';
2606 $ref_item{'epoch'} = $epoch;
2608 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2610 $ref_item{'age'} = "unknown";
2613 push @headslist, \
%ref_item;
2617 return wantarray ?
@headslist : \
@headslist;
2620 sub git_get_tags_list
{
2624 open my $fd, '-|', git_cmd
(), 'for-each-ref',
2625 ($limit ?
'--count='.($limit+1) : ()), '--sort=-creatordate',
2626 '--format=%(objectname) %(objecttype) %(refname) '.
2627 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
2630 while (my $line = <$fd>) {
2634 my ($refinfo, $creatorinfo) = split(/\0/, $line);
2635 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
2636 my ($creator, $epoch, $tz) =
2637 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
2638 $ref_item{'fullname'} = $name;
2639 $name =~ s!^refs/tags/!!;
2641 $ref_item{'type'} = $type;
2642 $ref_item{'id'} = $id;
2643 $ref_item{'name'} = $name;
2644 if ($type eq "tag") {
2645 $ref_item{'subject'} = $title;
2646 $ref_item{'reftype'} = $reftype;
2647 $ref_item{'refid'} = $refid;
2649 $ref_item{'reftype'} = $type;
2650 $ref_item{'refid'} = $id;
2653 if ($type eq "tag" || $type eq "commit") {
2654 $ref_item{'epoch'} = $epoch;
2656 $ref_item{'age'} = age_string
(time - $ref_item{'epoch'});
2658 $ref_item{'age'} = "unknown";
2662 push @tagslist, \
%ref_item;
2666 return wantarray ?
@tagslist : \
@tagslist;
2669 ## ----------------------------------------------------------------------
2670 ## filesystem-related functions
2672 sub get_file_owner
{
2675 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
2676 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
2677 if (!defined $gcos) {
2681 $owner =~ s/[,;].*$//;
2682 return to_utf8
($owner);
2685 ## ......................................................................
2686 ## mimetype related functions
2688 sub mimetype_guess_file
{
2689 my $filename = shift;
2690 my $mimemap = shift;
2691 -r
$mimemap or return undef;
2694 open(MIME
, $mimemap) or return undef;
2696 next if m/^#/; # skip comments
2697 my ($mime, $exts) = split(/\t+/);
2698 if (defined $exts) {
2699 my @exts = split(/\s+/, $exts);
2700 foreach my $ext (@exts) {
2701 $mimemap{$ext} = $mime;
2707 $filename =~ /\.([^.]*)$/;
2708 return $mimemap{$1};
2711 sub mimetype_guess
{
2712 my $filename = shift;
2714 $filename =~ /\./ or return undef;
2716 if ($mimetypes_file) {
2717 my $file = $mimetypes_file;
2718 if ($file !~ m!^/!) { # if it is relative path
2719 # it is relative to project
2720 $file = "$projectroot/$project/$file";
2722 $mime = mimetype_guess_file
($filename, $file);
2724 $mime ||= mimetype_guess_file
($filename, '/etc/mime.types');
2730 my $filename = shift;
2733 my $mime = mimetype_guess
($filename);
2734 $mime and return $mime;
2738 return $default_blob_plain_mimetype unless $fd;
2741 return 'text/plain';
2742 } elsif (! $filename) {
2743 return 'application/octet-stream';
2744 } elsif ($filename =~ m/\.png$/i) {
2746 } elsif ($filename =~ m/\.gif$/i) {
2748 } elsif ($filename =~ m/\.jpe?g$/i) {
2749 return 'image/jpeg';
2751 return 'application/octet-stream';
2755 sub blob_contenttype
{
2756 my ($fd, $file_name, $type) = @_;
2758 $type ||= blob_mimetype
($fd, $file_name);
2759 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
2760 $type .= "; charset=$default_text_plain_charset";
2766 ## ======================================================================
2767 ## functions printing HTML: header, footer, error page
2769 sub git_header_html
{
2770 my $status = shift || "200 OK";
2771 my $expires = shift;
2773 my $title = "$site_name";
2774 if (defined $project) {
2775 $title .= " - " . to_utf8
($project);
2776 if (defined $action) {
2777 $title .= "/$action";
2778 if (defined $file_name) {
2779 $title .= " - " . esc_path
($file_name);
2780 if ($action eq "tree" && $file_name !~ m
|/$|) {
2787 # require explicit support from the UA if we are to send the page as
2788 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
2789 # we have to do this because MSIE sometimes globs '*/*', pretending to
2790 # support xhtml+xml but choking when it gets what it asked for.
2791 if (defined $cgi->http('HTTP_ACCEPT') &&
2792 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\
+xml
(,|;|\s
|$)/ &&
2793 $cgi->Accept('application/xhtml+xml') != 0) {
2794 $content_type = 'application/xhtml+xml';
2796 $content_type = 'text/html';
2798 print $cgi->header(-type
=>$content_type, -charset
=> 'utf-8',
2799 -status
=> $status, -expires
=> $expires);
2800 my $mod_perl_version = $ENV{'MOD_PERL'} ?
" $ENV{'MOD_PERL'}" : '';
2802 <?xml version="1.0" encoding="utf-8"?>
2803 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2804 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
2805 <!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
2806 <!-- git core binaries version $git_version -->
2808 <meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
2809 <meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
2810 <meta name="robots" content="index, nofollow"/>
2811 <title>$title</title>
2813 # print out each stylesheet that exist
2814 if (defined $stylesheet) {
2815 #provides backwards capability for those people who define style sheet in a config file
2816 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2818 foreach my $stylesheet (@stylesheets) {
2819 next unless $stylesheet;
2820 print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
2823 if (defined $project) {
2824 my %href_params = get_feed_info
();
2825 if (!exists $href_params{'-title'}) {
2826 $href_params{'-title'} = 'log';
2829 foreach my $format qw(RSS Atom) {
2830 my $type = lc($format);
2832 '-rel' => 'alternate',
2833 '-title' => "$project - $href_params{'-title'} - $format feed",
2834 '-type' => "application/$type+xml"
2837 $href_params{'action'} = $type;
2838 $link_attr{'-href'} = href
(%href_params);
2840 "rel=\"$link_attr{'-rel'}\" ".
2841 "title=\"$link_attr{'-title'}\" ".
2842 "href=\"$link_attr{'-href'}\" ".
2843 "type=\"$link_attr{'-type'}\" ".
2846 $href_params{'extra_options'} = '--no-merges';
2847 $link_attr{'-href'} = href
(%href_params);
2848 $link_attr{'-title'} .= ' (no merges)';
2850 "rel=\"$link_attr{'-rel'}\" ".
2851 "title=\"$link_attr{'-title'}\" ".
2852 "href=\"$link_attr{'-href'}\" ".
2853 "type=\"$link_attr{'-type'}\" ".
2858 printf('<link rel="alternate" title="%s projects list" '.
2859 'href="%s" type="text/plain; charset=utf-8" />'."\n",
2860 $site_name, href
(project
=>undef, action
=>"project_index"));
2861 printf('<link rel="alternate" title="%s projects feeds" '.
2862 'href="%s" type="text/x-opml" />'."\n",
2863 $site_name, href
(project
=>undef, action
=>"opml"));
2865 if (defined $favicon) {
2866 print qq(<link rel
="shortcut icon" href
="$favicon" type
="image/png" />\n);
2872 if (-f
$site_header) {
2873 open (my $fd, $site_header);
2878 print "<div class=\"page_header\">\n" .
2879 $cgi->a({-href
=> esc_url
($logo_url),
2880 -title
=> $logo_label},
2881 qq(<img src
="$logo" width
="72" height
="27" alt
="git" class="logo"/>));
2882 print $cgi->a({-href
=> esc_url
($home_link)}, $home_link_str) . " / ";
2883 if (defined $project) {
2884 print $cgi->a({-href
=> href
(action
=>"summary")}, esc_html
($project));
2885 if (defined $action) {
2892 my ($have_search) = gitweb_check_feature
('search');
2893 if (defined $project && $have_search) {
2894 if (!defined $searchtext) {
2898 if (defined $hash_base) {
2899 $search_hash = $hash_base;
2900 } elsif (defined $hash) {
2901 $search_hash = $hash;
2903 $search_hash = "HEAD";
2905 my $action = $my_uri;
2906 my ($use_pathinfo) = gitweb_check_feature
('pathinfo');
2907 if ($use_pathinfo) {
2908 $action .= "/".esc_url
($project);
2910 print $cgi->startform(-method
=> "get", -action
=> $action) .
2911 "<div class=\"search\">\n" .
2913 $cgi->input({-name
=>"p", -value
=>$project, -type
=>"hidden"}) . "\n") .
2914 $cgi->input({-name
=>"a", -value
=>"search", -type
=>"hidden"}) . "\n" .
2915 $cgi->input({-name
=>"h", -value
=>$search_hash, -type
=>"hidden"}) . "\n" .
2916 $cgi->popup_menu(-name
=> 'st', -default => 'commit',
2917 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
2918 $cgi->sup($cgi->a({-href
=> href
(action
=>"search_help")}, "?")) .
2920 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
2921 "<span title=\"Extended regular expression\">" .
2922 $cgi->checkbox(-name
=> 'sr', -value
=> 1, -label
=> 're',
2923 -checked
=> $search_use_regexp) .
2926 $cgi->end_form() . "\n";
2930 sub git_footer_html
{
2931 my $feed_class = 'rss_logo';
2933 print "<div class=\"page_footer\">\n";
2934 if (defined $project) {
2935 my $descr = git_get_project_description
($project);
2936 if (defined $descr) {
2937 print "<div class=\"page_footer_text\">" . esc_html
($descr) . "</div>\n";
2940 my %href_params = get_feed_info
();
2941 if (!%href_params) {
2942 $feed_class .= ' generic';
2944 $href_params{'-title'} ||= 'log';
2946 foreach my $format qw(RSS Atom) {
2947 $href_params{'action'} = lc($format);
2948 print $cgi->a({-href
=> href
(%href_params),
2949 -title
=> "$href_params{'-title'} $format feed",
2950 -class => $feed_class}, $format)."\n";
2954 print $cgi->a({-href
=> href
(project
=>undef, action
=>"opml"),
2955 -class => $feed_class}, "OPML") . " ";
2956 print $cgi->a({-href
=> href
(project
=>undef, action
=>"project_index"),
2957 -class => $feed_class}, "TXT") . "\n";
2959 print "</div>\n"; # class="page_footer"
2961 if (-f
$site_footer) {
2962 open (my $fd, $site_footer);
2971 # die_error(<http_status_code>, <error_message>)
2972 # Example: die_error(404, 'Hash not found')
2973 # By convention, use the following status codes (as defined in RFC 2616):
2974 # 400: Invalid or missing CGI parameters, or
2975 # requested object exists but has wrong type.
2976 # 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
2977 # this server or project.
2978 # 404: Requested object/revision/project doesn't exist.
2979 # 500: The server isn't configured properly, or
2980 # an internal error occurred (e.g. failed assertions caused by bugs), or
2981 # an unknown error occurred (e.g. the git binary died unexpectedly).
2983 my $status = shift || 500;
2984 my $error = shift || "Internal server error";
2986 my %http_responses = (400 => '400 Bad Request',
2987 403 => '403 Forbidden',
2988 404 => '404 Not Found',
2989 500 => '500 Internal Server Error');
2990 git_header_html
($http_responses{$status});
2992 <div class="page_body">
3002 ## ----------------------------------------------------------------------
3003 ## functions printing or outputting HTML: navigation
3005 sub git_print_page_nav
{
3006 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
3007 $extra = '' if !defined $extra; # pager or formats
3009 my @navs = qw(summary shortlog log commit commitdiff tree);
3011 @navs = grep { $_ ne $suppress } @navs;
3014 my %arg = map { $_ => {action
=>$_} } @navs;
3015 if (defined $head) {
3016 for (qw(commit commitdiff)) {
3017 $arg{$_}{'hash'} = $head;
3019 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
3020 for (qw(shortlog log)) {
3021 $arg{$_}{'hash'} = $head;
3026 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
3027 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
3029 my @actions = gitweb_check_feature
('actions');
3031 my ($label, $link, $pos) = (shift(@actions), shift(@actions), shift(@actions));
3032 @navs = map { $_ eq $pos ?
($_, $label) : $_ } @navs;
3034 $link =~ s
#%n#$project#g;
3035 $link =~ s
#%f#$git_dir#g;
3036 $treehead ?
$link =~ s
#%h#$treehead#g : $link =~ s#%h##g;
3037 $treebase ?
$link =~ s
#%b#$treebase#g : $link =~ s#%b##g;
3038 $arg{$label}{'_href'} = $link;
3041 print "<div class=\"page_nav\">\n" .
3043 map { $_ eq $current ?
3044 $_ : $cgi->a({-href
=> ($arg{$_}{_href
} ?
$arg{$_}{_href
} : href
(%{$arg{$_}}))}, "$_")
3046 print "<br/>\n$extra<br/>\n" .
3050 sub format_paging_nav
{
3051 my ($action, $hash, $head, $page, $has_next_link) = @_;
3055 if ($hash ne $head || $page) {
3056 $paging_nav .= $cgi->a({-href
=> href
(action
=>$action)}, "HEAD");
3058 $paging_nav .= "HEAD";
3062 $paging_nav .= " ⋅ " .
3063 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
3064 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
3066 $paging_nav .= " ⋅ prev";
3069 if ($has_next_link) {
3070 $paging_nav .= " ⋅ " .
3071 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
3072 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
3074 $paging_nav .= " ⋅ next";
3080 ## ......................................................................
3081 ## functions printing or outputting HTML: div
3083 sub git_print_header_div
{
3084 my ($action, $title, $hash, $hash_base) = @_;
3087 $args{'action'} = $action;
3088 $args{'hash'} = $hash if $hash;
3089 $args{'hash_base'} = $hash_base if $hash_base;
3091 print "<div class=\"header\">\n" .
3092 $cgi->a({-href
=> href
(%args), -class => "title"},
3093 $title ?
$title : $action) .
3097 #sub git_print_authorship (\%) {
3098 sub git_print_authorship
{
3101 my %ad = parse_date
($co->{'author_epoch'}, $co->{'author_tz'});
3102 print "<div class=\"author_date\">" .
3103 esc_html
($co->{'author_name'}) .
3105 if ($ad{'hour_local'} < 6) {
3106 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
3107 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
3109 printf(" (%02d:%02d %s)",
3110 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
3115 sub git_print_page_path
{
3121 print "<div class=\"page_path\">";
3122 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hb),
3123 -title
=> 'tree root'}, to_utf8
("[$project]"));
3125 if (defined $name) {
3126 my @dirname = split '/', $name;
3127 my $basename = pop @dirname;
3130 foreach my $dir (@dirname) {
3131 $fullname .= ($fullname ?
'/' : '') . $dir;
3132 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$fullname,
3134 -title
=> $fullname}, esc_path
($dir));
3137 if (defined $type && $type eq 'blob') {
3138 print $cgi->a({-href
=> href
(action
=>"blob_plain", file_name
=>$file_name,
3140 -title
=> $name}, esc_path
($basename));
3141 } elsif (defined $type && $type eq 'tree') {
3142 print $cgi->a({-href
=> href
(action
=>"tree", file_name
=>$file_name,
3144 -title
=> $name}, esc_path
($basename));
3147 print esc_path
($basename);
3150 print "<br/></div>\n";
3153 # sub git_print_log (\@;%) {
3154 sub git_print_log
($;%) {
3158 if ($opts{'-remove_title'}) {
3159 # remove title, i.e. first line of log
3162 # remove leading empty lines
3163 while (defined $log->[0] && $log->[0] eq "") {
3170 foreach my $line (@
$log) {
3171 if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
3174 if (! $opts{'-remove_signoff'}) {
3175 print "<span class=\"signoff\">" . esc_html
($line) . "</span><br/>\n";
3178 # remove signoff lines
3185 # print only one empty line
3186 # do not print empty line after signoff
3188 next if ($empty || $signoff);
3194 print format_log_line_html
($line) . "<br/>\n";
3197 if ($opts{'-final_empty_line'}) {
3198 # end with single empty line
3199 print "<br/>\n" unless $empty;
3203 # return link target (what link points to)
3204 sub git_get_link_target
{
3209 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
3213 $link_target = <$fd>;
3218 return $link_target;
3221 # given link target, and the directory (basedir) the link is in,
3222 # return target of link relative to top directory (top tree);
3223 # return undef if it is not possible (including absolute links).
3224 sub normalize_link_target
{
3225 my ($link_target, $basedir, $hash_base) = @_;
3227 # we can normalize symlink target only if $hash_base is provided
3228 return unless $hash_base;
3230 # absolute symlinks (beginning with '/') cannot be normalized
3231 return if (substr($link_target, 0, 1) eq '/');
3233 # normalize link target to path from top (root) tree (dir)
3236 $path = $basedir . '/' . $link_target;
3238 # we are in top (root) tree (dir)
3239 $path = $link_target;
3242 # remove //, /./, and /../
3244 foreach my $part (split('/', $path)) {
3245 # discard '.' and ''
3246 next if (!$part || $part eq '.');
3248 if ($part eq '..') {
3252 # link leads outside repository (outside top dir)
3256 push @path_parts, $part;
3259 $path = join('/', @path_parts);
3264 # print tree entry (row of git_tree), but without encompassing <tr> element
3265 sub git_print_tree_entry
{
3266 my ($t, $basedir, $hash_base, $have_blame) = @_;
3269 $base_key{'hash_base'} = $hash_base if defined $hash_base;
3271 # The format of a table row is: mode list link. Where mode is
3272 # the mode of the entry, list is the name of the entry, an href,
3273 # and link is the action links of the entry.
3275 print "<td class=\"mode\">" . mode_str
($t->{'mode'}) . "</td>\n";
3276 if ($t->{'type'} eq "blob") {
3277 print "<td class=\"list\">" .
3278 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3279 file_name
=>"$basedir$t->{'name'}", %base_key),
3280 -class => "list"}, esc_path
($t->{'name'}));
3281 if (S_ISLNK
(oct $t->{'mode'})) {
3282 my $link_target = git_get_link_target
($t->{'hash'});
3284 my $norm_target = normalize_link_target
($link_target, $basedir, $hash_base);
3285 if (defined $norm_target) {
3287 $cgi->a({-href
=> href
(action
=>"object", hash_base
=>$hash_base,
3288 file_name
=>$norm_target),
3289 -title
=> $norm_target}, esc_path
($link_target));
3291 print " -> " . esc_path
($link_target);
3296 print "<td class=\"link\">";
3297 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$t->{'hash'},
3298 file_name
=>"$basedir$t->{'name'}", %base_key)},
3302 $cgi->a({-href
=> href
(action
=>"blame", hash
=>$t->{'hash'},
3303 file_name
=>"$basedir$t->{'name'}", %base_key)},
3306 if (defined $hash_base) {
3308 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3309 hash
=>$t->{'hash'}, file_name
=>"$basedir$t->{'name'}")},
3313 $cgi->a({-href
=> href
(action
=>"blob_plain", hash_base
=>$hash_base,
3314 file_name
=>"$basedir$t->{'name'}")},
3318 } elsif ($t->{'type'} eq "tree") {
3319 print "<td class=\"list\">";
3320 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3321 file_name
=>"$basedir$t->{'name'}", %base_key)},
3322 esc_path
($t->{'name'}));
3324 print "<td class=\"link\">";
3325 print $cgi->a({-href
=> href
(action
=>"tree", hash
=>$t->{'hash'},
3326 file_name
=>"$basedir$t->{'name'}", %base_key)},
3328 if (defined $hash_base) {
3330 $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash_base,
3331 file_name
=>"$basedir$t->{'name'}")},
3336 # unknown object: we can only present history for it
3337 # (this includes 'commit' object, i.e. submodule support)
3338 print "<td class=\"list\">" .
3339 esc_path
($t->{'name'}) .
3341 print "<td class=\"link\">";
3342 if (defined $hash_base) {
3343 print $cgi->a({-href
=> href
(action
=>"history",
3344 hash_base
=>$hash_base,
3345 file_name
=>"$basedir$t->{'name'}")},
3352 ## ......................................................................
3353 ## functions printing large fragments of HTML
3355 # get pre-image filenames for merge (combined) diff
3356 sub fill_from_file_info
{
3357 my ($diff, @parents) = @_;
3359 $diff->{'from_file'} = [ ];
3360 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
3361 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3362 if ($diff->{'status'}[$i] eq 'R' ||
3363 $diff->{'status'}[$i] eq 'C') {
3364 $diff->{'from_file'}[$i] =
3365 git_get_path_by_hash
($parents[$i], $diff->{'from_id'}[$i]);
3372 # is current raw difftree line of file deletion
3374 my $diffinfo = shift;
3376 return $diffinfo->{'to_id'} eq ('0' x
40);
3379 # does patch correspond to [previous] difftree raw line
3380 # $diffinfo - hashref of parsed raw diff format
3381 # $patchinfo - hashref of parsed patch diff format
3382 # (the same keys as in $diffinfo)
3383 sub is_patch_split
{
3384 my ($diffinfo, $patchinfo) = @_;
3386 return defined $diffinfo && defined $patchinfo
3387 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
3391 sub git_difftree_body
{
3392 my ($difftree, $hash, @parents) = @_;
3393 my ($parent) = $parents[0];
3394 my ($have_blame) = gitweb_check_feature
('blame');
3395 print "<div class=\"list_head\">\n";
3396 if ($#{$difftree} > 10) {
3397 print(($#{$difftree} + 1) . " files changed:\n");
3401 print "<table class=\"" .
3402 (@parents > 1 ?
"combined " : "") .
3405 # header only for combined diff in 'commitdiff' view
3406 my $has_header = @
$difftree && @parents > 1 && $action eq 'commitdiff';
3409 print "<thead><tr>\n" .
3410 "<th></th><th></th>\n"; # filename, patchN link
3411 for (my $i = 0; $i < @parents; $i++) {
3412 my $par = $parents[$i];
3414 $cgi->a({-href
=> href
(action
=>"commitdiff",
3415 hash
=>$hash, hash_parent
=>$par),
3416 -title
=> 'commitdiff to parent number ' .
3417 ($i+1) . ': ' . substr($par,0,7)},
3421 print "</tr></thead>\n<tbody>\n";
3426 foreach my $line (@
{$difftree}) {
3427 my $diff = parsed_difftree_line
($line);
3430 print "<tr class=\"dark\">\n";
3432 print "<tr class=\"light\">\n";
3436 if (exists $diff->{'nparents'}) { # combined diff
3438 fill_from_file_info
($diff, @parents)
3439 unless exists $diff->{'from_file'};
3441 if (!is_deleted
($diff)) {
3442 # file exists in the result (child) commit
3444 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3445 file_name
=>$diff->{'to_file'},
3447 -class => "list"}, esc_path
($diff->{'to_file'})) .
3451 esc_path
($diff->{'to_file'}) .
3455 if ($action eq 'commitdiff') {
3458 print "<td class=\"link\">" .
3459 $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3464 my $has_history = 0;
3465 my $not_deleted = 0;
3466 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
3467 my $hash_parent = $parents[$i];
3468 my $from_hash = $diff->{'from_id'}[$i];
3469 my $from_path = $diff->{'from_file'}[$i];
3470 my $status = $diff->{'status'}[$i];
3472 $has_history ||= ($status ne 'A');
3473 $not_deleted ||= ($status ne 'D');
3475 if ($status eq 'A') {
3476 print "<td class=\"link\" align=\"right\"> | </td>\n";
3477 } elsif ($status eq 'D') {
3478 print "<td class=\"link\">" .
3479 $cgi->a({-href
=> href
(action
=>"blob",
3482 file_name
=>$from_path)},
3486 if ($diff->{'to_id'} eq $from_hash) {
3487 print "<td class=\"link nochange\">";
3489 print "<td class=\"link\">";
3491 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3492 hash
=>$diff->{'to_id'},
3493 hash_parent
=>$from_hash,
3495 hash_parent_base
=>$hash_parent,
3496 file_name
=>$diff->{'to_file'},
3497 file_parent
=>$from_path)},
3503 print "<td class=\"link\">";
3505 print $cgi->a({-href
=> href
(action
=>"blob",
3506 hash
=>$diff->{'to_id'},
3507 file_name
=>$diff->{'to_file'},
3510 print " | " if ($has_history);
3513 print $cgi->a({-href
=> href
(action
=>"history",
3514 file_name
=>$diff->{'to_file'},
3521 next; # instead of 'else' clause, to avoid extra indent
3523 # else ordinary diff
3525 my ($to_mode_oct, $to_mode_str, $to_file_type);
3526 my ($from_mode_oct, $from_mode_str, $from_file_type);
3527 if ($diff->{'to_mode'} ne ('0' x
6)) {
3528 $to_mode_oct = oct $diff->{'to_mode'};
3529 if (S_ISREG
($to_mode_oct)) { # only for regular file
3530 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
3532 $to_file_type = file_type
($diff->{'to_mode'});
3534 if ($diff->{'from_mode'} ne ('0' x
6)) {
3535 $from_mode_oct = oct $diff->{'from_mode'};
3536 if (S_ISREG
($to_mode_oct)) { # only for regular file
3537 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
3539 $from_file_type = file_type
($diff->{'from_mode'});
3542 if ($diff->{'status'} eq "A") { # created
3543 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
3544 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
3545 $mode_chng .= "]</span>";
3547 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3548 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3549 -class => "list"}, esc_path
($diff->{'file'}));
3551 print "<td>$mode_chng</td>\n";
3552 print "<td class=\"link\">";
3553 if ($action eq 'commitdiff') {
3556 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3559 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3560 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3564 } elsif ($diff->{'status'} eq "D") { # deleted
3565 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
3567 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3568 hash_base
=>$parent, file_name
=>$diff->{'file'}),
3569 -class => "list"}, esc_path
($diff->{'file'}));
3571 print "<td>$mode_chng</td>\n";
3572 print "<td class=\"link\">";
3573 if ($action eq 'commitdiff') {
3576 print $cgi->a({-href
=> "#patch$patchno"}, "patch");
3579 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'from_id'},
3580 hash_base
=>$parent, file_name
=>$diff->{'file'})},
3583 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$parent,
3584 file_name
=>$diff->{'file'})},
3587 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$parent,
3588 file_name
=>$diff->{'file'})},
3592 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
3593 my $mode_chnge = "";
3594 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3595 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
3596 if ($from_file_type ne $to_file_type) {
3597 $mode_chnge .= " from $from_file_type to $to_file_type";
3599 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
3600 if ($from_mode_str && $to_mode_str) {
3601 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
3602 } elsif ($to_mode_str) {
3603 $mode_chnge .= " mode: $to_mode_str";
3606 $mode_chnge .= "]</span>\n";
3609 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3610 hash_base
=>$hash, file_name
=>$diff->{'file'}),
3611 -class => "list"}, esc_path
($diff->{'file'}));
3613 print "<td>$mode_chnge</td>\n";
3614 print "<td class=\"link\">";
3615 if ($action eq 'commitdiff') {
3618 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3620 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3621 # "commit" view and modified file (not onlu mode changed)
3622 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3623 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3624 hash_base
=>$hash, hash_parent_base
=>$parent,
3625 file_name
=>$diff->{'file'})},
3629 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3630 hash_base
=>$hash, file_name
=>$diff->{'file'})},
3633 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3634 file_name
=>$diff->{'file'})},
3637 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3638 file_name
=>$diff->{'file'})},
3642 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
3643 my %status_name = ('R' => 'moved', 'C' => 'copied');
3644 my $nstatus = $status_name{$diff->{'status'}};
3646 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
3647 # mode also for directories, so we cannot use $to_mode_str
3648 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
3651 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$hash,
3652 hash
=>$diff->{'to_id'}, file_name
=>$diff->{'to_file'}),
3653 -class => "list"}, esc_path
($diff->{'to_file'})) . "</td>\n" .
3654 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
3655 $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$parent,
3656 hash
=>$diff->{'from_id'}, file_name
=>$diff->{'from_file'}),
3657 -class => "list"}, esc_path
($diff->{'from_file'})) .
3658 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
3659 "<td class=\"link\">";
3660 if ($action eq 'commitdiff') {
3663 print $cgi->a({-href
=> "#patch$patchno"}, "patch") .
3665 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
3666 # "commit" view and modified file (not only pure rename or copy)
3667 print $cgi->a({-href
=> href
(action
=>"blobdiff",
3668 hash
=>$diff->{'to_id'}, hash_parent
=>$diff->{'from_id'},
3669 hash_base
=>$hash, hash_parent_base
=>$parent,
3670 file_name
=>$diff->{'to_file'}, file_parent
=>$diff->{'from_file'})},
3674 print $cgi->a({-href
=> href
(action
=>"blob", hash
=>$diff->{'to_id'},
3675 hash_base
=>$parent, file_name
=>$diff->{'to_file'})},
3678 print $cgi->a({-href
=> href
(action
=>"blame", hash_base
=>$hash,
3679 file_name
=>$diff->{'to_file'})},
3682 print $cgi->a({-href
=> href
(action
=>"history", hash_base
=>$hash,
3683 file_name
=>$diff->{'to_file'})},
3687 } # we should not encounter Unmerged (U) or Unknown (X) status
3690 print "</tbody>" if $has_header;
3694 sub git_patchset_body
{
3695 my ($fd, $difftree, $hash, @hash_parents) = @_;
3696 my ($hash_parent) = $hash_parents[0];
3698 my $is_combined = (@hash_parents > 1);
3700 my $patch_number = 0;
3706 print "<div class=\"patchset\">\n";
3708 # skip to first patch
3709 while ($patch_line = <$fd>) {
3712 last if ($patch_line =~ m/^diff /);
3716 while ($patch_line) {
3718 # parse "git diff" header line
3719 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
3720 # $1 is from_name, which we do not use
3721 $to_name = unquote
($2);
3722 $to_name =~ s!^b/!!;
3723 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
3724 # $1 is 'cc' or 'combined', which we do not use
3725 $to_name = unquote
($2);
3730 # check if current patch belong to current raw line
3731 # and parse raw git-diff line if needed
3732 if (is_patch_split
($diffinfo, { 'to_file' => $to_name })) {
3733 # this is continuation of a split patch
3734 print "<div class=\"patch cont\">\n";
3736 # advance raw git-diff output if needed
3737 $patch_idx++ if defined $diffinfo;
3739 # read and prepare patch information
3740 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3742 # compact combined diff output can have some patches skipped
3743 # find which patch (using pathname of result) we are at now;
3745 while ($to_name ne $diffinfo->{'to_file'}) {
3746 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3747 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3748 "</div>\n"; # class="patch"
3753 last if $patch_idx > $#$difftree;
3754 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3758 # modifies %from, %to hashes
3759 parse_from_to_diffinfo
($diffinfo, \
%from, \
%to, @hash_parents);
3761 # this is first patch for raw difftree line with $patch_idx index
3762 # we index @$difftree array from 0, but number patches from 1
3763 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
3767 #assert($patch_line =~ m/^diff /) if DEBUG;
3768 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
3770 # print "git diff" header
3771 print format_git_diff_header_line
($patch_line, $diffinfo,
3774 # print extended diff header
3775 print "<div class=\"diff extended_header\">\n";
3777 while ($patch_line = <$fd>) {
3780 last EXTENDED_HEADER
if ($patch_line =~ m/^--- |^diff /);
3782 print format_extended_diff_header_line
($patch_line, $diffinfo,
3785 print "</div>\n"; # class="diff extended_header"
3787 # from-file/to-file diff header
3788 if (! $patch_line) {
3789 print "</div>\n"; # class="patch"
3792 next PATCH
if ($patch_line =~ m/^diff /);
3793 #assert($patch_line =~ m/^---/) if DEBUG;
3795 my $last_patch_line = $patch_line;
3796 $patch_line = <$fd>;
3798 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
3800 print format_diff_from_to_header
($last_patch_line, $patch_line,
3801 $diffinfo, \
%from, \
%to,
3806 while ($patch_line = <$fd>) {
3809 next PATCH
if ($patch_line =~ m/^diff /);
3811 print format_diff_line
($patch_line, \
%from, \
%to);
3815 print "</div>\n"; # class="patch"
3818 # for compact combined (--cc) format, with chunk and patch simpliciaction
3819 # patchset might be empty, but there might be unprocessed raw lines
3820 for (++$patch_idx if $patch_number > 0;
3821 $patch_idx < @
$difftree;
3823 # read and prepare patch information
3824 $diffinfo = parsed_difftree_line
($difftree->[$patch_idx]);
3826 # generate anchor for "patch" links in difftree / whatchanged part
3827 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
3828 format_diff_cc_simplified
($diffinfo, @hash_parents) .
3829 "</div>\n"; # class="patch"
3834 if ($patch_number == 0) {
3835 if (@hash_parents > 1) {
3836 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
3838 print "<div class=\"diff nodifferences\">No differences found</div>\n";
3842 print "</div>\n"; # class="patchset"
3845 # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3847 # fills project list info (age, description, owner, forks) for each
3848 # project in the list, removing invalid projects from returned list
3849 # NOTE: modifies $projlist, but does not remove entries from it
3850 sub fill_project_list_info
{
3851 my ($projlist, $check_forks) = @_;
3854 my $show_ctags = gitweb_check_feature
('ctags');
3856 foreach my $pr (@
$projlist) {
3857 my (@activity) = git_get_last_activity
($pr->{'path'});
3858 unless (@activity) {
3861 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
3862 if (!defined $pr->{'descr'}) {
3863 my $descr = git_get_project_description
($pr->{'path'}) || "";
3864 $descr = to_utf8
($descr);
3865 $pr->{'descr_long'} = $descr;
3866 $pr->{'descr'} = chop_str
($descr, $projects_list_description_width, 5);
3868 if (!defined $pr->{'owner'}) {
3869 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}") || "";
3872 my $pname = $pr->{'path'};
3873 if (($pname =~ s/\.git$//) &&
3874 ($pname !~ /\/$/) &&
3875 (-d
"$projectroot/$pname")) {
3876 $pr->{'forks'} = "-d $projectroot/$pname";
3881 $show_ctags and $pr->{'ctags'} = git_get_project_ctags
($pr->{'path'});
3882 push @projects, $pr;
3888 # print 'sort by' <th> element, generating 'sort by $name' replay link
3889 # if that order is not selected
3891 my ($name, $order, $header) = @_;
3892 $header ||= ucfirst($name);
3894 if ($order eq $name) {
3895 print "<th>$header</th>\n";
3898 $cgi->a({-href
=> href
(-replay
=>1, order
=>$name),
3899 -class => "header"}, $header) .
3904 sub git_project_list_body
{
3905 # actually uses global variable $project
3906 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
3908 my ($check_forks) = gitweb_check_feature
('forks');
3909 my @projects = fill_project_list_info
($projlist, $check_forks);
3911 $order ||= $default_projects_order;
3912 $from = 0 unless defined $from;
3913 $to = $#projects if (!defined $to || $#projects < $to);
3916 project
=> { key
=> 'path', type
=> 'str' },
3917 descr
=> { key
=> 'descr_long', type
=> 'str' },
3918 owner
=> { key
=> 'owner', type
=> 'str' },
3919 age
=> { key
=> 'age', type
=> 'num' }
3921 my $oi = $order_info{$order};
3922 if ($oi->{'type'} eq 'str') {
3923 @projects = sort {$a->{$oi->{'key'}} cmp $b->{$oi->{'key'}}} @projects;
3925 @projects = sort {$a->{$oi->{'key'}} <=> $b->{$oi->{'key'}}} @projects;
3928 my $show_ctags = gitweb_check_feature
('ctags');
3931 foreach my $p (@projects) {
3932 foreach my $ct (keys %{$p->{'ctags'}}) {
3933 $ctags{$ct} += $p->{'ctags'}->{$ct};
3936 my $cloud = git_populate_project_tagcloud
(\
%ctags);
3937 print git_show_project_tagcloud
($cloud, 64);
3940 print "<table class=\"project_list\">\n";
3941 unless ($no_header) {
3944 print "<th></th>\n";
3946 print_sort_th
('project', $order, 'Project');
3947 print_sort_th
('descr', $order, 'Description');
3948 print_sort_th
('owner', $order, 'Owner');
3949 print_sort_th
('age', $order, 'Last Change');
3950 print "<th></th>\n" . # for links
3954 my $tagfilter = $cgi->param('by_tag');
3955 for (my $i = $from; $i <= $to; $i++) {
3956 my $pr = $projects[$i];
3958 next if $tagfilter and $show_ctags and not grep { lc $_ eq lc $tagfilter } keys %{$pr->{'ctags'}};
3959 next if $searchtext and not $pr->{'path'} =~ /$searchtext/
3960 and not $pr->{'descr_long'} =~ /$searchtext/;
3961 # Weed out forks or non-matching entries of search
3963 my $forkbase = $project; $forkbase ||= ''; $forkbase =~ s
#\.git$#/#;
3964 $forkbase="^$forkbase" if $forkbase;
3965 next if not $searchtext and not $tagfilter and $show_ctags
3966 and $pr->{'path'} =~ m
#$forkbase.*/.*#; # regexp-safe
3970 print "<tr class=\"dark\">\n";
3972 print "<tr class=\"light\">\n";
3977 if ($pr->{'forks'}) {
3978 print "<!-- $pr->{'forks'} -->\n";
3979 print $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "+");
3983 print "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
3984 -class => "list"}, esc_html
($pr->{'path'})) . "</td>\n" .
3985 "<td>" . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary"),
3986 -class => "list", -title
=> $pr->{'descr_long'}},
3987 esc_html
($pr->{'descr'})) . "</td>\n" .
3988 "<td><i>" . chop_and_escape_str
($pr->{'owner'}, 15) . "</i></td>\n";
3989 print "<td class=\"". age_class
($pr->{'age'}) . "\">" .
3990 (defined $pr->{'age_string'} ?
$pr->{'age_string'} : "No commits") . "</td>\n" .
3991 "<td class=\"link\">" .
3992 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"summary")}, "summary") . " | " .
3993 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"shortlog")}, "shortlog") . " | " .
3994 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"log")}, "log") . " | " .
3995 $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"tree")}, "tree") .
3996 ($pr->{'forks'} ?
" | " . $cgi->a({-href
=> href
(project
=>$pr->{'path'}, action
=>"forks")}, "forks") : '') .
4000 if (defined $extra) {
4003 print "<td></td>\n";
4005 print "<td colspan=\"5\">$extra</td>\n" .
4011 sub git_shortlog_body
{
4012 # uses global variable $project
4013 my ($commitlist, $from, $to, $refs, $extra) = @_;
4015 $from = 0 unless defined $from;
4016 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4018 print "<table class=\"shortlog\">\n";
4020 for (my $i = $from; $i <= $to; $i++) {
4021 my %co = %{$commitlist->[$i]};
4022 my $commit = $co{'id'};
4023 my $ref = format_ref_marker
($refs, $commit);
4025 print "<tr class=\"dark\">\n";
4027 print "<tr class=\"light\">\n";
4030 my $author = chop_and_escape_str
($co{'author_name'}, 10);
4031 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
4032 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4033 "<td><i>" . $author . "</i></td>\n" .
4035 print format_subject_html
($co{'title'}, $co{'title_short'},
4036 href
(action
=>"commit", hash
=>$commit), $ref);
4038 "<td class=\"link\">" .
4039 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") . " | " .
4040 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") . " | " .
4041 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree");
4042 my $snapshot_links = format_snapshot_links
($commit);
4043 if (defined $snapshot_links) {
4044 print " | " . $snapshot_links;
4049 if (defined $extra) {
4051 "<td colspan=\"4\">$extra</td>\n" .
4057 sub git_history_body
{
4058 # Warning: assumes constant type (blob or tree) during history
4059 my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
4061 $from = 0 unless defined $from;
4062 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
4064 print "<table class=\"history\">\n";
4066 for (my $i = $from; $i <= $to; $i++) {
4067 my %co = %{$commitlist->[$i]};
4071 my $commit = $co{'id'};
4073 my $ref = format_ref_marker
($refs, $commit);
4076 print "<tr class=\"dark\">\n";
4078 print "<tr class=\"light\">\n";
4081 # shortlog uses chop_str($co{'author_name'}, 10)
4082 my $author = chop_and_escape_str
($co{'author_name'}, 15, 3);
4083 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4084 "<td><i>" . $author . "</i></td>\n" .
4086 # originally git_history used chop_str($co{'title'}, 50)
4087 print format_subject_html
($co{'title'}, $co{'title_short'},
4088 href
(action
=>"commit", hash
=>$commit), $ref);
4090 "<td class=\"link\">" .
4091 $cgi->a({-href
=> href
(action
=>$ftype, hash_base
=>$commit, file_name
=>$file_name)}, $ftype) . " | " .
4092 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff");
4094 if ($ftype eq 'blob') {
4095 my $blob_current = git_get_hash_by_path
($hash_base, $file_name);
4096 my $blob_parent = git_get_hash_by_path
($commit, $file_name);
4097 if (defined $blob_current && defined $blob_parent &&
4098 $blob_current ne $blob_parent) {
4100 $cgi->a({-href
=> href
(action
=>"blobdiff",
4101 hash
=>$blob_current, hash_parent
=>$blob_parent,
4102 hash_base
=>$hash_base, hash_parent_base
=>$commit,
4103 file_name
=>$file_name)},
4110 if (defined $extra) {
4112 "<td colspan=\"4\">$extra</td>\n" .
4119 # uses global variable $project
4120 my ($taglist, $from, $to, $extra) = @_;
4121 $from = 0 unless defined $from;
4122 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
4124 print "<table class=\"tags\">\n";
4126 for (my $i = $from; $i <= $to; $i++) {
4127 my $entry = $taglist->[$i];
4129 my $comment = $tag{'subject'};
4131 if (defined $comment) {
4132 $comment_short = chop_str
($comment, 30, 5);
4135 print "<tr class=\"dark\">\n";
4137 print "<tr class=\"light\">\n";
4140 if (defined $tag{'age'}) {
4141 print "<td><i>$tag{'age'}</i></td>\n";
4143 print "<td></td>\n";
4146 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'}),
4147 -class => "list name"}, esc_html
($tag{'name'})) .
4150 if (defined $comment) {
4151 print format_subject_html
($comment, $comment_short,
4152 href
(action
=>"tag", hash
=>$tag{'id'}));
4155 "<td class=\"selflink\">";
4156 if ($tag{'type'} eq "tag") {
4157 print $cgi->a({-href
=> href
(action
=>"tag", hash
=>$tag{'id'})}, "tag");
4162 "<td class=\"link\">" . " | " .
4163 $cgi->a({-href
=> href
(action
=>$tag{'reftype'}, hash
=>$tag{'refid'})}, $tag{'reftype'});
4164 if ($tag{'reftype'} eq "commit") {
4165 print " | " . $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$tag{'fullname'})}, "shortlog") .
4166 " | " . $cgi->a({-href
=> href
(action
=>"log", hash
=>$tag{'fullname'})}, "log");
4167 } elsif ($tag{'reftype'} eq "blob") {
4168 print " | " . $cgi->a({-href
=> href
(action
=>"blob_plain", hash
=>$tag{'refid'})}, "raw");
4173 if (defined $extra) {
4175 "<td colspan=\"5\">$extra</td>\n" .
4181 sub git_heads_body
{
4182 # uses global variable $project
4183 my ($headlist, $head, $from, $to, $extra) = @_;
4184 $from = 0 unless defined $from;
4185 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
4187 print "<table class=\"heads\">\n";
4189 for (my $i = $from; $i <= $to; $i++) {
4190 my $entry = $headlist->[$i];
4192 my $curr = $ref{'id'} eq $head;
4194 print "<tr class=\"dark\">\n";
4196 print "<tr class=\"light\">\n";
4199 print "<td><i>$ref{'age'}</i></td>\n" .
4200 ($curr ?
"<td class=\"current_head\">" : "<td>") .
4201 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'}),
4202 -class => "list name"},esc_html
($ref{'name'})) .
4204 "<td class=\"link\">" .
4205 $cgi->a({-href
=> href
(action
=>"shortlog", hash
=>$ref{'fullname'})}, "shortlog") . " | " .
4206 $cgi->a({-href
=> href
(action
=>"log", hash
=>$ref{'fullname'})}, "log") . " | " .
4207 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$ref{'fullname'}, hash_base
=>$ref{'name'})}, "tree") .
4211 if (defined $extra) {
4213 "<td colspan=\"3\">$extra</td>\n" .
4219 sub git_search_grep_body
{
4220 my ($commitlist, $from, $to, $extra) = @_;
4221 $from = 0 unless defined $from;
4222 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
4224 print "<table class=\"commit_search\">\n";
4226 for (my $i = $from; $i <= $to; $i++) {
4227 my %co = %{$commitlist->[$i]};
4231 my $commit = $co{'id'};
4233 print "<tr class=\"dark\">\n";
4235 print "<tr class=\"light\">\n";
4238 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
4239 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
4240 "<td><i>" . $author . "</i></td>\n" .
4242 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
4243 -class => "list subject"},
4244 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
4245 my $comment = $co{'comment'};
4246 foreach my $line (@
$comment) {
4247 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
4248 my ($lead, $match, $trail) = ($1, $2, $3);
4249 $match = chop_str
($match, 70, 5, 'center');
4250 my $contextlen = int((80 - length($match))/2);
4251 $contextlen = 30 if ($contextlen > 30);
4252 $lead = chop_str
($lead, $contextlen, 10, 'left');
4253 $trail = chop_str
($trail, $contextlen, 10, 'right');
4255 $lead = esc_html
($lead);
4256 $match = esc_html
($match);
4257 $trail = esc_html
($trail);
4259 print "$lead<span class=\"match\">$match</span>$trail<br />";
4263 "<td class=\"link\">" .
4264 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
4266 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$co{'id'})}, "commitdiff") .
4268 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
4272 if (defined $extra) {
4274 "<td colspan=\"3\">$extra</td>\n" .
4280 ## ======================================================================
4281 ## ======================================================================
4284 sub git_project_list
{
4285 my $order = $input_params{'order'};
4286 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4287 die_error
(400, "Unknown order parameter");
4290 my @list = git_get_projects_list
();
4292 die_error
(404, "No projects found");
4296 if (-f
$home_text) {
4297 print "<div class=\"index_include\">\n";
4298 open (my $fd, $home_text);
4303 print $cgi->startform(-method
=> "get") .
4304 "<p class=\"projsearch\">Search:\n" .
4305 $cgi->textfield(-name
=> "s", -value
=> $searchtext) . "\n" .
4307 $cgi->end_form() . "\n";
4308 git_project_list_body
(\
@list, $order);
4313 my $order = $input_params{'order'};
4314 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
4315 die_error
(400, "Unknown order parameter");
4318 my @list = git_get_projects_list
($project);
4320 die_error
(404, "No forks found");
4324 git_print_page_nav
('','');
4325 git_print_header_div
('summary', "$project forks");
4326 git_project_list_body
(\
@list, $order);
4330 sub git_project_index
{
4331 my @projects = git_get_projects_list
($project);
4334 -type
=> 'text/plain',
4335 -charset
=> 'utf-8',
4336 -content_disposition
=> 'inline; filename="index.aux"');
4338 foreach my $pr (@projects) {
4339 if (!exists $pr->{'owner'}) {
4340 $pr->{'owner'} = git_get_project_owner
("$pr->{'path'}");
4343 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
4344 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
4345 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4346 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf
("%%%02X", ord($1))/eg
;
4350 print "$path $owner\n";
4355 my $descr = git_get_project_description
($project) || "none";
4356 my %co = parse_commit
("HEAD");
4357 my %cd = %co ? parse_date
($co{'committer_epoch'}, $co{'committer_tz'}) : ();
4358 my $head = $co{'id'};
4360 my $owner = git_get_project_owner
($project);
4362 my $refs = git_get_references
();
4363 # These get_*_list functions return one more to allow us to see if
4364 # there are more ...
4365 my @taglist = git_get_tags_list
(16);
4366 my @headlist = git_get_heads_list
(16);
4368 my ($check_forks) = gitweb_check_feature
('forks');
4371 @forklist = git_get_projects_list
($project);
4375 git_print_page_nav
('summary','', $head);
4377 print "<div class=\"title\"> </div>\n";
4378 print "<table class=\"projects_list\">\n" .
4379 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html
($descr) . "</td></tr>\n" .
4380 "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html
($owner) . "</td></tr>\n";
4381 if (defined $cd{'rfc2822'}) {
4382 print "<tr id=\"metadata_lchange\"><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
4385 # use per project git URL list in $projectroot/$project/cloneurl
4386 # or make project git URL from git base URL and project name
4387 my $url_tag = "URL";
4388 my @url_list = git_get_project_url_list
($project);
4389 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
4390 foreach my $git_url (@url_list) {
4391 next unless $git_url;
4392 print "<tr class=\"metadata_url\"><td>$url_tag</td><td>$git_url</td></tr>\n";
4397 my $show_ctags = (gitweb_check_feature
('ctags'))[0];
4399 my $ctags = git_get_project_ctags
($project);
4400 my $cloud = git_populate_project_tagcloud
($ctags);
4401 print "<tr id=\"metadata_ctags\"><td>Content tags:<br />";
4402 print "</td>\n<td>" unless %$ctags;
4403 print "<form action=\"$show_ctags\" method=\"post\"><input type=\"hidden\" name=\"p\" value=\"$project\" />Add: <input type=\"text\" name=\"t\" size=\"8\" /></form>";
4404 print "</td>\n<td>" if %$ctags;
4405 print git_show_project_tagcloud
($cloud, 48);
4411 if (-s
"$projectroot/$project/README.html") {
4412 if (open my $fd, "$projectroot/$project/README.html") {
4413 print "<div class=\"title\">readme</div>\n" .
4414 "<div class=\"readme\">\n";
4415 print $_ while (<$fd>);
4416 print "\n</div>\n"; # class="readme"
4421 # we need to request one more than 16 (0..15) to check if
4423 my @commitlist = $head ? parse_commits
($head, 17) : ();
4425 git_print_header_div
('shortlog');
4426 git_shortlog_body
(\
@commitlist, 0, 15, $refs,
4427 $#commitlist <= 15 ?
undef :
4428 $cgi->a({-href
=> href
(action
=>"shortlog")}, "..."));
4432 git_print_header_div
('tags');
4433 git_tags_body
(\
@taglist, 0, 15,
4434 $#taglist <= 15 ?
undef :
4435 $cgi->a({-href
=> href
(action
=>"tags")}, "..."));
4439 git_print_header_div
('heads');
4440 git_heads_body
(\
@headlist, $head, 0, 15,
4441 $#headlist <= 15 ?
undef :
4442 $cgi->a({-href
=> href
(action
=>"heads")}, "..."));
4446 git_print_header_div
('forks');
4447 git_project_list_body
(\
@forklist, 'age', 0, 15,
4448 $#forklist <= 15 ?
undef :
4449 $cgi->a({-href
=> href
(action
=>"forks")}, "..."),
4457 my $head = git_get_head_hash
($project);
4459 git_print_page_nav
('','', $head,undef,$head);
4460 my %tag = parse_tag
($hash);
4463 die_error
(404, "Unknown tag object");
4466 git_print_header_div
('commit', esc_html
($tag{'name'}), $hash);
4467 print "<div class=\"title_text\">\n" .
4468 "<table class=\"object_header\">\n" .
4470 "<td>object</td>\n" .
4471 "<td>" . $cgi->a({-class => "list", -href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4472 $tag{'object'}) . "</td>\n" .
4473 "<td class=\"link\">" . $cgi->a({-href
=> href
(action
=>$tag{'type'}, hash
=>$tag{'object'})},
4474 $tag{'type'}) . "</td>\n" .
4476 if (defined($tag{'author'})) {
4477 my %ad = parse_date
($tag{'epoch'}, $tag{'tz'});
4478 print "<tr><td>author</td><td>" . esc_html
($tag{'author'}) . "</td></tr>\n";
4479 print "<tr><td></td><td>" . $ad{'rfc2822'} .
4480 sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
4483 print "</table>\n\n" .
4485 print "<div class=\"page_body\">";
4486 my $comment = $tag{'comment'};
4487 foreach my $line (@
$comment) {
4489 print esc_html
($line, -nbsp
=>1) . "<br/>\n";
4499 gitweb_check_feature
('blame')
4500 or die_error
(403, "Blame view not allowed");
4502 die_error
(400, "No file name given") unless $file_name;
4503 $hash_base ||= git_get_head_hash
($project);
4504 die_error
(404, "Couldn't find base commit") unless ($hash_base);
4505 my %co = parse_commit
($hash_base)
4506 or die_error
(404, "Commit not found");
4507 if (!defined $hash) {
4508 $hash = git_get_hash_by_path
($hash_base, $file_name, "blob")
4509 or die_error
(404, "Error looking up file");
4511 $ftype = git_get_type
($hash);
4512 if ($ftype !~ "blob") {
4513 die_error
(400, "Object is not a blob");
4515 open ($fd, "-|", git_cmd
(), "blame", '-p', '--',
4516 $file_name, $hash_base)
4517 or die_error
(500, "Open git-blame failed");
4520 $cgi->a({-href
=> href
(action
=>"blob", -replay
=>1)},
4523 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4526 $cgi->a({-href
=> href
(action
=>"blame", file_name
=>$file_name)},
4528 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4529 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4530 git_print_page_path
($file_name, $ftype, $hash_base);
4531 my @rev_color = (qw(light2 dark2));
4532 my $num_colors = scalar(@rev_color);
4533 my $current_color = 0;
4536 <div class="page_body">
4537 <table class="blame">
4538 <tr><th>Commit</th><th>Line</th><th>Data</th></tr>
4543 last unless defined $_;
4544 my ($full_rev, $orig_lineno, $lineno, $group_size) =
4545 /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/;
4546 if (!exists $metainfo{$full_rev}) {
4547 $metainfo{$full_rev} = {};
4549 my $meta = $metainfo{$full_rev};
4552 if (/^(\S+) (.*)$/) {
4558 my $rev = substr($full_rev, 0, 8);
4559 my $author = $meta->{'author'};
4560 my %date = parse_date
($meta->{'author-time'},
4561 $meta->{'author-tz'});
4562 my $date = $date{'iso-tz'};
4564 $current_color = ++$current_color % $num_colors;
4566 print "<tr class=\"$rev_color[$current_color]\">\n";
4568 print "<td class=\"sha1\"";
4569 print " title=\"". esc_html
($author) . ", $date\"";
4570 print " rowspan=\"$group_size\"" if ($group_size > 1);
4572 print $cgi->a({-href
=> href
(action
=>"commit",
4574 file_name
=>$file_name)},
4578 open (my $dd, "-|", git_cmd
(), "rev-parse", "$full_rev^")
4579 or die_error
(500, "Open git-rev-parse failed");
4580 my $parent_commit = <$dd>;
4582 chomp($parent_commit);
4583 my $blamed = href
(action
=> 'blame',
4584 file_name
=> $meta->{'filename'},
4585 hash_base
=> $parent_commit);
4586 print "<td class=\"linenr\">";
4587 print $cgi->a({ -href
=> "$blamed#l$orig_lineno",
4589 -class => "linenr" },
4592 print "<td class=\"pre\">" . esc_html
($data) . "</td>\n";
4598 or print "Reading blob failed\n";
4603 my $head = git_get_head_hash
($project);
4605 git_print_page_nav
('','', $head,undef,$head);
4606 git_print_header_div
('summary', $project);
4608 my @tagslist = git_get_tags_list
();
4610 git_tags_body
(\
@tagslist);
4616 my $head = git_get_head_hash
($project);
4618 git_print_page_nav
('','', $head,undef,$head);
4619 git_print_header_div
('summary', $project);
4621 my @headslist = git_get_heads_list
();
4623 git_heads_body
(\
@headslist, $head);
4628 sub git_blob_plain
{
4632 if (!defined $hash) {
4633 if (defined $file_name) {
4634 my $base = $hash_base || git_get_head_hash
($project);
4635 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4636 or die_error
(404, "Cannot find file");
4638 die_error
(400, "No file name defined");
4640 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4641 # blobs defined by non-textual hash id's can be cached
4645 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4646 or die_error
(500, "Open git-cat-file blob '$hash' failed");
4648 # content-type (can include charset)
4649 $type = blob_contenttype
($fd, $file_name, $type);
4651 # "save as" filename, even when no $file_name is given
4652 my $save_as = "$hash";
4653 if (defined $file_name) {
4654 $save_as = $file_name;
4655 } elsif ($type =~ m/^text\//) {
4661 -expires
=> $expires,
4662 -content_disposition
=> 'inline; filename="' . $save_as . '"');
4664 binmode STDOUT
, ':raw';
4666 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
4674 if (!defined $hash) {
4675 if (defined $file_name) {
4676 my $base = $hash_base || git_get_head_hash
($project);
4677 $hash = git_get_hash_by_path
($base, $file_name, "blob")
4678 or die_error
(404, "Cannot find file");
4680 die_error
(400, "No file name defined");
4682 } elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
4683 # blobs defined by non-textual hash id's can be cached
4687 my ($have_blame) = gitweb_check_feature
('blame');
4688 open my $fd, "-|", git_cmd
(), "cat-file", "blob", $hash
4689 or die_error
(500, "Couldn't cat $file_name, $hash");
4690 my $mimetype = blob_mimetype
($fd, $file_name);
4691 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B
$fd) {
4693 return git_blob_plain
($mimetype);
4695 # we can have blame only for text/* mimetype
4696 $have_blame &&= ($mimetype =~ m!^text/!);
4698 git_header_html
(undef, $expires);
4699 my $formats_nav = '';
4700 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4701 if (defined $file_name) {
4704 $cgi->a({-href
=> href
(action
=>"blame", -replay
=>1)},
4709 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4712 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4715 $cgi->a({-href
=> href
(action
=>"blob",
4716 hash_base
=>"HEAD", file_name
=>$file_name)},
4720 $cgi->a({-href
=> href
(action
=>"blob_plain", -replay
=>1)},
4723 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
4724 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
4726 print "<div class=\"page_nav\">\n" .
4727 "<br/><br/></div>\n" .
4728 "<div class=\"title\">$hash</div>\n";
4730 git_print_page_path
($file_name, "blob", $hash_base);
4731 print "<div class=\"page_body\">\n";
4732 if ($mimetype =~ m!^image/!) {
4733 print qq!<img type
="$mimetype"!;
4735 print qq! alt
="$file_name" title
="$file_name"!;
4738 href(action=>"blob_plain
", hash=>$hash,
4739 hash_base=>$hash_base, file_name=>$file_name) .
4743 while (my $line = <$fd>) {
4746 $line = untabify
($line);
4747 printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
4748 $nr, $nr, $nr, esc_html
($line, -nbsp
=>1);
4752 or print "Reading blob failed.\n";
4758 if (!defined $hash_base) {
4759 $hash_base = "HEAD";
4761 if (!defined $hash) {
4762 if (defined $file_name) {
4763 $hash = git_get_hash_by_path
($hash_base, $file_name, "tree");
4768 die_error
(404, "No such tree") unless defined($hash);
4770 open my $fd, "-|", git_cmd
(), "ls-tree", '-z', $hash
4771 or die_error
(500, "Open git-ls-tree failed");
4772 my @entries = map { chomp; $_ } <$fd>;
4773 close $fd or die_error
(404, "Reading tree failed");
4776 my $refs = git_get_references
();
4777 my $ref = format_ref_marker
($refs, $hash_base);
4780 my ($have_blame) = gitweb_check_feature
('blame');
4781 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
4783 if (defined $file_name) {
4785 $cgi->a({-href
=> href
(action
=>"history", -replay
=>1)},
4787 $cgi->a({-href
=> href
(action
=>"tree",
4788 hash_base
=>"HEAD", file_name
=>$file_name)},
4791 my $snapshot_links = format_snapshot_links
($hash);
4792 if (defined $snapshot_links) {
4793 # FIXME: Should be available when we have no hash base as well.
4794 push @views_nav, $snapshot_links;
4796 git_print_page_nav
('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
4797 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash_base);
4800 print "<div class=\"page_nav\">\n";
4801 print "<br/><br/></div>\n";
4802 print "<div class=\"title\">$hash</div>\n";
4804 if (defined $file_name) {
4805 $basedir = $file_name;
4806 if ($basedir ne '' && substr($basedir, -1) ne '/') {
4809 git_print_page_path
($file_name, 'tree', $hash_base);
4811 print "<div class=\"page_body\">\n";
4812 print "<table class=\"tree\">\n";
4814 # '..' (top directory) link if possible
4815 if (defined $hash_base &&
4816 defined $file_name && $file_name =~ m![^/]+$!) {
4818 print "<tr class=\"dark\">\n";
4820 print "<tr class=\"light\">\n";
4824 my $up = $file_name;
4825 $up =~ s!/?[^/]+$!!;
4826 undef $up unless $up;
4827 # based on git_print_tree_entry
4828 print '<td class="mode">' . mode_str
('040000') . "</td>\n";
4829 print '<td class="list">';
4830 print $cgi->a({-href
=> href
(action
=>"tree", hash_base
=>$hash_base,
4834 print "<td class=\"link\"></td>\n";
4838 foreach my $line (@entries) {
4839 my %t = parse_ls_tree_line
($line, -z
=> 1);
4842 print "<tr class=\"dark\">\n";
4844 print "<tr class=\"light\">\n";
4848 git_print_tree_entry
(\
%t, $basedir, $hash_base, $have_blame);
4852 print "</table>\n" .
4858 my @supported_fmts = gitweb_check_feature
('snapshot');
4859 @supported_fmts = filter_snapshot_fmts
(@supported_fmts);
4861 my $format = $input_params{'snapshot_format'};
4862 if (!@supported_fmts) {
4863 die_error
(403, "Snapshots not allowed");
4865 # default to first supported snapshot format
4866 $format ||= $supported_fmts[0];
4867 if ($format !~ m/^[a-z0-9]+$/) {
4868 die_error
(400, "Invalid snapshot format parameter");
4869 } elsif (!exists($known_snapshot_formats{$format})) {
4870 die_error
(400, "Unknown snapshot format");
4871 } elsif (!grep($_ eq $format, @supported_fmts)) {
4872 die_error
(403, "Unsupported snapshot format");
4875 if (!defined $hash) {
4876 $hash = git_get_head_hash
($project);
4879 my $name = $project;
4880 $name =~ s
,([^/])/*\
.git
$,$1,;
4881 $name = basename
($name);
4882 my $filename = to_utf8
($name);
4883 $name =~ s/\047/\047\\\047\047/g;
4885 $filename .= "-$hash$known_snapshot_formats{$format}{'suffix'}";
4886 $cmd = quote_command
(
4887 git_cmd
(), 'archive',
4888 "--format=$known_snapshot_formats{$format}{'format'}",
4889 "--prefix=$name/", $hash);
4890 if (exists $known_snapshot_formats{$format}{'compressor'}) {
4891 $cmd .= ' | ' . quote_command
(@
{$known_snapshot_formats{$format}{'compressor'}});
4895 -type
=> $known_snapshot_formats{$format}{'type'},
4896 -content_disposition
=> 'inline; filename="' . "$filename" . '"',
4897 -status
=> '200 OK');
4899 open my $fd, "-|", $cmd
4900 or die_error
(500, "Execute git-archive failed");
4901 binmode STDOUT
, ':raw';
4903 binmode STDOUT
, ':utf8'; # as set at the beginning of gitweb.cgi
4908 my $head = git_get_head_hash
($project);
4909 if (!defined $hash) {
4912 if (!defined $page) {
4915 my $refs = git_get_references
();
4917 my @commitlist = parse_commits
($hash, 101, (100 * $page));
4919 my $paging_nav = format_paging_nav
('log', $hash, $head, $page, $#commitlist >= 100);
4922 git_print_page_nav
('log','', $hash,undef,undef, $paging_nav);
4925 my %co = parse_commit
($hash);
4927 git_print_header_div
('summary', $project);
4928 print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
4930 my $to = ($#commitlist >= 99) ?
(99) : ($#commitlist);
4931 for (my $i = 0; $i <= $to; $i++) {
4932 my %co = %{$commitlist[$i]};
4934 my $commit = $co{'id'};
4935 my $ref = format_ref_marker
($refs, $commit);
4936 my %ad = parse_date
($co{'author_epoch'});
4937 git_print_header_div
('commit',
4938 "<span class=\"age\">$co{'age_string'}</span>" .
4939 esc_html
($co{'title'}) . $ref,
4941 print "<div class=\"title_text\">\n" .
4942 "<div class=\"log_link\">\n" .
4943 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$commit)}, "commit") .
4945 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$commit)}, "commitdiff") .
4947 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$commit, hash_base
=>$commit)}, "tree") .
4950 "<i>" . esc_html
($co{'author_name'}) . " [$ad{'rfc2822'}]</i><br/>\n" .
4953 print "<div class=\"log_body\">\n";
4954 git_print_log
($co{'comment'}, -final_empty_line
=> 1);
4957 if ($#commitlist >= 100) {
4958 print "<div class=\"page_nav\">\n";
4959 print $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
4960 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
4967 $hash ||= $hash_base || "HEAD";
4968 my %co = parse_commit
($hash)
4969 or die_error
(404, "Unknown commit object");
4970 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
4971 my %cd = parse_date
($co{'committer_epoch'}, $co{'committer_tz'});
4973 my $parent = $co{'parent'};
4974 my $parents = $co{'parents'}; # listref
4976 # we need to prepare $formats_nav before any parameter munging
4978 if (!defined $parent) {
4980 $formats_nav .= '(initial)';
4981 } elsif (@
$parents == 1) {
4982 # single parent commit
4985 $cgi->a({-href
=> href
(action
=>"commit",
4987 esc_html
(substr($parent, 0, 7))) .
4994 $cgi->a({-href
=> href
(action
=>"commit",
4996 esc_html
(substr($_, 0, 7)));
5001 if (!defined $parent) {
5005 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', "--no-commit-id",
5007 (@
$parents <= 1 ?
$parent : '-c'),
5009 or die_error
(500, "Open git-diff-tree failed");
5010 @difftree = map { chomp; $_ } <$fd>;
5011 close $fd or die_error
(404, "Reading git-diff-tree failed");
5013 # non-textual hash id's can be cached
5015 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5018 my $refs = git_get_references
();
5019 my $ref = format_ref_marker
($refs, $co{'id'});
5021 git_header_html
(undef, $expires);
5022 git_print_page_nav
('commit', '',
5023 $hash, $co{'tree'}, $hash,
5026 if (defined $co{'parent'}) {
5027 git_print_header_div
('commitdiff', esc_html
($co{'title'}) . $ref, $hash);
5029 git_print_header_div
('tree', esc_html
($co{'title'}) . $ref, $co{'tree'}, $hash);
5031 print "<div class=\"title_text\">\n" .
5032 "<table class=\"object_header\">\n";
5033 print "<tr><td>author</td><td>" . esc_html
($co{'author'}) . "</td></tr>\n".
5035 "<td></td><td> $ad{'rfc2822'}";
5036 if ($ad{'hour_local'} < 6) {
5037 printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
5038 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
5040 printf(" (%02d:%02d %s)",
5041 $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
5045 print "<tr><td>committer</td><td>" . esc_html
($co{'committer'}) . "</td></tr>\n";
5046 print "<tr><td></td><td> $cd{'rfc2822'}" .
5047 sprintf(" (%02d:%02d %s)", $cd{'hour_local'}, $cd{'minute_local'}, $cd{'tz_local'}) .
5049 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
5052 "<td class=\"sha1\">" .
5053 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash),
5054 class => "list"}, $co{'tree'}) .
5056 "<td class=\"link\">" .
5057 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$hash)},
5059 my $snapshot_links = format_snapshot_links
($hash);
5060 if (defined $snapshot_links) {
5061 print " | " . $snapshot_links;
5066 foreach my $par (@
$parents) {
5069 "<td class=\"sha1\">" .
5070 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par),
5071 class => "list"}, $par) .
5073 "<td class=\"link\">" .
5074 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$par)}, "commit") .
5076 $cgi->a({-href
=> href
(action
=>"commitdiff", hash
=>$hash, hash_parent
=>$par)}, "diff") .
5083 print "<div class=\"page_body\">\n";
5084 git_print_log
($co{'comment'});
5087 git_difftree_body
(\
@difftree, $hash, @
$parents);
5093 # object is defined by:
5094 # - hash or hash_base alone
5095 # - hash_base and file_name
5098 # - hash or hash_base alone
5099 if ($hash || ($hash_base && !defined $file_name)) {
5100 my $object_id = $hash || $hash_base;
5102 open my $fd, "-|", quote_command
(
5103 git_cmd
(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
5104 or die_error
(404, "Object does not exist");
5108 or die_error
(404, "Object does not exist");
5110 # - hash_base and file_name
5111 } elsif ($hash_base && defined $file_name) {
5112 $file_name =~ s
,/+$,,;
5114 system(git_cmd
(), "cat-file", '-e', $hash_base) == 0
5115 or die_error
(404, "Base object does not exist");
5117 # here errors should not hapen
5118 open my $fd, "-|", git_cmd
(), "ls-tree", $hash_base, "--", $file_name
5119 or die_error
(500, "Open git-ls-tree failed");
5123 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
5124 unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
5125 die_error
(404, "File or directory for given base does not exist");
5130 die_error
(400, "Not enough information to find object");
5133 print $cgi->redirect(-uri
=> href
(action
=>$type, -full
=>1,
5134 hash
=>$hash, hash_base
=>$hash_base,
5135 file_name
=>$file_name),
5136 -status
=> '302 Found');
5140 my $format = shift || 'html';
5147 # preparing $fd and %diffinfo for git_patchset_body
5149 if (defined $hash_base && defined $hash_parent_base) {
5150 if (defined $file_name) {
5152 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5153 $hash_parent_base, $hash_base,
5154 "--", (defined $file_parent ?
$file_parent : ()), $file_name
5155 or die_error
(500, "Open git-diff-tree failed");
5156 @difftree = map { chomp; $_ } <$fd>;
5158 or die_error
(404, "Reading git-diff-tree failed");
5160 or die_error
(404, "Blob diff not found");
5162 } elsif (defined $hash &&
5163 $hash =~ /[0-9a-fA-F]{40}/) {
5164 # try to find filename from $hash
5166 # read filtered raw output
5167 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5168 $hash_parent_base, $hash_base, "--"
5169 or die_error
(500, "Open git-diff-tree failed");
5171 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
5173 grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
5174 map { chomp; $_ } <$fd>;
5176 or die_error
(404, "Reading git-diff-tree failed");
5178 or die_error
(404, "Blob diff not found");
5181 die_error
(400, "Missing one of the blob diff parameters");
5184 if (@difftree > 1) {
5185 die_error
(400, "Ambiguous blob diff specification");
5188 %diffinfo = parse_difftree_raw_line
($difftree[0]);
5189 $file_parent ||= $diffinfo{'from_file'} || $file_name;
5190 $file_name ||= $diffinfo{'to_file'};
5192 $hash_parent ||= $diffinfo{'from_id'};
5193 $hash ||= $diffinfo{'to_id'};
5195 # non-textual hash id's can be cached
5196 if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
5197 $hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
5202 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5203 '-p', ($format eq 'html' ?
"--full-index" : ()),
5204 $hash_parent_base, $hash_base,
5205 "--", (defined $file_parent ?
$file_parent : ()), $file_name
5206 or die_error
(500, "Open git-diff-tree failed");
5209 # old/legacy style URI
5210 if (!%diffinfo && # if new style URI failed
5211 defined $hash && defined $hash_parent) {
5212 # fake git-diff-tree raw output
5213 $diffinfo{'from_mode'} = $diffinfo{'to_mode'} = "blob";
5214 $diffinfo{'from_id'} = $hash_parent;
5215 $diffinfo{'to_id'} = $hash;
5216 if (defined $file_name) {
5217 if (defined $file_parent) {
5218 $diffinfo{'status'} = '2';
5219 $diffinfo{'from_file'} = $file_parent;
5220 $diffinfo{'to_file'} = $file_name;
5221 } else { # assume not renamed
5222 $diffinfo{'status'} = '1';
5223 $diffinfo{'from_file'} = $file_name;
5224 $diffinfo{'to_file'} = $file_name;
5226 } else { # no filename given
5227 $diffinfo{'status'} = '2';
5228 $diffinfo{'from_file'} = $hash_parent;
5229 $diffinfo{'to_file'} = $hash;
5232 # non-textual hash id's can be cached
5233 if ($hash =~ m/^[0-9a-fA-F]{40}$/ &&
5234 $hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5239 open $fd, "-|", git_cmd
(), "diff", @diff_opts,
5240 '-p', ($format eq 'html' ?
"--full-index" : ()),
5241 $hash_parent, $hash, "--"
5242 or die_error
(500, "Open git-diff failed");
5244 die_error
(400, "Missing one of the blob diff parameters")
5249 if ($format eq 'html') {
5251 $cgi->a({-href
=> href
(action
=>"blobdiff_plain", -replay
=>1)},
5253 git_header_html
(undef, $expires);
5254 if (defined $hash_base && (my %co = parse_commit
($hash_base))) {
5255 git_print_page_nav
('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
5256 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5258 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
5259 print "<div class=\"title\">$hash vs $hash_parent</div>\n";
5261 if (defined $file_name) {
5262 git_print_page_path
($file_name, "blob", $hash_base);
5264 print "<div class=\"page_path\"></div>\n";
5267 } elsif ($format eq 'plain') {
5269 -type
=> 'text/plain',
5270 -charset
=> 'utf-8',
5271 -expires
=> $expires,
5272 -content_disposition
=> 'inline; filename="' . "$file_name" . '.patch"');
5274 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5277 die_error
(400, "Unknown blobdiff format");
5281 if ($format eq 'html') {
5282 print "<div class=\"page_body\">\n";
5284 git_patchset_body
($fd, [ \
%diffinfo ], $hash_base, $hash_parent_base);
5287 print "</div>\n"; # class="page_body"
5291 while (my $line = <$fd>) {
5292 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
5293 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
5297 last if $line =~ m!^\+\+\+!;
5305 sub git_blobdiff_plain
{
5306 git_blobdiff
('plain');
5309 sub git_commitdiff
{
5310 my $format = shift || 'html';
5311 $hash ||= $hash_base || "HEAD";
5312 my %co = parse_commit
($hash)
5313 or die_error
(404, "Unknown commit object");
5315 # choose format for commitdiff for merge
5316 if (! defined $hash_parent && @
{$co{'parents'}} > 1) {
5317 $hash_parent = '--cc';
5319 # we need to prepare $formats_nav before almost any parameter munging
5321 if ($format eq 'html') {
5323 $cgi->a({-href
=> href
(action
=>"commitdiff_plain", -replay
=>1)},
5326 if (defined $hash_parent &&
5327 $hash_parent ne '-c' && $hash_parent ne '--cc') {
5328 # commitdiff with two commits given
5329 my $hash_parent_short = $hash_parent;
5330 if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
5331 $hash_parent_short = substr($hash_parent, 0, 7);
5335 for (my $i = 0; $i < @
{$co{'parents'}}; $i++) {
5336 if ($co{'parents'}[$i] eq $hash_parent) {
5337 $formats_nav .= ' parent ' . ($i+1);
5341 $formats_nav .= ': ' .
5342 $cgi->a({-href
=> href
(action
=>"commitdiff",
5343 hash
=>$hash_parent)},
5344 esc_html
($hash_parent_short)) .
5346 } elsif (!$co{'parent'}) {
5348 $formats_nav .= ' (initial)';
5349 } elsif (scalar @
{$co{'parents'}} == 1) {
5350 # single parent commit
5353 $cgi->a({-href
=> href
(action
=>"commitdiff",
5354 hash
=>$co{'parent'})},
5355 esc_html
(substr($co{'parent'}, 0, 7))) .
5359 if ($hash_parent eq '--cc') {
5360 $formats_nav .= ' | ' .
5361 $cgi->a({-href
=> href
(action
=>"commitdiff",
5362 hash
=>$hash, hash_parent
=>'-c')},
5364 } else { # $hash_parent eq '-c'
5365 $formats_nav .= ' | ' .
5366 $cgi->a({-href
=> href
(action
=>"commitdiff",
5367 hash
=>$hash, hash_parent
=>'--cc')},
5373 $cgi->a({-href
=> href
(action
=>"commitdiff",
5375 esc_html
(substr($_, 0, 7)));
5376 } @
{$co{'parents'}} ) .
5381 my $hash_parent_param = $hash_parent;
5382 if (!defined $hash_parent_param) {
5383 # --cc for multiple parents, --root for parentless
5384 $hash_parent_param =
5385 @
{$co{'parents'}} > 1 ?
'--cc' : $co{'parent'} || '--root';
5391 if ($format eq 'html') {
5392 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5393 "--no-commit-id", "--patch-with-raw", "--full-index",
5394 $hash_parent_param, $hash, "--"
5395 or die_error
(500, "Open git-diff-tree failed");
5397 while (my $line = <$fd>) {
5399 # empty line ends raw part of diff-tree output
5401 push @difftree, scalar parse_difftree_raw_line
($line);
5404 } elsif ($format eq 'plain') {
5405 open $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5406 '-p', $hash_parent_param, $hash, "--"
5407 or die_error
(500, "Open git-diff-tree failed");
5410 die_error
(400, "Unknown commitdiff format");
5413 # non-textual hash id's can be cached
5415 if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
5419 # write commit message
5420 if ($format eq 'html') {
5421 my $refs = git_get_references
();
5422 my $ref = format_ref_marker
($refs, $co{'id'});
5424 git_header_html
(undef, $expires);
5425 git_print_page_nav
('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
5426 git_print_header_div
('commit', esc_html
($co{'title'}) . $ref, $hash);
5427 git_print_authorship
(\
%co);
5428 print "<div class=\"page_body\">\n";
5429 if (@
{$co{'comment'}} > 1) {
5430 print "<div class=\"log\">\n";
5431 git_print_log
($co{'comment'}, -final_empty_line
=> 1, -remove_title
=> 1);
5432 print "</div>\n"; # class="log"
5435 } elsif ($format eq 'plain') {
5436 my $refs = git_get_references
("tags");
5437 my $tagname = git_get_rev_name_tags
($hash);
5438 my $filename = basename
($project) . "-$hash.patch";
5441 -type
=> 'text/plain',
5442 -charset
=> 'utf-8',
5443 -expires
=> $expires,
5444 -content_disposition
=> 'inline; filename="' . "$filename" . '"');
5445 my %ad = parse_date
($co{'author_epoch'}, $co{'author_tz'});
5446 print "From: " . to_utf8
($co{'author'}) . "\n";
5447 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
5448 print "Subject: " . to_utf8
($co{'title'}) . "\n";
5450 print "X-Git-Tag: $tagname\n" if $tagname;
5451 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
5453 foreach my $line (@
{$co{'comment'}}) {
5454 print to_utf8
($line) . "\n";
5460 if ($format eq 'html') {
5461 my $use_parents = !defined $hash_parent ||
5462 $hash_parent eq '-c' || $hash_parent eq '--cc';
5463 git_difftree_body
(\
@difftree, $hash,
5464 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5467 git_patchset_body
($fd, \
@difftree, $hash,
5468 $use_parents ? @
{$co{'parents'}} : $hash_parent);
5470 print "</div>\n"; # class="page_body"
5473 } elsif ($format eq 'plain') {
5477 or print "Reading git-diff-tree failed\n";
5481 sub git_commitdiff_plain
{
5482 git_commitdiff
('plain');
5486 if (!defined $hash_base) {
5487 $hash_base = git_get_head_hash
($project);
5489 if (!defined $page) {
5493 my %co = parse_commit
($hash_base)
5494 or die_error
(404, "Unknown commit object");
5496 my $refs = git_get_references
();
5497 my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
5499 my @commitlist = parse_commits
($hash_base, 101, (100 * $page),
5500 $file_name, "--full-history")
5501 or die_error
(404, "No such file or directory on given branch");
5503 if (!defined $hash && defined $file_name) {
5504 # some commits could have deleted file in question,
5505 # and not have it in tree, but one of them has to have it
5506 for (my $i = 0; $i <= @commitlist; $i++) {
5507 $hash = git_get_hash_by_path
($commitlist[$i]{'id'}, $file_name);
5508 last if defined $hash;
5511 if (defined $hash) {
5512 $ftype = git_get_type
($hash);
5514 if (!defined $ftype) {
5515 die_error
(500, "Unknown type of object");
5518 my $paging_nav = '';
5521 $cgi->a({-href
=> href
(action
=>"history", hash
=>$hash, hash_base
=>$hash_base,
5522 file_name
=>$file_name)},
5524 $paging_nav .= " ⋅ " .
5525 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5526 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5528 $paging_nav .= "first";
5529 $paging_nav .= " ⋅ prev";
5532 if ($#commitlist >= 100) {
5534 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5535 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5536 $paging_nav .= " ⋅ $next_link";
5538 $paging_nav .= " ⋅ next";
5542 git_print_page_nav
('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
5543 git_print_header_div
('commit', esc_html
($co{'title'}), $hash_base);
5544 git_print_page_path
($file_name, $ftype, $hash_base);
5546 git_history_body
(\
@commitlist, 0, 99,
5547 $refs, $hash_base, $ftype, $next_link);
5553 gitweb_check_feature
('search') or die_error
(403, "Search is disabled");
5554 if (!defined $searchtext) {
5555 die_error
(400, "Text field is empty");
5557 if (!defined $hash) {
5558 $hash = git_get_head_hash
($project);
5560 my %co = parse_commit
($hash);
5562 die_error
(404, "Unknown commit object");
5564 if (!defined $page) {
5568 $searchtype ||= 'commit';
5569 if ($searchtype eq 'pickaxe') {
5570 # pickaxe may take all resources of your box and run for several minutes
5571 # with every query - so decide by yourself how public you make this feature
5572 gitweb_check_feature
('pickaxe')
5573 or die_error
(403, "Pickaxe is disabled");
5575 if ($searchtype eq 'grep') {
5576 gitweb_check_feature
('grep')
5577 or die_error
(403, "Grep is disabled");
5582 if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
5584 if ($searchtype eq 'commit') {
5585 $greptype = "--grep=";
5586 } elsif ($searchtype eq 'author') {
5587 $greptype = "--author=";
5588 } elsif ($searchtype eq 'committer') {
5589 $greptype = "--committer=";
5591 $greptype .= $searchtext;
5592 my @commitlist = parse_commits
($hash, 101, (100 * $page), undef,
5593 $greptype, '--regexp-ignore-case',
5594 $search_use_regexp ?
'--extended-regexp' : '--fixed-strings');
5596 my $paging_nav = '';
5599 $cgi->a({-href
=> href
(action
=>"search", hash
=>$hash,
5600 searchtext
=>$searchtext,
5601 searchtype
=>$searchtype)},
5603 $paging_nav .= " ⋅ " .
5604 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page-1),
5605 -accesskey
=> "p", -title
=> "Alt-p"}, "prev");
5607 $paging_nav .= "first";
5608 $paging_nav .= " ⋅ prev";
5611 if ($#commitlist >= 100) {
5613 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5614 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5615 $paging_nav .= " ⋅ $next_link";
5617 $paging_nav .= " ⋅ next";
5620 if ($#commitlist >= 100) {
5623 git_print_page_nav
('','', $hash,$co{'tree'},$hash, $paging_nav);
5624 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5625 git_search_grep_body
(\
@commitlist, 0, 99, $next_link);
5628 if ($searchtype eq 'pickaxe') {
5629 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5630 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5632 print "<table class=\"pickaxe search\">\n";
5635 open my $fd, '-|', git_cmd
(), '--no-pager', 'log', @diff_opts,
5636 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
5637 ($search_use_regexp ?
'--pickaxe-regex' : ());
5640 while (my $line = <$fd>) {
5644 my %set = parse_difftree_raw_line
($line);
5645 if (defined $set{'commit'}) {
5646 # finish previous commit
5649 "<td class=\"link\">" .
5650 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5652 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5658 print "<tr class=\"dark\">\n";
5660 print "<tr class=\"light\">\n";
5663 %co = parse_commit
($set{'commit'});
5664 my $author = chop_and_escape_str
($co{'author_name'}, 15, 5);
5665 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
5666 "<td><i>$author</i></td>\n" .
5668 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'}),
5669 -class => "list subject"},
5670 chop_and_escape_str
($co{'title'}, 50) . "<br/>");
5671 } elsif (defined $set{'to_id'}) {
5672 next if ($set{'to_id'} =~ m/^0{40}$/);
5674 print $cgi->a({-href
=> href
(action
=>"blob", hash_base
=>$co{'id'},
5675 hash
=>$set{'to_id'}, file_name
=>$set{'to_file'}),
5677 "<span class=\"match\">" . esc_path
($set{'file'}) . "</span>") .
5683 # finish last commit (warning: repetition!)
5686 "<td class=\"link\">" .
5687 $cgi->a({-href
=> href
(action
=>"commit", hash
=>$co{'id'})}, "commit") .
5689 $cgi->a({-href
=> href
(action
=>"tree", hash
=>$co{'tree'}, hash_base
=>$co{'id'})}, "tree");
5697 if ($searchtype eq 'grep') {
5698 git_print_page_nav
('','', $hash,$co{'tree'},$hash);
5699 git_print_header_div
('commit', esc_html
($co{'title'}), $hash);
5701 print "<table class=\"grep_search\">\n";
5705 open my $fd, "-|", git_cmd
(), 'grep', '-n',
5706 $search_use_regexp ?
('-E', '-i') : '-F',
5707 $searchtext, $co{'tree'};
5709 while (my $line = <$fd>) {
5711 my ($file, $lno, $ltext, $binary);
5712 last if ($matches++ > 1000);
5713 if ($line =~ /^Binary file (.+) matches$/) {
5717 (undef, $file, $lno, $ltext) = split(/:/, $line, 4);
5719 if ($file ne $lastfile) {
5720 $lastfile and print "</td></tr>\n";
5722 print "<tr class=\"dark\">\n";
5724 print "<tr class=\"light\">\n";
5726 print "<td class=\"list\">".
5727 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5728 file_name
=>"$file"),
5729 -class => "list"}, esc_path
($file));
5730 print "</td><td>\n";
5734 print "<div class=\"binary\">Binary file</div>\n";
5736 $ltext = untabify
($ltext);
5737 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
5738 $ltext = esc_html
($1, -nbsp
=>1);
5739 $ltext .= '<span class="match">';
5740 $ltext .= esc_html
($2, -nbsp
=>1);
5741 $ltext .= '</span>';
5742 $ltext .= esc_html
($3, -nbsp
=>1);
5744 $ltext = esc_html
($ltext, -nbsp
=>1);
5746 print "<div class=\"pre\">" .
5747 $cgi->a({-href
=> href
(action
=>"blob", hash
=>$co{'hash'},
5748 file_name
=>"$file").'#l'.$lno,
5749 -class => "linenr"}, sprintf('%4i', $lno))
5750 . ' ' . $ltext . "</div>\n";
5754 print "</td></tr>\n";
5755 if ($matches > 1000) {
5756 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
5759 print "<div class=\"diff nodifferences\">No matches found</div>\n";
5768 sub git_search_help
{
5770 git_print_page_nav
('','', $hash,$hash,$hash);
5772 <p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
5773 regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
5774 the pattern entered is recognized as the POSIX extended
5775 <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
5778 <dt><b>commit</b></dt>
5779 <dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
5781 my ($have_grep) = gitweb_check_feature
('grep');
5784 <dt><b>grep</b></dt>
5785 <dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
5786 a different one) are searched for the given pattern. On large trees, this search can take
5787 a while and put some strain on the server, so please use it with some consideration. Note that
5788 due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
5789 case-sensitive.</dd>
5793 <dt><b>author</b></dt>
5794 <dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
5795 <dt><b>committer</b></dt>
5796 <dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
5798 my ($have_pickaxe) = gitweb_check_feature
('pickaxe');
5799 if ($have_pickaxe) {
5801 <dt><b>pickaxe</b></dt>
5802 <dd>All commits that caused the string to appear or disappear from any file (changes that
5803 added, removed or "modified" the string) will be listed. This search can take a while and
5804 takes a lot of strain on the server, so please use it wisely. Note that since you may be
5805 interested even in changes just changing the case as well, this search is case sensitive.</dd>
5813 my $head = git_get_head_hash
($project);
5814 if (!defined $hash) {
5817 if (!defined $page) {
5820 my $refs = git_get_references
();
5822 my $commit_hash = $hash;
5823 if (defined $hash_parent) {
5824 $commit_hash = "$hash_parent..$hash";
5826 my @commitlist = parse_commits
($commit_hash, 101, (100 * $page));
5828 my $paging_nav = format_paging_nav
('shortlog', $hash, $head, $page, $#commitlist >= 100);
5830 if ($#commitlist >= 100) {
5832 $cgi->a({-href
=> href
(-replay
=>1, page
=>$page+1),
5833 -accesskey
=> "n", -title
=> "Alt-n"}, "next");
5837 git_print_page_nav
('shortlog','', $hash,$hash,$hash, $paging_nav);
5838 git_print_header_div
('summary', $project);
5840 git_shortlog_body
(\
@commitlist, 0, 99, $refs, $next_link);
5845 ## ......................................................................
5846 ## feeds (RSS, Atom; OPML)
5849 my $format = shift || 'atom';
5850 my ($have_blame) = gitweb_check_feature
('blame');
5852 # Atom: http://www.atomenabled.org/developers/syndication/
5853 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
5854 if ($format ne 'rss' && $format ne 'atom') {
5855 die_error
(400, "Unknown web feed format");
5858 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
5859 my $head = $hash || 'HEAD';
5860 my @commitlist = parse_commits
($head, 150, 0, $file_name);
5864 my $content_type = "application/$format+xml";
5865 if (defined $cgi->http('HTTP_ACCEPT') &&
5866 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
5867 # browser (feed reader) prefers text/xml
5868 $content_type = 'text/xml';
5870 if (defined($commitlist[0])) {
5871 %latest_commit = %{$commitlist[0]};
5872 %latest_date = parse_date
($latest_commit{'author_epoch'});
5874 -type
=> $content_type,
5875 -charset
=> 'utf-8',
5876 -last_modified
=> $latest_date{'rfc2822'});
5879 -type
=> $content_type,
5880 -charset
=> 'utf-8');
5883 # Optimization: skip generating the body if client asks only
5884 # for Last-Modified date.
5885 return if ($cgi->request_method() eq 'HEAD');
5888 my $title = "$site_name - $project/$action";
5889 my $feed_type = 'log';
5890 if (defined $hash) {
5891 $title .= " - '$hash'";
5892 $feed_type = 'branch log';
5893 if (defined $file_name) {
5894 $title .= " :: $file_name";
5895 $feed_type = 'history';
5897 } elsif (defined $file_name) {
5898 $title .= " - $file_name";
5899 $feed_type = 'history';
5901 $title .= " $feed_type";
5902 my $descr = git_get_project_description
($project);
5903 if (defined $descr) {
5904 $descr = esc_html
($descr);
5906 $descr = "$project " .
5907 ($format eq 'rss' ?
'RSS' : 'Atom') .
5910 my $owner = git_get_project_owner
($project);
5911 $owner = esc_html
($owner);
5915 if (defined $file_name) {
5916 $alt_url = href
(-full
=>1, action
=>"history", hash
=>$hash, file_name
=>$file_name);
5917 } elsif (defined $hash) {
5918 $alt_url = href
(-full
=>1, action
=>"log", hash
=>$hash);
5920 $alt_url = href
(-full
=>1, action
=>"summary");
5922 print qq!<?xml version
="1.0" encoding
="utf-8"?
>\n!;
5923 if ($format eq 'rss') {
5925 <rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
5928 print "<title>$title</title>\n" .
5929 "<link>$alt_url</link>\n" .
5930 "<description>$descr</description>\n" .
5931 "<language>en</language>\n";
5932 } elsif ($format eq 'atom') {
5934 <feed xmlns="http://www.w3.org/2005/Atom">
5936 print "<title>$title</title>\n" .
5937 "<subtitle>$descr</subtitle>\n" .
5938 '<link rel="alternate" type="text/html" href="' .
5939 $alt_url . '" />' . "\n" .
5940 '<link rel="self" type="' . $content_type . '" href="' .
5941 $cgi->self_url() . '" />' . "\n" .
5942 "<id>" . href
(-full
=>1) . "</id>\n" .
5943 # use project owner for feed author
5944 "<author><name>$owner</name></author>\n";
5945 if (defined $favicon) {
5946 print "<icon>" . esc_url
($favicon) . "</icon>\n";
5948 if (defined $logo_url) {
5949 # not twice as wide as tall: 72 x 27 pixels
5950 print "<logo>" . esc_url
($logo) . "</logo>\n";
5952 if (! %latest_date) {
5953 # dummy date to keep the feed valid until commits trickle in:
5954 print "<updated>1970-01-01T00:00:00Z</updated>\n";
5956 print "<updated>$latest_date{'iso-8601'}</updated>\n";
5961 for (my $i = 0; $i <= $#commitlist; $i++) {
5962 my %co = %{$commitlist[$i]};
5963 my $commit = $co{'id'};
5964 # we read 150, we always show 30 and the ones more recent than 48 hours
5965 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
5968 my %cd = parse_date
($co{'author_epoch'});
5970 # get list of changed files
5971 open my $fd, "-|", git_cmd
(), "diff-tree", '-r', @diff_opts,
5972 $co{'parent'} || "--root",
5973 $co{'id'}, "--", (defined $file_name ?
$file_name : ())
5975 my @difftree = map { chomp; $_ } <$fd>;
5979 # print element (entry, item)
5980 my $co_url = href
(-full
=>1, action
=>"commitdiff", hash
=>$commit);
5981 if ($format eq 'rss') {
5983 "<title>" . esc_html
($co{'title'}) . "</title>\n" .
5984 "<author>" . esc_html
($co{'author'}) . "</author>\n" .
5985 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
5986 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
5987 "<link>$co_url</link>\n" .
5988 "<description>" . esc_html
($co{'title'}) . "</description>\n" .
5989 "<content:encoded>" .
5991 } elsif ($format eq 'atom') {
5993 "<title type=\"html\">" . esc_html
($co{'title'}) . "</title>\n" .
5994 "<updated>$cd{'iso-8601'}</updated>\n" .
5996 " <name>" . esc_html
($co{'author_name'}) . "</name>\n";
5997 if ($co{'author_email'}) {
5998 print " <email>" . esc_html
($co{'author_email'}) . "</email>\n";
6000 print "</author>\n" .
6001 # use committer for contributor
6003 " <name>" . esc_html
($co{'committer_name'}) . "</name>\n";
6004 if ($co{'committer_email'}) {
6005 print " <email>" . esc_html
($co{'committer_email'}) . "</email>\n";
6007 print "</contributor>\n" .
6008 "<published>$cd{'iso-8601'}</published>\n" .
6009 "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
6010 "<id>$co_url</id>\n" .
6011 "<content type=\"xhtml\" xml:base=\"" . esc_url
($my_url) . "\">\n" .
6012 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
6014 my $comment = $co{'comment'};
6016 foreach my $line (@
$comment) {
6017 $line = esc_html
($line);
6020 print "</pre><ul>\n";
6021 foreach my $difftree_line (@difftree) {
6022 my %difftree = parse_difftree_raw_line
($difftree_line);
6023 next if !$difftree{'from_id'};
6025 my $file = $difftree{'file'} || $difftree{'to_file'};
6029 $cgi->a({-href
=> href
(-full
=>1, action
=>"blobdiff",
6030 hash
=>$difftree{'to_id'}, hash_parent
=>$difftree{'from_id'},
6031 hash_base
=>$co{'id'}, hash_parent_base
=>$co{'parent'},
6032 file_name
=>$file, file_parent
=>$difftree{'from_file'}),
6033 -title
=> "diff"}, 'D');
6035 print $cgi->a({-href
=> href
(-full
=>1, action
=>"blame",
6036 file_name
=>$file, hash_base
=>$commit),
6037 -title
=> "blame"}, 'B');
6039 # if this is not a feed of a file history
6040 if (!defined $file_name || $file_name ne $file) {
6041 print $cgi->a({-href
=> href
(-full
=>1, action
=>"history",
6042 file_name
=>$file, hash
=>$commit),
6043 -title
=> "history"}, 'H');
6045 $file = esc_path
($file);
6049 if ($format eq 'rss') {
6050 print "</ul>]]>\n" .
6051 "</content:encoded>\n" .
6053 } elsif ($format eq 'atom') {
6054 print "</ul>\n</div>\n" .
6061 if ($format eq 'rss') {
6062 print "</channel>\n</rss>\n";
6063 } elsif ($format eq 'atom') {
6077 my @list = git_get_projects_list
();
6079 print $cgi->header(-type
=> 'text/xml', -charset
=> 'utf-8');
6081 <?xml version="1.0" encoding="utf-8"?>
6082 <opml version="1.0">
6084 <title>$site_name OPML Export</title>
6087 <outline text="git RSS feeds">
6090 foreach my $pr (@list) {
6092 my $head = git_get_head_hash
($proj{'path'});
6093 if (!defined $head) {
6096 $git_dir = "$projectroot/$proj{'path'}";
6097 my %co = parse_commit
($head);
6102 my $path = esc_html
(chop_str
($proj{'path'}, 25, 5));
6103 my $rss = "$my_url?p=$proj{'path'};a=rss";
6104 my $html = "$my_url?p=$proj{'path'};a=summary";
6105 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";