Google Git
Sign in
googlers / jrn / git / 523506df51e2e13c8c354dff1eea3378bac8dec8 / . / gitweb / gitweb.perl
blob: e09e024a09b00f420a4ca63bb5f12546ae5bf27b [file] [log] [blame]
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]1#!/usr/bin/perl
2
Kay Sieversc994d622005-08-07 20:27:18 +0200[diff] [blame]3# gitweb - simple web interface to track changes in git repositories
Kay Sievers22fafb92005-08-07 19:56:59 +0200[diff] [blame]4#
Kay Sievers00cd0792006-05-22 14:30:47 +0200[diff] [blame]5# (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
6# (C) 2005, Christian Gierke
Kay Sievers823d5dc2005-08-07 19:57:58 +0200[diff] [blame]7#
Kay Sieversd8f1c5c2005-10-04 01:12:47 +0200[diff] [blame]8# This program is licensed under the GPLv2
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]9
Ævar Arnfjörð Bjarmasond48b2842010-09-24 20:00:52 +0000[diff] [blame]10use 5.008;
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]11use strict;
12use warnings;
Guillaume Castagnino411ddf92017-10-19 09:32:46 +0200[diff] [blame]13# handle ACL in file access tests
14use filetest 'access';
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]15use CGI qw(:standard :escapeHTML -nosticky);
Kay Sievers7403d502005-08-07 20:23:49 +0200[diff] [blame]16use CGI::Util qw(unescape);
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]17use CGI::Carp qw(fatalsToBrowser set_message);
Kay Sievers40c13812005-11-19 17:41:29 +0100[diff] [blame]18use Encode;
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]19use Fcntl ':mode';
Junio C Hamano7a13b992006-07-31 19:18:34 -0700[diff] [blame]20use File::Find qw();
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]21use File::Basename qw(basename);
Jakub Narebski3962f1d72010-11-09 19:27:54 +0100[diff] [blame]22use Time::HiRes qw(gettimeofday tv_interval);
Ævar Arnfjörð Bjarmason7d5b30e2018-03-03 15:38:08 +0000[diff] [blame]23use Digest::MD5 qw(md5_hex);
24
Kay Sievers10bb9032005-11-23 04:26:40 +0100[diff] [blame]25binmode STDOUT, ':utf8';
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]26
Jeff King13dbf462014-11-18 12:10:22 -0500[diff] [blame]27if (!defined($CGI::VERSION) || $CGI::VERSION < 4.08) {
28 eval 'sub CGI::multi_param { CGI::param(@_) }'
29}
30
Jakub Narebski3962f1d72010-11-09 19:27:54 +0100[diff] [blame]31our $t0 = [ gettimeofday() ];
Jakub Narebskiaa7dd052009-09-01 13:39:16 +0200[diff] [blame]32our $number_of_git_cmds = 0;
33
Jakub Narebskib1f5f642006-12-28 00:00:52 +0100[diff] [blame]34BEGIN {
Jakub Narebski3be8e722007-04-01 22:22:21 +0200[diff] [blame]35 CGI->compile() if $ENV{'MOD_PERL'};
Jakub Narebskib1f5f642006-12-28 00:00:52 +0100[diff] [blame]36}
37
Junio C Hamano06c084d2006-08-02 13:50:20 -0700[diff] [blame]38our $version = "++GIT_VERSION++";
Kay Sievers44ad2972005-08-07 19:59:24 +0200[diff] [blame]39
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]40our ($my_url, $my_uri, $base_url, $path_info, $home_link);
41sub evaluate_uri {
42 our $cgi;
Giuseppe Bilotta81d3fe92009-02-15 10:18:36 +0100[diff] [blame]43
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]44 our $my_url = $cgi->url();
45 our $my_uri = $cgi->url(-absolute => 1);
46
47 # Base URL for relative URLs in gitweb ($logo, $favicon, ...),
48 # needed and used only for URLs with nonempty PATH_INFO
49 our $base_url = $my_url;
50
51 # When the script is used as DirectoryIndex, the URL does not contain the name
52 # of the script file itself, and $cgi->url() fails to strip PATH_INFO, so we
53 # have to do it ourselves. We make $path_info global because it's also used
54 # later on.
55 #
56 # Another issue with the script being the DirectoryIndex is that the resulting
57 # $my_url data is not the full script URL: this is good, because we want
58 # generated links to keep implying the script name if it wasn't explicitly
59 # indicated in the URL we're handling, but it means that $my_url cannot be used
60 # as base URL.
61 # Therefore, if we needed to strip PATH_INFO, then we know that we have
62 # to build the base URL ourselves:
Jakub Narebski84d9e2d2012-02-03 13:44:54 +0100[diff] [blame]63 our $path_info = decode_utf8($ENV{"PATH_INFO"});
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]64 if ($path_info) {
Jay Soffiancacfc092012-08-08 22:29:26 -0400[diff] [blame]65 # $path_info has already been URL-decoded by the web server, but
66 # $my_url and $my_uri have not. URL-decode them so we can properly
67 # strip $path_info.
68 $my_url = unescape($my_url);
69 $my_uri = unescape($my_uri);
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]70 if ($my_url =~ s,\Q$path_info\E$,, &&
71 $my_uri =~ s,\Q$path_info\E$,, &&
72 defined $ENV{'SCRIPT_NAME'}) {
73 $base_url = $cgi->url(-base => 1) . $ENV{'SCRIPT_NAME'};
74 }
Giuseppe Bilotta81d3fe92009-02-15 10:18:36 +0100[diff] [blame]75 }
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]76
77 # target of the home link on top of all pages
78 our $home_link = $my_uri || "/";
Giuseppe Bilottab65910f2008-09-29 15:07:42 +0200[diff] [blame]79}
80
Alp Tokere130dda2006-07-12 23:55:10 +0100[diff] [blame]81# core git executable to use
82# this can just be "git" if your webserver has a sensible PATH
Junio C Hamano06c084d2006-08-02 13:50:20 -0700[diff] [blame]83our $GIT = "++GIT_BINDIR++/git";
Jakub Narebski3f7f27102006-06-21 09:48:04 +0200[diff] [blame]84
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]85# absolute fs-path which will be prepended to the project path
Dennis Stosberg4a87b432006-06-21 15:07:08 +0200[diff] [blame]86#our $projectroot = "/pub/scm";
Junio C Hamano06c084d2006-08-02 13:50:20 -0700[diff] [blame]87our $projectroot = "++GITWEB_PROJECTROOT++";
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]88
Luke Luca5e9492007-10-16 20:45:25 -0700[diff] [blame]89# fs traversing limit for getting project list
90# the number is relative to the projectroot
91our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";
92
Yasushi SHOJI2de21fa2006-08-15 07:50:49 +0900[diff] [blame]93# string of the home link on top of all pages
94our $home_link_str = "++GITWEB_HOME_LINK_STR++";
95
Tony Finchad9c2e22013-07-04 18:02:12 +0100[diff] [blame]96# extra breadcrumbs preceding the home link
97our @extra_breadcrumbs = ();
98
Alp Toker49da1da2006-07-11 21:10:26 +0100[diff] [blame]99# name of your site or organization to appear in page titles
100# replace this with something more descriptive for clearer bookmarks
Petr Baudis8be28902006-10-24 05:18:39 +0200[diff] [blame]101our $site_name = "++GITWEB_SITENAME++"
102 || ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
Alp Toker49da1da2006-07-11 21:10:26 +0100[diff] [blame]103
Lénaïc Huardc1355b72011-10-21 09:09:29 +0200[diff] [blame]104# html snippet to include in the <head> section of each page
105our $site_html_head_string = "++GITWEB_SITE_HTML_HEAD_STRING++";
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]106# filename of html text to include at top of each page
107our $site_header = "++GITWEB_SITE_HEADER++";
Kay Sievers8ab1da22005-08-07 20:22:53 +0200[diff] [blame]108# html text to include at home page
Junio C Hamano06c084d2006-08-02 13:50:20 -0700[diff] [blame]109our $home_text = "++GITWEB_HOMETEXT++";
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]110# filename of html text to include at bottom of each page
111our $site_footer = "++GITWEB_SITE_FOOTER++";
Kay Sievers8ab1da22005-08-07 20:22:53 +0200[diff] [blame]112
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]113# URI of stylesheets
114our @stylesheets = ("++GITWEB_CSS++");
Petr Baudis887a6122006-10-26 14:41:25 +0200[diff] [blame]115# URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
116our $stylesheet = undef;
Jakub Narebski9a7a62f2006-10-06 12:31:05 +0200[diff] [blame]117# URI of GIT logo (72x27 size)
Junio C Hamano06c084d2006-08-02 13:50:20 -0700[diff] [blame]118our $logo = "++GITWEB_LOGO++";
Jakub Narebski0b5deba2006-09-04 20:32:13 +0200[diff] [blame]119# URI of GIT favicon, assumed to be image/png type
120our $favicon = "++GITWEB_FAVICON++";
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]121# URI of gitweb.js (JavaScript code for gitweb)
122our $javascript = "++GITWEB_JS++";
Jakub Narebskiaedd9422006-06-17 11:23:56 +0200[diff] [blame]123
Jakub Narebski9a7a62f2006-10-06 12:31:05 +0200[diff] [blame]124# URI and label (title) of GIT logo link
125#our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
126#our $logo_label = "git documentation";
Wincent Colaiuta69fb8282009-07-12 14:31:28 +0200[diff] [blame]127our $logo_url = "http://git-scm.com/";
Jakub Narebski9a7a62f2006-10-06 12:31:05 +0200[diff] [blame]128our $logo_label = "git homepage";
Junio C Hamano51a7c662006-09-23 12:36:01 -0700[diff] [blame]129
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]130# source of projects list
Junio C Hamano06c084d2006-08-02 13:50:20 -0700[diff] [blame]131our $projects_list = "++GITWEB_LIST++";
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]132
Michael Hendricks55feb122007-07-04 18:36:48 -0600[diff] [blame]133# the width (in characters) of the projects list "Description" column
134our $projects_list_description_width = 25;
135
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]136# group projects by category on the projects list
137# (enabled if this variable evaluates to true)
138our $projects_list_group_categories = 0;
139
140# default category if none specified
141# (leave the empty string for no category)
142our $project_list_default_category = "";
143
Frank Lichtenheldb06dcf82007-04-06 23:58:24 +0200[diff] [blame]144# default order of projects list
145# valid values are none, project, descr, owner, and age
146our $default_projects_order = "project";
147
Matthias Lederhofer32f4aac2006-09-17 00:31:01 +0200[diff] [blame]148# show repository only if this file exists
149# (only effective if this variable evaluates to true)
150our $export_ok = "++GITWEB_EXPORT_OK++";
151
Kacper Kornet5710be42012-04-24 19:39:15 +0200[diff] [blame]152# don't generate age column on the projects list page
153our $omit_age_column = 0;
154
Kacper Kornet0ebe7822012-04-26 18:45:44 +0200[diff] [blame]155# don't generate information about owners of repositories
156our $omit_owner=0;
157
Alexander Gavrilovdd7f5f12008-11-06 01:36:23 +0300[diff] [blame]158# show repository only if this subroutine returns true
159# when given the path to the project, for example:
160# sub { return -e "$_[0]/git-daemon-export-ok"; }
161our $export_auth_hook = undef;
162
Matthias Lederhofer32f4aac2006-09-17 00:31:01 +0200[diff] [blame]163# only allow viewing of repositories also shown on the overview page
164our $strict_export = "++GITWEB_STRICT_EXPORT++";
165
Jakub Narebski19a87212006-08-15 23:03:17 +0200[diff] [blame]166# list of git base URLs used for URL to where fetch project from,
167# i.e. full URL is "$git_base_url/$project"
Jakub Narebskid6b7e0b2006-10-26 12:26:44 +0200[diff] [blame]168our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
Jakub Narebski19a87212006-08-15 23:03:17 +0200[diff] [blame]169
Jakub Narebskif5aa79d2006-06-17 13:32:15 +0200[diff] [blame]170# default blob_plain mimetype and default charset for text/plain blob
Dennis Stosberg4a87b432006-06-21 15:07:08 +0200[diff] [blame]171our $default_blob_plain_mimetype = 'text/plain';
172our $default_text_plain_charset = undef;
Jakub Narebskif5aa79d2006-06-17 13:32:15 +0200[diff] [blame]173
Petr Baudis2d007372006-06-18 00:01:06 +0200[diff] [blame]174# file to use for guessing MIME types before trying /etc/mime.types
175# (relative to the current git repository)
Dennis Stosberg4a87b432006-06-21 15:07:08 +0200[diff] [blame]176our $mimetypes_file = undef;
Petr Baudis2d007372006-06-18 00:01:06 +0200[diff] [blame]177
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]178# assume this charset if line contains non-UTF-8 characters;
179# it should be valid encoding (see Encoding::Supported(3pm) for list),
180# for which encoding all byte sequences are valid, for example
181# 'iso-8859-1' aka 'latin1' (it is decoded without checking, so it
182# could be even 'utf-8' for the old behavior)
183our $fallback_encoding = 'latin1';
184
Jakub Narebski69a9b412007-07-20 02:15:09 +0200[diff] [blame]185# rename detection options for git-diff and git-diff-tree
186# - default is '-M', with the cost proportional to
187# (number of removed files) * (number of new files).
188# - more costly is '-C' (which implies '-M'), with the cost proportional to
189# (number of changed files + number of removed files) * (number of new files)
190# - even more costly is '-C', '--find-copies-harder' with cost
191# (number of files in the original tree) * (number of new files)
192# - one might want to include '-B' option, e.g. '-B', '-M'
193our @diff_opts = ('-M'); # taken from git_commit
194
Matt McCutchen7e1100e2009-02-07 19:00:09 -0500[diff] [blame]195# Disables features that would allow repository owners to inject script into
196# the gitweb domain.
197our $prevent_xss = 0;
198
Christopher Wilson7ce896b2010-09-21 00:25:19 -0700[diff] [blame]199# Path to the highlight executable to use (must be the one from
200# http://www.andre-simon.de due to assumptions about parameters and output).
201# Useful if highlight is not installed on your webserver's PATH.
202# [Default: highlight]
203our $highlight_bin = "++HIGHLIGHT_BIN++";
204
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]205# information about snapshot formats that gitweb is capable of serving
206our %known_snapshot_formats = (
207 # name => {
208 # 'display' => display name,
209 # 'type' => mime type,
210 # 'suffix' => filename suffix,
211 # 'format' => --format for git-archive,
212 # 'compressor' => [compressor command and arguments]
Mark A Rada1bfd3632009-08-06 10:25:39 -0400[diff] [blame]213 # (array reference, optional)
214 # 'disabled' => boolean (optional)}
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]215 #
216 'tgz' => {
217 'display' => 'tar.gz',
218 'type' => 'application/x-gzip',
219 'suffix' => '.tar.gz',
220 'format' => 'tar',
Fraser Tweedale0c8c3852011-04-26 11:32:00 +1000[diff] [blame]221 'compressor' => ['gzip', '-n']},
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]222
223 'tbz2' => {
224 'display' => 'tar.bz2',
225 'type' => 'application/x-bzip2',
226 'suffix' => '.tar.bz2',
227 'format' => 'tar',
228 'compressor' => ['bzip2']},
229
Mark A Radacbdefb52009-08-06 10:28:25 -0400[diff] [blame]230 'txz' => {
231 'display' => 'tar.xz',
232 'type' => 'application/x-xz',
233 'suffix' => '.tar.xz',
234 'format' => 'tar',
235 'compressor' => ['xz'],
236 'disabled' => 1},
237
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]238 'zip' => {
239 'display' => 'zip',
240 'type' => 'application/x-zip',
241 'suffix' => '.zip',
242 'format' => 'zip'},
243);
244
245# Aliases so we understand old gitweb.snapshot values in repository
246# configuration.
247our %known_snapshot_format_aliases = (
248 'gzip' => 'tgz',
249 'bzip2' => 'tbz2',
Mark A Radacbdefb52009-08-06 10:28:25 -0400[diff] [blame]250 'xz' => 'txz',
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]251
252 # backward compatibility: legacy gitweb config support
253 'x-gzip' => undef, 'gz' => undef,
254 'x-bzip2' => undef, 'bz2' => undef,
255 'x-zip' => undef, '' => undef,
256);
257
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]258# Pixel sizes for icons and avatars. If the default font sizes or lineheights
259# are changed, it may be appropriate to change these values too via
260# $GITWEB_CONFIG.
261our %avatar_size = (
262 'default' => 16,
263 'double' => 32
264);
265
John 'Warthog9' Hawleyb62a1a92010-01-30 23:30:39 +0100[diff] [blame]266# Used to set the maximum load that we will still respond to gitweb queries.
267# If server load exceed this value then return "503 server busy" error.
268# If gitweb cannot determined server load, it is taken to be 0.
269# Leave it undefined (or set to 'undef') to turn off load checking.
270our $maxload = 300;
271
Alejandro R. Sedeño61bf1262010-07-28 14:40:53 -0400[diff] [blame]272# configuration for 'highlight' (http://www.andre-simon.de/)
273# match by basename
274our %highlight_basename = (
275 #'Program' => 'py',
276 #'Library' => 'py',
277 'SConstruct' => 'py', # SCons equivalent of Makefile
278 'Makefile' => 'make',
279);
280# match by extension
281our %highlight_ext = (
282 # main extensions, defining name of syntax;
283 # see files in /usr/share/highlight/langDefs/ directory
Richard Hubbell048b3992012-11-04 09:45:55 -0800[diff] [blame]284 (map { $_ => $_ } qw(py rb java css js tex bib xml awk bat ini spec tcl sql)),
Alejandro R. Sedeño61bf1262010-07-28 14:40:53 -0400[diff] [blame]285 # alternate extensions, see /etc/highlight/filetypes.conf
Richard Hubbell048b3992012-11-04 09:45:55 -0800[diff] [blame]286 (map { $_ => 'c' } qw(c h)),
287 (map { $_ => 'sh' } qw(sh bash zsh ksh)),
288 (map { $_ => 'cpp' } qw(cpp cxx c++ cc)),
289 (map { $_ => 'php' } qw(php php3 php4 php5 phps)),
290 (map { $_ => 'pl' } qw(pl perl pm)), # perhaps also 'cgi'
291 (map { $_ => 'make'} qw(make mak mk)),
292 (map { $_ => 'xml' } qw(xml xhtml html htm)),
Alejandro R. Sedeño61bf1262010-07-28 14:40:53 -0400[diff] [blame]293);
294
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]295# You define site-wide feature defaults here; override them with
296# $GITWEB_CONFIG as necessary.
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]297our %feature = (
Jakub Narebski17848fc2006-08-26 19:14:22 +0200[diff] [blame]298 # feature => {
299 # 'sub' => feature-sub (subroutine),
300 # 'override' => allow-override (boolean),
301 # 'default' => [ default options...] (array reference)}
302 #
Jakub Narebskib4b20b22007-05-15 01:55:44 +0200[diff] [blame]303 # if feature is overridable (it means that allow-override has true value),
Jakub Narebski17848fc2006-08-26 19:14:22 +0200[diff] [blame]304 # then feature-sub will be called with default options as parameters;
305 # return value of feature-sub indicates if to enable specified feature
306 #
Jakub Narebskib4b20b22007-05-15 01:55:44 +0200[diff] [blame]307 # if there is no 'sub' key (no feature-sub), then feature cannot be
Ralf Wildenhues22e5e582010-08-22 13:12:12 +0200[diff] [blame]308 # overridden
Jakub Narebskib4b20b22007-05-15 01:55:44 +0200[diff] [blame]309 #
Giuseppe Bilottaff3c0ff2008-12-02 14:57:28 -0800[diff] [blame]310 # use gitweb_get_feature(<feature>) to retrieve the <feature> value
311 # (an array) or gitweb_check_feature(<feature>) to check if <feature>
312 # is enabled
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]313
Petr Baudis45a3b122006-10-07 15:17:47 +0200[diff] [blame]314 # Enable the 'blame' blob view, showing the last commit that modified
315 # each line in the file. This can be very CPU-intensive.
316
317 # To enable system wide have in $GITWEB_CONFIG
318 # $feature{'blame'}{'default'} = [1];
319 # To have project specific config enable override in $GITWEB_CONFIG
320 # $feature{'blame'}{'override'} = 1;
321 # and in project config gitweb.blame = 0|1;
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]322 'blame' => {
Matt Kraaicdad8172008-12-15 22:16:19 -0800[diff] [blame]323 'sub' => sub { feature_bool('blame', @_) },
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]324 'override' => 0,
325 'default' => [0]},
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]326
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]327 # Enable the 'snapshot' link, providing a compressed archive of any
Petr Baudis45a3b122006-10-07 15:17:47 +0200[diff] [blame]328 # tree. This can potentially generate high traffic if you have large
329 # project.
330
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]331 # Value is a list of formats defined in %known_snapshot_formats that
332 # you wish to offer.
Petr Baudis45a3b122006-10-07 15:17:47 +0200[diff] [blame]333 # To disable system wide have in $GITWEB_CONFIG
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]334 # $feature{'snapshot'}{'default'} = [];
Petr Baudis45a3b122006-10-07 15:17:47 +0200[diff] [blame]335 # To have project specific config enable override in $GITWEB_CONFIG
Uwe Zeisbergerbbee1d92006-12-08 12:44:31 +0100[diff] [blame]336 # $feature{'snapshot'}{'override'} = 1;
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]337 # and in project config, a comma-separated list of formats or "none"
338 # to disable. Example: gitweb.snapshot = tbz2,zip;
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]339 'snapshot' => {
340 'sub' => \&feature_snapshot,
341 'override' => 0,
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]342 'default' => ['tgz']},
Jakub Narebski04f7a942006-09-11 00:29:27 +0200[diff] [blame]343
Robert Fitzsimons6be93512006-12-23 03:35:16 +0000[diff] [blame]344 # Enable text search, which will list the commits which match author,
345 # committer or commit text to a given string. Enabled by default.
Jakub Narebskib4b20b22007-05-15 01:55:44 +0200[diff] [blame]346 # Project specific override is not supported.
Jakub Narebskie0ca3642011-06-22 17:28:52 +0200[diff] [blame]347 #
348 # Note that this controls all search features, which means that if
349 # it is disabled, then 'grep' and 'pickaxe' search would also be
350 # disabled.
Robert Fitzsimons6be93512006-12-23 03:35:16 +0000[diff] [blame]351 'search' => {
352 'override' => 0,
353 'default' => [1]},
354
Petr Baudise7738552007-05-17 04:31:12 +0200[diff] [blame]355 # Enable grep search, which will list the files in currently selected
356 # tree containing the given string. Enabled by default. This can be
357 # potentially CPU-intensive, of course.
Jakub Narebskia598ded2011-06-21 08:41:16 +0200[diff] [blame]358 # Note that you need to have 'search' feature enabled too.
Petr Baudise7738552007-05-17 04:31:12 +0200[diff] [blame]359
360 # To enable system wide have in $GITWEB_CONFIG
361 # $feature{'grep'}{'default'} = [1];
362 # To have project specific config enable override in $GITWEB_CONFIG
363 # $feature{'grep'}{'override'} = 1;
364 # and in project config gitweb.grep = 0|1;
365 'grep' => {
Matt Kraaicdad8172008-12-15 22:16:19 -0800[diff] [blame]366 'sub' => sub { feature_bool('grep', @_) },
Petr Baudise7738552007-05-17 04:31:12 +0200[diff] [blame]367 'override' => 0,
368 'default' => [1]},
369
Petr Baudis45a3b122006-10-07 15:17:47 +0200[diff] [blame]370 # Enable the pickaxe search, which will list the commits that modified
371 # a given string in a file. This can be practical and quite faster
372 # alternative to 'blame', but still potentially CPU-intensive.
Jakub Narebskia598ded2011-06-21 08:41:16 +0200[diff] [blame]373 # Note that you need to have 'search' feature enabled too.
Petr Baudis45a3b122006-10-07 15:17:47 +0200[diff] [blame]374
375 # To enable system wide have in $GITWEB_CONFIG
376 # $feature{'pickaxe'}{'default'} = [1];
377 # To have project specific config enable override in $GITWEB_CONFIG
378 # $feature{'pickaxe'}{'override'} = 1;
379 # and in project config gitweb.pickaxe = 0|1;
Jakub Narebski04f7a942006-09-11 00:29:27 +0200[diff] [blame]380 'pickaxe' => {
Matt Kraaicdad8172008-12-15 22:16:19 -0800[diff] [blame]381 'sub' => sub { feature_bool('pickaxe', @_) },
Jakub Narebski04f7a942006-09-11 00:29:27 +0200[diff] [blame]382 'override' => 0,
383 'default' => [1]},
Martin Waitz9e756902006-10-01 23:57:48 +0200[diff] [blame]384
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]385 # Enable showing size of blobs in a 'tree' view, in a separate
386 # column, similar to what 'ls -l' does. This cost a bit of IO.
387
388 # To disable system wide have in $GITWEB_CONFIG
389 # $feature{'show-sizes'}{'default'} = [0];
390 # To have project specific config enable override in $GITWEB_CONFIG
391 # $feature{'show-sizes'}{'override'} = 1;
392 # and in project config gitweb.showsizes = 0|1;
393 'show-sizes' => {
394 'sub' => sub { feature_bool('showsizes', @_) },
395 'override' => 0,
396 'default' => [1]},
397
Petr Baudis45a3b122006-10-07 15:17:47 +0200[diff] [blame]398 # Make gitweb use an alternative format of the URLs which can be
399 # more readable and natural-looking: project name is embedded
400 # directly in the path and the query string contains other
401 # auxiliary information. All gitweb installations recognize
402 # URL in either format; this configures in which formats gitweb
403 # generates links.
404
405 # To enable system wide have in $GITWEB_CONFIG
406 # $feature{'pathinfo'}{'default'} = [1];
407 # Project specific override is not supported.
408
409 # Note that you will need to change the default location of CSS,
410 # favicon, logo and possibly other files to an absolute URL. Also,
411 # if gitweb.cgi serves as your indexfile, you will need to force
412 # $my_uri to contain the script name in your $GITWEB_CONFIG.
Martin Waitz9e756902006-10-01 23:57:48 +0200[diff] [blame]413 'pathinfo' => {
414 'override' => 0,
415 'default' => [0]},
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]416
417 # Make gitweb consider projects in project root subdirectories
418 # to be forks of existing projects. Given project $projname.git,
419 # projects matching $projname/*.git will not be shown in the main
420 # projects list, instead a '+' mark will be added to $projname
421 # there and a 'forks' view will be enabled for the project, listing
Frank Lichtenheldc2b8b132007-04-06 23:58:11 +0200[diff] [blame]422 # all the forks. If project list is taken from a file, forks have
423 # to be listed after the main project.
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]424
425 # To enable system wide have in $GITWEB_CONFIG
426 # $feature{'forks'}{'default'} = [1];
427 # Project specific override is not supported.
428 'forks' => {
429 'override' => 0,
430 'default' => [0]},
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]431
432 # Insert custom links to the action bar of all project pages.
433 # This enables you mainly to link to third-party scripts integrating
434 # into gitweb; e.g. git-browser for graphical history representation
435 # or custom web-based repository administration interface.
436
437 # The 'default' value consists of a list of triplets in the form
438 # (label, link, position) where position is the label after which
Jakub Narebski2b11e052008-10-12 00:02:32 +0200[diff] [blame]439 # to insert the link and link is a format string where %n expands
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]440 # to the project name, %f to the project path within the filesystem,
441 # %h to the current hash (h gitweb parameter) and %b to the current
Jakub Narebski2b11e052008-10-12 00:02:32 +0200[diff] [blame]442 # hash base (hb gitweb parameter); %% expands to %.
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]443
444 # To enable system wide have in $GITWEB_CONFIG e.g.
445 # $feature{'actions'}{'default'} = [('graphiclog',
446 # '/git-browser/by-commit.html?r=%n', 'summary')];
447 # Project specific override is not supported.
448 'actions' => {
449 'override' => 0,
450 'default' => []},
Shawn O. Pearce3e3d4ee2008-10-03 07:41:25 -0700[diff] [blame]451
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]452 # Allow gitweb scan project content tags of project repository,
453 # and display the popular Web 2.0-ish "tag cloud" near the projects
454 # list. Note that this is something COMPLETELY different from the
455 # normal Git tags.
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]456
457 # gitweb by itself can show existing tags, but it does not handle
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]458 # tagging itself; you need to do it externally, outside gitweb.
459 # The format is described in git_get_project_ctags() subroutine.
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]460 # You may want to install the HTML::TagCloud Perl module to get
461 # a pretty tag cloud instead of just a list of tags.
462
463 # To enable system wide have in $GITWEB_CONFIG
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]464 # $feature{'ctags'}{'default'} = [1];
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]465 # Project specific override is not supported.
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]466
467 # In the future whether ctags editing is enabled might depend
468 # on the value, but using 1 should always mean no editing of ctags.
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]469 'ctags' => {
470 'override' => 0,
471 'default' => [0]},
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]472
473 # The maximum number of patches in a patchset generated in patch
474 # view. Set this to 0 or undef to disable patch view, or to a
475 # negative number to remove any limit.
476
477 # To disable system wide have in $GITWEB_CONFIG
478 # $feature{'patches'}{'default'} = [0];
479 # To have project specific config enable override in $GITWEB_CONFIG
480 # $feature{'patches'}{'override'} = 1;
481 # and in project config gitweb.patches = 0|n;
482 # where n is the maximum number of patches allowed in a patchset.
483 'patches' => {
484 'sub' => \&feature_patches,
485 'override' => 0,
486 'default' => [16]},
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]487
488 # Avatar support. When this feature is enabled, views such as
489 # shortlog or commit will display an avatar associated with
490 # the email of the committer(s) and/or author(s).
491
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]492 # Currently available providers are gravatar and picon.
493 # If an unknown provider is specified, the feature is disabled.
494
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]495 # Picon currently relies on the indiana.edu database.
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]496
497 # To enable system wide have in $GITWEB_CONFIG
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]498 # $feature{'avatar'}{'default'} = ['<provider>'];
499 # where <provider> is either gravatar or picon.
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]500 # To have project specific config enable override in $GITWEB_CONFIG
501 # $feature{'avatar'}{'override'} = 1;
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]502 # and in project config gitweb.avatar = <provider>;
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]503 'avatar' => {
504 'sub' => \&feature_avatar,
505 'override' => 0,
506 'default' => ['']},
Jakub Narebskiaa7dd052009-09-01 13:39:16 +0200[diff] [blame]507
508 # Enable displaying how much time and how many git commands
509 # it took to generate and display page. Disabled by default.
510 # Project specific override is not supported.
511 'timed' => {
512 'override' => 0,
513 'default' => [0]},
Jakub Narebskie627e502009-11-26 21:12:15 +0100[diff] [blame]514
515 # Enable turning some links into links to actions which require
516 # JavaScript to run (like 'blame_incremental'). Not enabled by
517 # default. Project specific override is currently not supported.
518 'javascript-actions' => {
519 'override' => 0,
520 'default' => [0]},
Johannes Schindelinb331fe52010-04-27 21:34:44 +0200[diff] [blame]521
Jakub Narebski2e987f92011-04-28 21:04:11 +0200[diff] [blame]522 # Enable and configure ability to change common timezone for dates
523 # in gitweb output via JavaScript. Enabled by default.
524 # Project specific override is not supported.
525 'javascript-timezone' => {
526 'override' => 0,
527 'default' => [
528 'local', # default timezone: 'utc', 'local', or '(-|+)HHMM' format,
529 # or undef to turn off this feature
530 'gitweb_tz', # name of cookie where to store selected timezone
531 'datetime', # CSS class used to mark up dates for manipulation
532 ]},
533
Johannes Schindelinb331fe52010-04-27 21:34:44 +0200[diff] [blame]534 # Syntax highlighting support. This is based on Daniel Svensson's
535 # and Sham Chukoury's work in gitweb-xmms2.git.
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]536 # It requires the 'highlight' program present in $PATH,
537 # and therefore is disabled by default.
Johannes Schindelinb331fe52010-04-27 21:34:44 +0200[diff] [blame]538
539 # To enable system wide have in $GITWEB_CONFIG
540 # $feature{'highlight'}{'default'} = [1];
541
542 'highlight' => {
543 'sub' => sub { feature_bool('highlight', @_) },
544 'override' => 0,
545 'default' => [0]},
Giuseppe Bilotta60efa242010-11-11 13:26:09 +0100[diff] [blame]546
547 # Enable displaying of remote heads in the heads list
548
549 # To enable system wide have in $GITWEB_CONFIG
550 # $feature{'remote_heads'}{'default'} = [1];
551 # To have project specific config enable override in $GITWEB_CONFIG
552 # $feature{'remote_heads'}{'override'} = 1;
Phil Pennockaf507942012-11-05 18:50:47 -0500[diff] [blame]553 # and in project config gitweb.remoteheads = 0|1;
Giuseppe Bilotta60efa242010-11-11 13:26:09 +0100[diff] [blame]554 'remote_heads' => {
555 'sub' => sub { feature_bool('remote_heads', @_) },
556 'override' => 0,
557 'default' => [0]},
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]558
559 # Enable showing branches under other refs in addition to heads
560
561 # To set system wide extra branch refs have in $GITWEB_CONFIG
562 # $feature{'extra-branch-refs'}{'default'} = ['dirs', 'of', 'choice'];
563 # To have project specific config enable override in $GITWEB_CONFIG
564 # $feature{'extra-branch-refs'}{'override'} = 1;
565 # and in project config gitweb.extrabranchrefs = dirs of choice
566 # Every directory is separated with whitespace.
567
568 'extra-branch-refs' => {
569 'sub' => \&feature_extra_branch_refs,
570 'override' => 0,
571 'default' => []},
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]572
573 # Redact e-mail addresses.
574
575 # To enable system wide have in $GITWEB_CONFIG
576 # $feature{'email-privacy'}{'default'} = [1];
577 'email-privacy' => {
578 'sub' => sub { feature_bool('email-privacy', @_) },
579 'override' => 1,
580 'default' => [0]},
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]581);
582
Junio C Hamanoa7c5a282008-11-29 13:02:08 -0800[diff] [blame]583sub gitweb_get_feature {
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]584 my ($name) = @_;
Jakub Narebskidd1ad5f2006-09-26 01:56:17 +0200[diff] [blame]585 return unless exists $feature{$name};
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]586 my ($sub, $override, @defaults) = (
587 $feature{$name}{'sub'},
588 $feature{$name}{'override'},
589 @{$feature{$name}{'default'}});
Jakub Narebski9be36142010-03-01 22:51:34 +0100[diff] [blame]590 # project specific override is possible only if we have project
591 our $git_dir; # global variable, declared later
592 if (!$override || !defined $git_dir) {
593 return @defaults;
594 }
Martin Waitza9455912006-10-03 20:07:43 +0200[diff] [blame]595 if (!defined $sub) {
Nanako Shiraishi93197892009-08-28 12:18:49 +0900[diff] [blame]596 warn "feature $name is not overridable";
Martin Waitza9455912006-10-03 20:07:43 +0200[diff] [blame]597 return @defaults;
598 }
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]599 return $sub->(@defaults);
600}
601
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]602# A wrapper to check if a given feature is enabled.
603# With this, you can say
604#
605# my $bool_feat = gitweb_check_feature('bool_feat');
606# gitweb_check_feature('bool_feat') or somecode;
607#
608# instead of
609#
610# my ($bool_feat) = gitweb_get_feature('bool_feat');
611# (gitweb_get_feature('bool_feat'))[0] or somecode;
612#
613sub gitweb_check_feature {
614 return (gitweb_get_feature(@_))[0];
615}
616
617
Matt Kraaicdad8172008-12-15 22:16:19 -0800[diff] [blame]618sub feature_bool {
619 my $key = shift;
620 my ($val) = git_get_project_config($key, '--bool');
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]621
Marcel M. Carydf5d10a2009-02-18 14:09:41 +0100[diff] [blame]622 if (!defined $val) {
623 return ($_[0]);
624 } elsif ($val eq 'true') {
Matt Kraaicdad8172008-12-15 22:16:19 -0800[diff] [blame]625 return (1);
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]626 } elsif ($val eq 'false') {
Matt Kraaicdad8172008-12-15 22:16:19 -0800[diff] [blame]627 return (0);
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]628 }
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]629}
630
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]631sub feature_snapshot {
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]632 my (@fmts) = @_;
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]633
634 my ($val) = git_get_project_config('snapshot');
635
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]636 if ($val) {
637 @fmts = ($val eq 'none' ? () : split /\s*[,\s]\s*/, $val);
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]638 }
639
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]640 return @fmts;
Luben Tuikovde9272f2006-09-28 16:49:21 -0700[diff] [blame]641}
642
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]643sub feature_patches {
644 my @val = (git_get_project_config('patches', '--int'));
645
646 if (@val) {
647 return @val;
648 }
649
650 return ($_[0]);
651}
652
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]653sub feature_avatar {
654 my @val = (git_get_project_config('avatar'));
655
656 return @val ? @val : @_;
657}
658
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]659sub feature_extra_branch_refs {
660 my (@branch_refs) = @_;
661 my $values = git_get_project_config('extrabranchrefs');
662
663 if ($values) {
664 $values = config_to_multi ($values);
665 @branch_refs = ();
666 foreach my $value (@{$values}) {
667 push @branch_refs, split /\s+/, $value;
668 }
669 }
670
671 return @branch_refs;
672}
673
Junio C Hamano2172ce42006-10-03 02:30:47 -0700[diff] [blame]674# checking HEAD file with -e is fragile if the repository was
675# initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
676# and then pruned.
677sub check_head_link {
678 my ($dir) = @_;
679 my $headfile = "$dir/HEAD";
680 return ((-e $headfile) ||
681 (-l $headfile && readlink($headfile) =~ /^refs\/heads\//));
682}
683
684sub check_export_ok {
685 my ($dir) = @_;
686 return (check_head_link($dir) &&
Alexander Gavrilovdd7f5f12008-11-06 01:36:23 +0300[diff] [blame]687 (!$export_ok || -e "$dir/$export_ok") &&
688 (!$export_auth_hook || $export_auth_hook->($dir)));
Junio C Hamano2172ce42006-10-03 02:30:47 -0700[diff] [blame]689}
690
Jakub Narebskia7817852007-07-22 23:41:20 +0200[diff] [blame]691# process alternate names for backward compatibility
692# filter out unsupported (unknown) snapshot formats
693sub filter_snapshot_fmts {
694 my @fmts = @_;
695
696 @fmts = map {
697 exists $known_snapshot_format_aliases{$_} ?
698 $known_snapshot_format_aliases{$_} : $_} @fmts;
Jakub Narebski68cedb12009-05-10 02:40:37 +0200[diff] [blame]699 @fmts = grep {
Mark A Rada1bfd3632009-08-06 10:25:39 -0400[diff] [blame]700 exists $known_snapshot_formats{$_} &&
701 !$known_snapshot_formats{$_}{'disabled'}} @fmts;
Jakub Narebskia7817852007-07-22 23:41:20 +0200[diff] [blame]702}
703
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]704sub filter_and_validate_refs {
705 my @refs = @_;
706 my %unique_refs = ();
707
708 foreach my $ref (@refs) {
709 die_error(500, "Invalid ref '$ref' in 'extra-branch-refs' feature") unless (is_valid_ref_format($ref));
710 # 'heads' are added implicitly in get_branch_refs().
711 $unique_refs{$ref} = 1 if ($ref ne 'heads');
712 }
713 return sort keys %unique_refs;
714}
715
Jakub Narebskida4b2432010-11-25 19:43:59 +0100[diff] [blame]716# If it is set to code reference, it is code that it is to be run once per
717# request, allowing updating configurations that change with each request,
718# while running other code in config file only once.
719#
720# Otherwise, if it is false then gitweb would process config file only once;
721# if it is true then gitweb config would be run for each request.
722our $per_request_config = 1;
723
Jakub Narebskif612a712011-05-25 18:35:26 +0200[diff] [blame]724# read and parse gitweb config file given by its parameter.
725# returns true on success, false on recoverable error, allowing
726# to chain this subroutine, using first file that exists.
727# dies on errors during parsing config file, as it is unrecoverable.
728sub read_config_file {
729 my $filename = shift;
730 return unless defined $filename;
731 # die if there are errors parsing config file
732 if (-e $filename) {
733 do $filename;
734 die $@ if $@;
735 return 1;
736 }
737 return;
738}
739
Jakub Narebski131d6af2011-07-25 00:29:18 +0200[diff] [blame]740our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM, $GITWEB_CONFIG_COMMON);
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]741sub evaluate_gitweb_config {
742 our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
743 our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";
Jakub Narebski131d6af2011-07-25 00:29:18 +0200[diff] [blame]744 our $GITWEB_CONFIG_COMMON = $ENV{'GITWEB_CONFIG_COMMON'} || "++GITWEB_CONFIG_COMMON++";
Jakub Narebskif612a712011-05-25 18:35:26 +0200[diff] [blame]745
Stefano Lattarini41ccfdd2013-04-12 00:36:10 +0200[diff] [blame]746 # Protect against duplications of file names, to not read config twice.
Jakub Narebski131d6af2011-07-25 00:29:18 +0200[diff] [blame]747 # Only one of $GITWEB_CONFIG and $GITWEB_CONFIG_SYSTEM is used, so
748 # there possibility of duplication of filename there doesn't matter.
749 $GITWEB_CONFIG = "" if ($GITWEB_CONFIG eq $GITWEB_CONFIG_COMMON);
750 $GITWEB_CONFIG_SYSTEM = "" if ($GITWEB_CONFIG_SYSTEM eq $GITWEB_CONFIG_COMMON);
751
752 # Common system-wide settings for convenience.
Denis Ovsienko4e2c4c02020-01-04 18:39:26 +0100[diff] [blame]753 # Those settings can be overridden by GITWEB_CONFIG or GITWEB_CONFIG_SYSTEM.
Jakub Narebski131d6af2011-07-25 00:29:18 +0200[diff] [blame]754 read_config_file($GITWEB_CONFIG_COMMON);
755
756 # Use first config file that exists. This means use the per-instance
757 # GITWEB_CONFIG if exists, otherwise use GITWEB_SYSTEM_CONFIG.
758 read_config_file($GITWEB_CONFIG) and return;
Jakub Narebskif612a712011-05-25 18:35:26 +0200[diff] [blame]759 read_config_file($GITWEB_CONFIG_SYSTEM);
Gerrit Pape17a8b252008-03-26 18:11:19 +0000[diff] [blame]760}
Jeff Kingc8d138a2006-08-02 15:23:34 -0400[diff] [blame]761
John 'Warthog9' Hawleyb62a1a92010-01-30 23:30:39 +0100[diff] [blame]762# Get loadavg of system, to compare against $maxload.
763# Currently it requires '/proc/loadavg' present to get loadavg;
764# if it is not present it returns 0, which means no load checking.
765sub get_loadavg {
766 if( -e '/proc/loadavg' ){
767 open my $fd, '<', '/proc/loadavg'
768 or return 0;
769 my @load = split(/\s+/, scalar <$fd>);
770 close $fd;
771
772 # The first three columns measure CPU and IO utilization of the last one,
773 # five, and 10 minute periods. The fourth column shows the number of
774 # currently running processes and the total number of processes in the m/n
775 # format. The last column displays the last process ID used.
776 return $load[0] || 0;
777 }
778 # additional checks for load average should go here for things that don't export
779 # /proc/loadavg
780
781 return 0;
782}
783
Jeff Kingc8d138a2006-08-02 15:23:34 -0400[diff] [blame]784# version of the core git binary
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]785our $git_version;
786sub evaluate_git_version {
787 our $git_version = qx("$GIT" --version) =~ m/git version (.*)$/ ? $1 : "unknown";
788 $number_of_git_cmds++;
789}
Jeff Kingc8d138a2006-08-02 15:23:34 -0400[diff] [blame]790
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]791sub check_loadavg {
792 if (defined $maxload && get_loadavg() > $maxload) {
793 die_error(503, "The load average on the server is too high");
794 }
John 'Warthog9' Hawleyb62a1a92010-01-30 23:30:39 +0100[diff] [blame]795}
796
Jakub Narebski154b4d72006-08-05 12:55:20 +0200[diff] [blame]797# ======================================================================
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]798# input validation and dispatch
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]799
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]800# Various hash size-related values.
801my $sha1_len = 40;
802my $sha256_extra_len = 24;
803my $sha256_len = $sha1_len + $sha256_extra_len;
804
805# A regex matching $len hex characters. $len may be a range (e.g. 7,64).
806sub oid_nlen_regex {
807 my $len = shift;
808 my $hchr = qr/[0-9a-fA-F]/;
809 return qr/(?:(?:$hchr){$len})/;
810}
811
812# A regex matching two sets of $nlen hex characters, prefixed by the literal
813# string $prefix and with the literal string $infix between them.
814sub oid_nlen_prefix_infix_regex {
815 my $nlen = shift;
816 my $prefix = shift;
817 my $infix = shift;
818
819 my $rx = oid_nlen_regex($nlen);
820
821 return qr/^\Q$prefix\E$rx\Q$infix\E$rx$/;
822}
823
824# A regex matching a valid object ID.
825our $oid_regex;
826{
827 my $x = oid_nlen_regex($sha1_len);
828 my $y = oid_nlen_regex($sha256_extra_len);
829 $oid_regex = qr/(?:$x(?:$y)?)/;
830}
831
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]832# input parameters can be collected from a variety of sources (presently, CGI
833# and PATH_INFO), so we define an %input_params hash that collects them all
834# together during validation: this allows subsequent uses (e.g. href()) to be
835# agnostic of the parameter origin
Kay Sievers6191f8e2005-08-07 20:19:56 +0200[diff] [blame]836
Alexander Gavrilovdde80d92008-11-06 01:10:07 +0300[diff] [blame]837our %input_params = ();
Martin Waitz5c95fab2006-08-17 00:28:38 +0200[diff] [blame]838
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]839# input parameters are stored with the long parameter name as key. This will
840# also be used in the href subroutine to convert parameters to their CGI
841# equivalent, and since the href() usage is the most frequent one, we store
842# the name -> CGI key mapping here, instead of the reverse.
843#
844# XXX: Warning: If you touch this, check the search form for updating,
845# too.
Jakub Narebski24d06932006-09-26 01:57:02 +0200[diff] [blame]846
Alexander Gavrilovdde80d92008-11-06 01:10:07 +0300[diff] [blame]847our @cgi_param_mapping = (
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]848 project => "p",
849 action => "a",
850 file_name => "f",
851 file_parent => "fp",
852 hash => "h",
853 hash_parent => "hp",
854 hash_base => "hb",
855 hash_parent_base => "hpb",
856 page => "pg",
857 order => "o",
858 searchtext => "s",
859 searchtype => "st",
860 snapshot_format => "sf",
861 extra_options => "opt",
862 search_use_regexp => "sr",
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]863 ctag => "by_tag",
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]864 diff_style => "ds",
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]865 project_filter => "pf",
Jakub Narebskic4ccf612009-09-01 13:39:19 +0200[diff] [blame]866 # this must be last entry (for manipulation from JavaScript)
867 javascript => "js"
Miklos Vajna868bc062007-07-12 20:39:27 +0200[diff] [blame]868);
Alexander Gavrilovdde80d92008-11-06 01:10:07 +0300[diff] [blame]869our %cgi_param_mapping = @cgi_param_mapping;
Miklos Vajna868bc062007-07-12 20:39:27 +0200[diff] [blame]870
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]871# we will also need to know the possible actions, for validation
Alexander Gavrilovdde80d92008-11-06 01:10:07 +0300[diff] [blame]872our %actions = (
Rafael Garcia-Suarez3a5b9192008-06-06 09:53:32 +0200[diff] [blame]873 "blame" => \&git_blame,
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]874 "blame_incremental" => \&git_blame_incremental,
875 "blame_data" => \&git_blame_data,
Matthias Lederhofer8e85cdc2006-07-31 23:46:25 +0200[diff] [blame]876 "blobdiff" => \&git_blobdiff,
877 "blobdiff_plain" => \&git_blobdiff_plain,
878 "blob" => \&git_blob,
879 "blob_plain" => \&git_blob_plain,
880 "commitdiff" => \&git_commitdiff,
881 "commitdiff_plain" => \&git_commitdiff_plain,
882 "commit" => \&git_commit,
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]883 "forks" => \&git_forks,
Matthias Lederhofer8e85cdc2006-07-31 23:46:25 +0200[diff] [blame]884 "heads" => \&git_heads,
885 "history" => \&git_history,
886 "log" => \&git_log,
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]887 "patch" => \&git_patch,
Giuseppe Bilottaa3411f82008-12-18 08:13:18 +0100[diff] [blame]888 "patches" => \&git_patches,
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]889 "remotes" => \&git_remotes,
Matthias Lederhofer8e85cdc2006-07-31 23:46:25 +0200[diff] [blame]890 "rss" => \&git_rss,
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]891 "atom" => \&git_atom,
Matthias Lederhofer8e85cdc2006-07-31 23:46:25 +0200[diff] [blame]892 "search" => \&git_search,
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]893 "search_help" => \&git_search_help,
Matthias Lederhofer8e85cdc2006-07-31 23:46:25 +0200[diff] [blame]894 "shortlog" => \&git_shortlog,
895 "summary" => \&git_summary,
896 "tag" => \&git_tag,
897 "tags" => \&git_tags,
898 "tree" => \&git_tree,
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]899 "snapshot" => \&git_snapshot,
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]900 "object" => \&git_object,
Jakub Narebski77a153f2006-08-22 16:59:20 +0200[diff] [blame]901 # those below don't need $project
902 "opml" => \&git_opml,
903 "project_list" => \&git_project_list,
Jakub Narebskifc2b2be2006-09-15 04:56:03 +0200[diff] [blame]904 "project_index" => \&git_project_index,
Matthias Lederhofer8e85cdc2006-07-31 23:46:25 +0200[diff] [blame]905);
906
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]907# finally, we have the hash of allowed extra_options for the commands that
908# allow them
Alexander Gavrilovdde80d92008-11-06 01:10:07 +0300[diff] [blame]909our %allowed_options = (
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]910 "--no-merges" => [ qw(rss atom log shortlog history) ],
911);
912
913# fill %input_params with the CGI parameters. All values except for 'opt'
914# should be single values, but opt can be an array. We should probably
915# build an array of parameters that can be multi-valued, but since for the time
916# being it's only this one, we just single it out
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]917sub evaluate_query_params {
918 our $cgi;
919
920 while (my ($name, $symbol) = each %cgi_param_mapping) {
921 if ($symbol eq 'opt') {
Jeff King13dbf462014-11-18 12:10:22 -0500[diff] [blame]922 $input_params{$name} = [ map { decode_utf8($_) } $cgi->multi_param($symbol) ];
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]923 } else {
Jakub Narebski84d9e2d2012-02-03 13:44:54 +0100[diff] [blame]924 $input_params{$name} = decode_utf8($cgi->param($symbol));
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]925 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]926 }
927}
928
929# now read PATH_INFO and update the parameter list for missing parameters
930sub evaluate_path_info {
931 return if defined $input_params{'project'};
932 return if !$path_info;
933 $path_info =~ s,^/+,,;
934 return if !$path_info;
935
936 # find which part of PATH_INFO is project
937 my $project = $path_info;
938 $project =~ s,/+$,,;
939 while ($project && !check_head_link("$projectroot/$project")) {
940 $project =~ s,/*[^/]*$,,;
941 }
942 return unless $project;
943 $input_params{'project'} = $project;
944
945 # do not change any parameters if an action is given using the query string
946 return if $input_params{'action'};
947 $path_info =~ s,^\Q$project\E/*,,;
948
Giuseppe Bilottad8c28822008-10-21 21:34:50 +0200[diff] [blame]949 # next, check if we have an action
950 my $action = $path_info;
951 $action =~ s,/.*$,,;
952 if (exists $actions{$action}) {
953 $path_info =~ s,^$action/*,,;
954 $input_params{'action'} = $action;
955 }
956
957 # list of actions that want hash_base instead of hash, but can have no
958 # pathname (f) parameter
959 my @wants_base = (
960 'tree',
961 'history',
962 );
963
Jakub Narebski7e00dc52010-10-13 13:33:48 +0200[diff] [blame]964 # we want to catch, among others
Giuseppe Bilottab0be3832008-10-21 21:34:53 +0200[diff] [blame]965 # [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]
966 my ($parentrefname, $parentpathname, $refname, $pathname) =
Jakub Narebski7e00dc52010-10-13 13:33:48 +0200[diff] [blame]967 ($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?([^:]+?)?(?::(.+))?$/);
Giuseppe Bilottab0be3832008-10-21 21:34:53 +0200[diff] [blame]968
969 # first, analyze the 'current' part
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]970 if (defined $pathname) {
Giuseppe Bilottad8c28822008-10-21 21:34:50 +0200[diff] [blame]971 # we got "branch:filename" or "branch:dir/"
972 # we could use git_get_type(branch:pathname), but:
973 # - it needs $git_dir
974 # - it does a git() call
975 # - the convention of terminating directories with a slash
976 # makes it superfluous
977 # - embedding the action in the PATH_INFO would make it even
978 # more superfluous
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]979 $pathname =~ s,^/+,,;
980 if (!$pathname || substr($pathname, -1) eq "/") {
Giuseppe Bilottad8c28822008-10-21 21:34:50 +0200[diff] [blame]981 $input_params{'action'} ||= "tree";
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]982 $pathname =~ s,/$,,;
983 } else {
Giuseppe Bilottab0be3832008-10-21 21:34:53 +0200[diff] [blame]984 # the default action depends on whether we had parent info
985 # or not
986 if ($parentrefname) {
987 $input_params{'action'} ||= "blobdiff_plain";
988 } else {
989 $input_params{'action'} ||= "blob_plain";
990 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]991 }
992 $input_params{'hash_base'} ||= $refname;
993 $input_params{'file_name'} ||= $pathname;
994 } elsif (defined $refname) {
Giuseppe Bilottad8c28822008-10-21 21:34:50 +0200[diff] [blame]995 # we got "branch". In this case we have to choose if we have to
996 # set hash or hash_base.
997 #
998 # Most of the actions without a pathname only want hash to be
999 # set, except for the ones specified in @wants_base that want
1000 # hash_base instead. It should also be noted that hand-crafted
1001 # links having 'history' as an action and no pathname or hash
1002 # set will fail, but that happens regardless of PATH_INFO.
Jakub Narebskid0af3732010-10-13 13:35:20 +0200[diff] [blame]1003 if (defined $parentrefname) {
1004 # if there is parent let the default be 'shortlog' action
1005 # (for http://git.example.com/repo.git/A..B links); if there
1006 # is no parent, dispatch will detect type of object and set
1007 # action appropriately if required (if action is not set)
1008 $input_params{'action'} ||= "shortlog";
1009 }
1010 if ($input_params{'action'} &&
1011 grep { $_ eq $input_params{'action'} } @wants_base) {
Giuseppe Bilottad8c28822008-10-21 21:34:50 +0200[diff] [blame]1012 $input_params{'hash_base'} ||= $refname;
1013 } else {
1014 $input_params{'hash'} ||= $refname;
1015 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1016 }
Giuseppe Bilottab0be3832008-10-21 21:34:53 +0200[diff] [blame]1017
1018 # next, handle the 'parent' part, if present
1019 if (defined $parentrefname) {
1020 # a missing pathspec defaults to the 'current' filename, allowing e.g.
1021 # someproject/blobdiff/oldrev..newrev:/filename
1022 if ($parentpathname) {
1023 $parentpathname =~ s,^/+,,;
1024 $parentpathname =~ s,/$,,;
1025 $input_params{'file_parent'} ||= $parentpathname;
1026 } else {
1027 $input_params{'file_parent'} ||= $input_params{'file_name'};
1028 }
1029 # we assume that hash_parent_base is wanted if a path was specified,
1030 # or if the action wants hash_base instead of hash
1031 if (defined $input_params{'file_parent'} ||
1032 grep { $_ eq $input_params{'action'} } @wants_base) {
1033 $input_params{'hash_parent_base'} ||= $parentrefname;
1034 } else {
1035 $input_params{'hash_parent'} ||= $parentrefname;
1036 }
1037 }
Giuseppe Bilotta1ec2fb52008-11-02 10:21:38 +0100[diff] [blame]1038
1039 # for the snapshot action, we allow URLs in the form
1040 # $project/snapshot/$hash.ext
1041 # where .ext determines the snapshot and gets removed from the
1042 # passed $refname to provide the $hash.
1043 #
1044 # To be able to tell that $refname includes the format extension, we
1045 # require the following two conditions to be satisfied:
1046 # - the hash input parameter MUST have been set from the $refname part
1047 # of the URL (i.e. they must be equal)
1048 # - the snapshot format MUST NOT have been defined already (e.g. from
1049 # CGI parameter sf)
1050 # It's also useless to try any matching unless $refname has a dot,
1051 # so we check for that too
1052 if (defined $input_params{'action'} &&
1053 $input_params{'action'} eq 'snapshot' &&
1054 defined $refname && index($refname, '.') != -1 &&
1055 $refname eq $input_params{'hash'} &&
1056 !defined $input_params{'snapshot_format'}) {
1057 # We loop over the known snapshot formats, checking for
1058 # extensions. Allowed extensions are both the defined suffix
1059 # (which includes the initial dot already) and the snapshot
1060 # format key itself, with a prepended dot
Holger Weißccb4b532009-03-31 18:16:36 +0200[diff] [blame]1061 while (my ($fmt, $opt) = each %known_snapshot_formats) {
Giuseppe Bilotta1ec2fb52008-11-02 10:21:38 +0100[diff] [blame]1062 my $hash = $refname;
Jakub Narebski095e9142009-05-11 19:42:47 +0200[diff] [blame]1063 unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {
1064 next;
1065 }
1066 my $sfx = $1;
Giuseppe Bilotta1ec2fb52008-11-02 10:21:38 +0100[diff] [blame]1067 # a valid suffix was found, so set the snapshot format
1068 # and reset the hash parameter
1069 $input_params{'snapshot_format'} = $fmt;
1070 $input_params{'hash'} = $hash;
1071 # we also set the format suffix to the one requested
1072 # in the URL: this way a request for e.g. .tgz returns
1073 # a .tgz instead of a .tar.gz
1074 $known_snapshot_formats{$fmt}{'suffix'} = $sfx;
1075 last;
1076 }
1077 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1078}
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1079
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1080our ($action, $project, $file_name, $file_parent, $hash, $hash_parent, $hash_base,
1081 $hash_parent_base, @extra_options, $page, $searchtype, $search_use_regexp,
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]1082 $searchtext, $search_regexp, $project_filter);
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1083sub evaluate_and_validate_params {
1084 our $action = $input_params{'action'};
1085 if (defined $action) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1086 if (!is_valid_action($action)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1087 die_error(400, "Invalid action parameter");
1088 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1089 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1090
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1091 # parameters which are pathnames
1092 our $project = $input_params{'project'};
1093 if (defined $project) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1094 if (!is_valid_project($project)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1095 undef $project;
1096 die_error(404, "No such project");
1097 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1098 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1099
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]1100 our $project_filter = $input_params{'project_filter'};
1101 if (defined $project_filter) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1102 if (!is_valid_pathname($project_filter)) {
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]1103 die_error(404, "Invalid project_filter parameter");
1104 }
1105 }
1106
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1107 our $file_name = $input_params{'file_name'};
1108 if (defined $file_name) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1109 if (!is_valid_pathname($file_name)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1110 die_error(400, "Invalid file parameter");
1111 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1112 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1113
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1114 our $file_parent = $input_params{'file_parent'};
1115 if (defined $file_parent) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1116 if (!is_valid_pathname($file_parent)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1117 die_error(400, "Invalid file parent parameter");
1118 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1119 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1120
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1121 # parameters which are refnames
1122 our $hash = $input_params{'hash'};
1123 if (defined $hash) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1124 if (!is_valid_refname($hash)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1125 die_error(400, "Invalid hash parameter");
1126 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1127 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1128
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1129 our $hash_parent = $input_params{'hash_parent'};
1130 if (defined $hash_parent) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1131 if (!is_valid_refname($hash_parent)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1132 die_error(400, "Invalid hash parent parameter");
1133 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1134 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1135
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1136 our $hash_base = $input_params{'hash_base'};
1137 if (defined $hash_base) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1138 if (!is_valid_refname($hash_base)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1139 die_error(400, "Invalid hash base parameter");
1140 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1141 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1142
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1143 our @extra_options = @{$input_params{'extra_options'}};
1144 # @extra_options is always defined, since it can only be (currently) set from
1145 # CGI, and $cgi->param() returns the empty array in array context if the param
1146 # is not set
1147 foreach my $opt (@extra_options) {
1148 if (not exists $allowed_options{$opt}) {
1149 die_error(400, "Invalid option parameter");
1150 }
1151 if (not grep(/^$action$/, @{$allowed_options{$opt}})) {
1152 die_error(400, "Invalid option parameter for this action");
1153 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1154 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1155
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1156 our $hash_parent_base = $input_params{'hash_parent_base'};
1157 if (defined $hash_parent_base) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1158 if (!is_valid_refname($hash_parent_base)) {
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1159 die_error(400, "Invalid hash parent base parameter");
1160 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1161 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1162
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1163 # other parameters
1164 our $page = $input_params{'page'};
1165 if (defined $page) {
1166 if ($page =~ m/[^0-9]/) {
1167 die_error(400, "Invalid page parameter");
1168 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1169 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1170
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1171 our $searchtype = $input_params{'searchtype'};
1172 if (defined $searchtype) {
1173 if ($searchtype =~ m/[^a-z]/) {
1174 die_error(400, "Invalid searchtype parameter");
1175 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1176 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1177
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1178 our $search_use_regexp = $input_params{'search_use_regexp'};
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1179
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1180 our $searchtext = $input_params{'searchtext'};
Charles McGarveyca7a5dc2013-06-04 22:44:28 -0600[diff] [blame]1181 our $search_regexp = undef;
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1182 if (defined $searchtext) {
1183 if (length($searchtext) < 2) {
1184 die_error(403, "At least two characters are required for search parameter");
1185 }
Jakub Narebski36612e42012-02-28 19:41:47 +0100[diff] [blame]1186 if ($search_use_regexp) {
1187 $search_regexp = $searchtext;
1188 if (!eval { qr/$search_regexp/; 1; }) {
1189 (my $error = $@) =~ s/ at \S+ line \d+.*\n?//;
1190 die_error(400, "Invalid search regexp '$search_regexp'",
1191 esc_html($error));
1192 }
1193 } else {
1194 $search_regexp = quotemeta $searchtext;
1195 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1196 }
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1197}
1198
1199# path to the current git repository
1200our $git_dir;
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1201sub evaluate_git_dir {
1202 our $git_dir = "$projectroot/$project" if $project;
1203}
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1204
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]1205our (@snapshot_fmts, $git_avatar, @extra_branch_refs);
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1206sub configure_gitweb_features {
1207 # list of supported snapshot formats
1208 our @snapshot_fmts = gitweb_get_feature('snapshot');
1209 @snapshot_fmts = filter_snapshot_fmts(@snapshot_fmts);
Giuseppe Bilotta5e166842008-11-02 10:21:37 +0100[diff] [blame]1210
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1211 our ($git_avatar) = gitweb_get_feature('avatar');
Ævar Arnfjörð Bjarmason7d5b30e2018-03-03 15:38:08 +0000[diff] [blame]1212 $git_avatar = '' unless $git_avatar =~ /^(?:gravatar|picon)$/s;
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]1213
1214 our @extra_branch_refs = gitweb_get_feature('extra-branch-refs');
1215 @extra_branch_refs = filter_and_validate_refs (@extra_branch_refs);
1216}
1217
1218sub get_branch_refs {
1219 return ('heads', @extra_branch_refs);
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]1220}
1221
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]1222# custom error handler: 'die <message>' is Internal Server Error
1223sub handle_errors_html {
1224 my $msg = shift; # it is already HTML escaped
1225
1226 # to avoid infinite loop where error occurs in die_error,
1227 # change handler to default handler, disabling handle_errors_html
Stefano Lattarini41ccfdd2013-04-12 00:36:10 +0200[diff] [blame]1228 set_message("Error occurred when inside die_error:\n$msg");
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]1229
1230 # you cannot jump out of die_error when called as error handler;
1231 # the subroutine set via CGI::Carp::set_message is called _after_
1232 # HTTP headers are already written, so it cannot write them itself
1233 die_error(undef, undef, $msg, -error_handler => 1, -no_http_header => 1);
1234}
1235set_message(\&handle_errors_html);
1236
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1237# dispatch
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1238sub dispatch {
1239 if (!defined $action) {
1240 if (defined $hash) {
1241 $action = git_get_type($hash);
Jakub Narebski18ab83e2012-01-07 11:47:38 +0100[diff] [blame]1242 $action or die_error(404, "Object does not exist");
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1243 } elsif (defined $hash_base && defined $file_name) {
1244 $action = git_get_type("$hash_base:$file_name");
Jakub Narebski18ab83e2012-01-07 11:47:38 +0100[diff] [blame]1245 $action or die_error(404, "File or directory does not exist");
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1246 } elsif (defined $project) {
1247 $action = 'summary';
1248 } else {
1249 $action = 'project_list';
1250 }
Gerrit Pape7f9778b2007-05-10 07:32:07 +0000[diff] [blame]1251 }
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1252 if (!defined($actions{$action})) {
1253 die_error(400, "Unknown action");
1254 }
1255 if ($action !~ m/^(?:opml|project_list|project_index)$/ &&
1256 !$project) {
1257 die_error(400, "Project needed");
1258 }
1259 $actions{$action}->();
Jakub Narebski77a153f2006-08-22 16:59:20 +0200[diff] [blame]1260}
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1261
Jakub Narebski869d5882010-07-05 20:52:43 +0200[diff] [blame]1262sub reset_timer {
Jakub Narebski3962f1d72010-11-09 19:27:54 +0100[diff] [blame]1263 our $t0 = [ gettimeofday() ]
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1264 if defined $t0;
Jakub Narebski869d5882010-07-05 20:52:43 +0200[diff] [blame]1265 our $number_of_git_cmds = 0;
1266}
1267
Jakub Narebskida4b2432010-11-25 19:43:59 +0100[diff] [blame]1268our $first_request = 1;
Jakub Narebski869d5882010-07-05 20:52:43 +0200[diff] [blame]1269sub run_request {
1270 reset_timer();
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1271
1272 evaluate_uri();
Jakub Narebskida4b2432010-11-25 19:43:59 +0100[diff] [blame]1273 if ($first_request) {
1274 evaluate_gitweb_config();
1275 evaluate_git_version();
1276 }
1277 if ($per_request_config) {
1278 if (ref($per_request_config) eq 'CODE') {
1279 $per_request_config->();
1280 } elsif (!$first_request) {
1281 evaluate_gitweb_config();
1282 }
1283 }
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1284 check_loadavg();
1285
Jonathan Nieder7f425db2010-07-30 22:01:59 -0500[diff] [blame]1286 # $projectroot and $projects_list might be set in gitweb config file
1287 $projects_list ||= $projectroot;
1288
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1289 evaluate_query_params();
1290 evaluate_path_info();
1291 evaluate_and_validate_params();
1292 evaluate_git_dir();
1293
1294 configure_gitweb_features();
1295
1296 dispatch();
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]1297}
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1298
1299our $is_last_request = sub { 1 };
1300our ($pre_dispatch_hook, $post_dispatch_hook, $pre_listen_hook);
1301our $CGI = 'CGI';
1302our $cgi;
Julien Moutinho2ecfcde2020-03-29 01:20:28 +0100[diff] [blame]1303our $FCGI_Stream_PRINT_raw = \&FCGI::Stream::PRINT;
Jakub Narebski45aa9892010-06-05 23:11:18 +0200[diff] [blame]1304sub configure_as_fcgi {
1305 require CGI::Fast;
1306 our $CGI = 'CGI::Fast';
Julien Moutinho2ecfcde2020-03-29 01:20:28 +0100[diff] [blame]1307 # FCGI is not Unicode aware hence the UTF-8 encoding must be done manually.
1308 # However no encoding must be done within git_blob_plain() and git_snapshot()
1309 # which must still output in raw binary mode.
1310 no warnings 'redefine';
1311 my $enc = Encode::find_encoding('UTF-8');
1312 *FCGI::Stream::PRINT = sub {
1313 my @OUTPUT = @_;
1314 for (my $i = 1; $i < @_; $i++) {
1315 $OUTPUT[$i] = $enc->encode($_[$i], Encode::FB_CROAK|Encode::LEAVE_SRC);
1316 }
1317 @_ = @OUTPUT;
1318 goto $FCGI_Stream_PRINT_raw;
1319 };
Jakub Narebski45aa9892010-06-05 23:11:18 +0200[diff] [blame]1320
1321 my $request_number = 0;
1322 # let each child service 100 requests
1323 our $is_last_request = sub { ++$request_number > 100 };
Jakub Narebskid04d3d42006-09-19 21:53:22 +0200[diff] [blame]1324}
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1325sub evaluate_argv {
Jakub Narebski45aa9892010-06-05 23:11:18 +0200[diff] [blame]1326 my $script_name = $ENV{'SCRIPT_NAME'} || $ENV{'SCRIPT_FILENAME'} || __FILE__;
1327 configure_as_fcgi()
1328 if $script_name =~ /\.fcgi$/;
1329
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1330 return unless (@ARGV);
1331
1332 require Getopt::Long;
1333 Getopt::Long::GetOptions(
Jakub Narebski45aa9892010-06-05 23:11:18 +0200[diff] [blame]1334 'fastcgi|fcgi|f' => \&configure_as_fcgi,
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1335 'nproc|n=i' => sub {
1336 my ($arg, $val) = @_;
1337 return unless eval { require FCGI::ProcManager; 1; };
1338 my $proc_manager = FCGI::ProcManager->new({
1339 n_processes => $val,
1340 });
1341 our $pre_listen_hook = sub { $proc_manager->pm_manage() };
1342 our $pre_dispatch_hook = sub { $proc_manager->pm_pre_dispatch() };
1343 our $post_dispatch_hook = sub { $proc_manager->pm_post_dispatch() };
1344 },
1345 );
1346}
1347
1348sub run {
1349 evaluate_argv();
Jakub Narebski869d5882010-07-05 20:52:43 +0200[diff] [blame]1350
Jakub Narebskida4b2432010-11-25 19:43:59 +0100[diff] [blame]1351 $first_request = 1;
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1352 $pre_listen_hook->()
1353 if $pre_listen_hook;
1354
1355 REQUEST:
1356 while ($cgi = $CGI->new()) {
1357 $pre_dispatch_hook->()
1358 if $pre_dispatch_hook;
1359
1360 run_request();
1361
Jakub Narebski0b450102010-08-02 22:21:47 +0200[diff] [blame]1362 $post_dispatch_hook->()
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1363 if $post_dispatch_hook;
Jakub Narebskida4b2432010-11-25 19:43:59 +0100[diff] [blame]1364 $first_request = 0;
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1365
1366 last REQUEST if ($is_last_request->());
1367 }
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1368
1369 DONE_GITWEB:
1370 1;
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]1371}
Sam Vilaina0446e72010-05-07 14:54:05 +0200[diff] [blame]1372
Jakub Narebskic2394fe2010-05-07 14:54:04 +0200[diff] [blame]1373run();
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]1374
Jakub Narebski5ed2ec12010-06-13 12:09:32 +0200[diff] [blame]1375if (defined caller) {
1376 # wrapped in a subroutine processing requests,
1377 # e.g. mod_perl with ModPerl::Registry, or PSGI with Plack::App::WrapCGI
1378 return;
1379} else {
1380 # pure CGI script, serving single request
1381 exit;
1382}
Kay Sievers823d5dc2005-08-07 19:57:58 +0200[diff] [blame]1383
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1384## ======================================================================
Martin Waitz06a9d862006-08-16 00:23:50 +0200[diff] [blame]1385## action links
1386
Jakub Narebski377bee32010-04-24 15:53:19 +0200[diff] [blame]1387# possible values of extra options
1388# -full => 0|1 - use absolute/full URL ($my_uri/$my_url as base)
1389# -replay => 1 - start from a current view (replay with modifications)
1390# -path_info => 0|1 - don't use/use path_info URL (if possible)
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]1391# -anchor => ANCHOR - add #ANCHOR to end of URL, implies -replay if used alone
Jakub Narebski74fd8722009-05-07 19:11:29 +0200[diff] [blame]1392sub href {
Jakub Narebski498fe002006-08-22 19:05:25 +0200[diff] [blame]1393 my %params = @_;
Jakub Narebskibd5d1e42006-11-19 15:05:21 +0100[diff] [blame]1394 # default is to use -absolute url() i.e. $my_uri
1395 my $href = $params{-full} ? $my_url : $my_uri;
Jakub Narebski498fe002006-08-22 19:05:25 +0200[diff] [blame]1396
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]1397 # implicit -replay, must be first of implicit params
1398 $params{-replay} = 1 if (keys %params == 1 && $params{-anchor});
1399
Jakub Narebskiafa9b622008-02-14 09:22:30 +0100[diff] [blame]1400 $params{'project'} = $project unless exists $params{'project'};
1401
Jakub Narebski1cad2832007-11-01 13:06:27 +0100[diff] [blame]1402 if ($params{-replay}) {
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1403 while (my ($name, $symbol) = each %cgi_param_mapping) {
Jakub Narebski1cad2832007-11-01 13:06:27 +0100[diff] [blame]1404 if (!exists $params{$name}) {
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1405 $params{$name} = $input_params{$name};
Jakub Narebski1cad2832007-11-01 13:06:27 +0100[diff] [blame]1406 }
1407 }
1408 }
1409
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]1410 my $use_pathinfo = gitweb_check_feature('pathinfo');
Jakub Narebski377bee32010-04-24 15:53:19 +0200[diff] [blame]1411 if (defined $params{'project'} &&
1412 (exists $params{-path_info} ? $params{-path_info} : $use_pathinfo)) {
Giuseppe Bilottab02bd7a2008-10-21 21:34:51 +0200[diff] [blame]1413 # try to put as many parameters as possible in PATH_INFO:
1414 # - project name
1415 # - action
Giuseppe Bilotta8db49a72008-10-21 21:34:54 +0200[diff] [blame]1416 # - hash_parent or hash_parent_base:/file_parent
Giuseppe Bilotta3550ea72008-10-21 21:34:52 +0200[diff] [blame]1417 # - hash or hash_base:/filename
Giuseppe Bilottac752a0e2008-11-02 10:21:39 +0100[diff] [blame]1418 # - the snapshot_format as an appropriate suffix
Giuseppe Bilottab02bd7a2008-10-21 21:34:51 +0200[diff] [blame]1419
1420 # When the script is the root DirectoryIndex for the domain,
1421 # $href here would be something like http://gitweb.example.com/
1422 # Thus, we strip any trailing / from $href, to spare us double
1423 # slashes in the final URL
1424 $href =~ s,/$,,;
1425
1426 # Then add the project name, if present
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1427 $href .= "/".esc_path_info($params{'project'});
Martin Waitz9e756902006-10-01 23:57:48 +0200[diff] [blame]1428 delete $params{'project'};
1429
Giuseppe Bilottac752a0e2008-11-02 10:21:39 +0100[diff] [blame]1430 # since we destructively absorb parameters, we keep this
1431 # boolean that remembers if we're handling a snapshot
1432 my $is_snapshot = $params{'action'} eq 'snapshot';
1433
Giuseppe Bilottab02bd7a2008-10-21 21:34:51 +0200[diff] [blame]1434 # Summary just uses the project path URL, any other action is
1435 # added to the URL
1436 if (defined $params{'action'}) {
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1437 $href .= "/".esc_path_info($params{'action'})
1438 unless $params{'action'} eq 'summary';
Martin Waitz9e756902006-10-01 23:57:48 +0200[diff] [blame]1439 delete $params{'action'};
1440 }
Giuseppe Bilottab02bd7a2008-10-21 21:34:51 +0200[diff] [blame]1441
Giuseppe Bilotta8db49a72008-10-21 21:34:54 +0200[diff] [blame]1442 # Next, we put hash_parent_base:/file_parent..hash_base:/file_name,
1443 # stripping nonexistent or useless pieces
1444 $href .= "/" if ($params{'hash_base'} || $params{'hash_parent_base'}
1445 || $params{'hash_parent'} || $params{'hash'});
Giuseppe Bilottab02bd7a2008-10-21 21:34:51 +0200[diff] [blame]1446 if (defined $params{'hash_base'}) {
Giuseppe Bilotta8db49a72008-10-21 21:34:54 +0200[diff] [blame]1447 if (defined $params{'hash_parent_base'}) {
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1448 $href .= esc_path_info($params{'hash_parent_base'});
Giuseppe Bilotta8db49a72008-10-21 21:34:54 +0200[diff] [blame]1449 # skip the file_parent if it's the same as the file_name
Giuseppe Bilottab7da7212009-07-31 08:48:49 +0200[diff] [blame]1450 if (defined $params{'file_parent'}) {
1451 if (defined $params{'file_name'} && $params{'file_parent'} eq $params{'file_name'}) {
1452 delete $params{'file_parent'};
1453 } elsif ($params{'file_parent'} !~ /\.\./) {
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1454 $href .= ":/".esc_path_info($params{'file_parent'});
Giuseppe Bilottab7da7212009-07-31 08:48:49 +0200[diff] [blame]1455 delete $params{'file_parent'};
1456 }
Giuseppe Bilotta8db49a72008-10-21 21:34:54 +0200[diff] [blame]1457 }
1458 $href .= "..";
1459 delete $params{'hash_parent'};
1460 delete $params{'hash_parent_base'};
1461 } elsif (defined $params{'hash_parent'}) {
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1462 $href .= esc_path_info($params{'hash_parent'}). "..";
Giuseppe Bilotta8db49a72008-10-21 21:34:54 +0200[diff] [blame]1463 delete $params{'hash_parent'};
1464 }
1465
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1466 $href .= esc_path_info($params{'hash_base'});
Giuseppe Bilotta8db49a72008-10-21 21:34:54 +0200[diff] [blame]1467 if (defined $params{'file_name'} && $params{'file_name'} !~ /\.\./) {
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1468 $href .= ":/".esc_path_info($params{'file_name'});
Giuseppe Bilottab02bd7a2008-10-21 21:34:51 +0200[diff] [blame]1469 delete $params{'file_name'};
1470 }
1471 delete $params{'hash'};
1472 delete $params{'hash_base'};
1473 } elsif (defined $params{'hash'}) {
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1474 $href .= esc_path_info($params{'hash'});
Giuseppe Bilottab02bd7a2008-10-21 21:34:51 +0200[diff] [blame]1475 delete $params{'hash'};
1476 }
Giuseppe Bilottac752a0e2008-11-02 10:21:39 +0100[diff] [blame]1477
1478 # If the action was a snapshot, we can absorb the
1479 # snapshot_format parameter too
1480 if ($is_snapshot) {
1481 my $fmt = $params{'snapshot_format'};
1482 # snapshot_format should always be defined when href()
1483 # is called, but just in case some code forgets, we
1484 # fall back to the default
1485 $fmt ||= $snapshot_fmts[0];
1486 $href .= $known_snapshot_formats{$fmt}{'suffix'};
1487 delete $params{'snapshot_format'};
1488 }
Martin Waitz9e756902006-10-01 23:57:48 +0200[diff] [blame]1489 }
1490
1491 # now encode the parameters explicitly
Jakub Narebski498fe002006-08-22 19:05:25 +0200[diff] [blame]1492 my @result = ();
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1493 for (my $i = 0; $i < @cgi_param_mapping; $i += 2) {
1494 my ($name, $symbol) = ($cgi_param_mapping[$i], $cgi_param_mapping[$i+1]);
Jakub Narebski498fe002006-08-22 19:05:25 +0200[diff] [blame]1495 if (defined $params{$name}) {
Jakub Narebskif22cca42007-07-29 01:04:09 +0200[diff] [blame]1496 if (ref($params{$name}) eq "ARRAY") {
1497 foreach my $par (@{$params{$name}}) {
1498 push @result, $symbol . "=" . esc_param($par);
1499 }
1500 } else {
1501 push @result, $symbol . "=" . esc_param($params{$name});
1502 }
Jakub Narebski498fe002006-08-22 19:05:25 +0200[diff] [blame]1503 }
1504 }
Martin Waitz9e756902006-10-01 23:57:48 +0200[diff] [blame]1505 $href .= "?" . join(';', @result) if scalar @result;
1506
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1507 # final transformation: trailing spaces must be escaped (URI-encoded)
1508 $href =~ s/(\s+)$/CGI::escape($1)/e;
1509
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]1510 if ($params{-anchor}) {
1511 $href .= "#".esc_param($params{-anchor});
1512 }
1513
Martin Waitz9e756902006-10-01 23:57:48 +0200[diff] [blame]1514 return $href;
Martin Waitz06a9d862006-08-16 00:23:50 +0200[diff] [blame]1515}
1516
1517
1518## ======================================================================
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1519## validation, quoting/unquoting and escaping
1520
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1521sub is_valid_action {
1522 my $input = shift;
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1523 return undef unless exists $actions{$input};
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1524 return 1;
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1525}
1526
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1527sub is_valid_project {
1528 my $input = shift;
1529
1530 return unless defined $input;
1531 if (!is_valid_pathname($input) ||
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1532 !(-d "$projectroot/$input") ||
Alexander Gavrilovec26f092008-11-06 01:15:56 +0300[diff] [blame]1533 !check_export_ok("$projectroot/$input") ||
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1534 ($strict_export && !project_in_list($input))) {
1535 return undef;
1536 } else {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1537 return 1;
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]1538 }
1539}
1540
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1541sub is_valid_pathname {
1542 my $input = shift;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1543
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1544 return undef unless defined $input;
Justin Lebar01689902014-03-31 15:11:46 -0700[diff] [blame]1545 # no '.' or '..' as elements of path, i.e. no '.' or '..'
Jakub Narebski24d06932006-09-26 01:57:02 +0200[diff] [blame]1546 # at the beginning, at the end, and between slashes.
1547 # also this catches doubled slashes
1548 if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
1549 return undef;
1550 }
1551 # no null characters
1552 if ($input =~ m!\0!) {
1553 return undef;
1554 }
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1555 return 1;
Jakub Narebski24d06932006-09-26 01:57:02 +0200[diff] [blame]1556}
1557
Krzesimir Nowakc0bc2262013-12-11 12:54:41 +0100[diff] [blame]1558sub is_valid_ref_format {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1559 my $input = shift;
Krzesimir Nowakc0bc2262013-12-11 12:54:41 +0100[diff] [blame]1560
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1561 return undef unless defined $input;
Krzesimir Nowakc0bc2262013-12-11 12:54:41 +0100[diff] [blame]1562 # restrictions on ref name according to git-check-ref-format
1563 if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
1564 return undef;
1565 }
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1566 return 1;
Krzesimir Nowakc0bc2262013-12-11 12:54:41 +0100[diff] [blame]1567}
1568
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1569sub is_valid_refname {
1570 my $input = shift;
Jakub Narebski24d06932006-09-26 01:57:02 +0200[diff] [blame]1571
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1572 return undef unless defined $input;
Jakub Narebski24d06932006-09-26 01:57:02 +0200[diff] [blame]1573 # textual hashes are O.K.
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]1574 if ($input =~ m/^$oid_regex$/) {
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1575 return 1;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1576 }
Jakub Narebski24d06932006-09-26 01:57:02 +0200[diff] [blame]1577 # it must be correct pathname
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1578 is_valid_pathname($input) or return undef;
Krzesimir Nowakc0bc2262013-12-11 12:54:41 +0100[diff] [blame]1579 # check git-check-ref-format restrictions
Krzesimir Nowak23faf542013-12-11 12:54:42 +0100[diff] [blame]1580 is_valid_ref_format($input) or return undef;
1581 return 1;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1582}
1583
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]1584# decode sequences of octets in utf8 into Perl's internal form,
1585# which is utf-8 with utf8 flag set if needed. gitweb writes out
1586# in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
1587sub to_utf8 {
1588 my $str = shift;
Jakub Narebski1df48762010-02-07 21:52:25 +0100[diff] [blame]1589 return undef unless defined $str;
Jakub Narebskib13e3ea2011-12-18 23:00:58 +0100[diff] [blame]1590
1591 if (utf8::is_utf8($str) || utf8::decode($str)) {
İsmail Dönmeze5d3de52007-12-04 10:55:41 +0200[diff] [blame]1592 return $str;
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]1593 } else {
1594 return decode($fallback_encoding, $str, Encode::FB_DEFAULT);
1595 }
1596}
1597
Kay Sievers232ff552005-11-24 16:56:55 +0100[diff] [blame]1598# quote unsafe chars, but keep the slash, even when it's not
1599# correct, but quoted slashes look too horrible in bookmarks
1600sub esc_param {
Kay Sievers353347b2005-11-14 05:47:18 +0100[diff] [blame]1601 my $str = shift;
Jakub Narebski1df48762010-02-07 21:52:25 +0100[diff] [blame]1602 return undef unless defined $str;
Giuseppe Bilotta452e2252009-10-13 21:51:36 +0200[diff] [blame]1603 $str =~ s/([^A-Za-z0-9\-_.~()\/:@ ]+)/CGI::escape($1)/eg;
Kay Sieversa9e60b72005-11-14 15:15:12 +0100[diff] [blame]1604 $str =~ s/ /\+/g;
Kay Sievers353347b2005-11-14 05:47:18 +0100[diff] [blame]1605 return $str;
1606}
1607
Jakub Narebski67976c62010-12-14 16:54:31 +0100[diff] [blame]1608# the quoting rules for path_info fragment are slightly different
1609sub esc_path_info {
1610 my $str = shift;
1611 return undef unless defined $str;
1612
1613 # path_info doesn't treat '+' as space (specially), but '?' must be escaped
1614 $str =~ s/([^A-Za-z0-9\-_.~();\/;:@&= +]+)/CGI::escape($1)/eg;
1615
1616 return $str;
1617}
1618
Ralf Wildenhues22e5e582010-08-22 13:12:12 +0200[diff] [blame]1619# quote unsafe chars in whole URL, so some characters cannot be quoted
Jakub Narebskif93bff82006-09-26 01:58:41 +0200[diff] [blame]1620sub esc_url {
1621 my $str = shift;
Jakub Narebski1df48762010-02-07 21:52:25 +0100[diff] [blame]1622 return undef unless defined $str;
Pavan Kumar Sunkara109988f2010-07-15 12:59:01 +0530[diff] [blame]1623 $str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&= ]+)/CGI::escape($1)/eg;
Jakub Narebskif93bff82006-09-26 01:58:41 +0200[diff] [blame]1624 $str =~ s/ /\+/g;
1625 return $str;
1626}
1627
Jakub Narebski3017ed62010-12-15 00:34:01 +0100[diff] [blame]1628# quote unsafe characters in HTML attributes
1629sub esc_attr {
1630
1631 # for XHTML conformance escaping '"' to '&quot;' is not enough
1632 return esc_html(@_);
1633}
1634
Kay Sievers232ff552005-11-24 16:56:55 +0100[diff] [blame]1635# replace invalid utf8 character with SUBSTITUTION sequence
Jakub Narebski74fd8722009-05-07 19:11:29 +0200[diff] [blame]1636sub esc_html {
Kay Sievers40c13812005-11-19 17:41:29 +0100[diff] [blame]1637 my $str = shift;
Jakub Narebski6255ef02006-11-01 14:33:21 +0100[diff] [blame]1638 my %opts = @_;
1639
Jakub Narebski1df48762010-02-07 21:52:25 +0100[diff] [blame]1640 return undef unless defined $str;
1641
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]1642 $str = to_utf8($str);
Li Yangc390ae92007-03-06 11:58:56 +0800[diff] [blame]1643 $str = $cgi->escapeHTML($str);
Jakub Narebski6255ef02006-11-01 14:33:21 +0100[diff] [blame]1644 if ($opts{'-nbsp'}) {
1645 $str =~ s/ /&nbsp;/g;
1646 }
Junio C Hamano25ffbb22006-11-08 15:11:10 -0800[diff] [blame]1647 $str =~ s|([[:cntrl:]])|(($1 ne "\t") ? quot_cec($1) : $1)|eg;
Kay Sievers40c13812005-11-19 17:41:29 +0100[diff] [blame]1648 return $str;
1649}
1650
Jakub Narebski391862e2006-11-25 09:43:59 +0100[diff] [blame]1651# quote control characters and escape filename to HTML
1652sub esc_path {
1653 my $str = shift;
1654 my %opts = @_;
1655
Jakub Narebski1df48762010-02-07 21:52:25 +0100[diff] [blame]1656 return undef unless defined $str;
1657
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]1658 $str = to_utf8($str);
Li Yangc390ae92007-03-06 11:58:56 +0800[diff] [blame]1659 $str = $cgi->escapeHTML($str);
Jakub Narebski391862e2006-11-25 09:43:59 +0100[diff] [blame]1660 if ($opts{'-nbsp'}) {
1661 $str =~ s/ /&nbsp;/g;
1662 }
1663 $str =~ s|([[:cntrl:]])|quot_cec($1)|eg;
1664 return $str;
1665}
1666
Ævar Arnfjörð Bjarmason26547bf2016-10-06 09:11:33 +0000[diff] [blame]1667# Sanitize for use in XHTML + application/xml+xhtml (valid XML 1.0)
Jakub Narebski08667862011-09-16 14:41:57 +0200[diff] [blame]1668sub sanitize {
1669 my $str = shift;
1670
1671 return undef unless defined $str;
1672
1673 $str = to_utf8($str);
Orgad Shaneh0e901d22012-12-30 13:52:53 +0200[diff] [blame]1674 $str =~ s|([[:cntrl:]])|(index("\t\n\r", $1) != -1 ? $1 : quot_cec($1))|eg;
Jakub Narebski08667862011-09-16 14:41:57 +0200[diff] [blame]1675 return $str;
1676}
1677
Jakub Narebski391862e2006-11-25 09:43:59 +0100[diff] [blame]1678# Make control characters "printable", using character escape codes (CEC)
Jakub Narebski1d3bc0c2006-11-08 11:50:07 +0100[diff] [blame]1679sub quot_cec {
1680 my $cntrl = shift;
Jakub Narebskic84c4832008-02-17 18:48:13 +0100[diff] [blame]1681 my %opts = @_;
Jakub Narebski1d3bc0c2006-11-08 11:50:07 +0100[diff] [blame]1682 my %es = ( # character escape codes, aka escape sequences
Elijah Newren15beaaa2019-11-05 17:07:23 +0000[diff] [blame]1683 "\t" => '\t', # tab (HT)
1684 "\n" => '\n', # line feed (LF)
1685 "\r" => '\r', # carriage return (CR)
1686 "\f" => '\f', # form feed (FF)
1687 "\b" => '\b', # backspace (BS)
1688 "\a" => '\a', # alarm (bell) (BEL)
1689 "\e" => '\e', # escape (ESC)
1690 "\013" => '\v', # vertical tab (VT)
1691 "\000" => '\0', # nul character (NUL)
Jakub Narebskic84c4832008-02-17 18:48:13 +0100[diff] [blame]1692 );
Jakub Narebski1d3bc0c2006-11-08 11:50:07 +0100[diff] [blame]1693 my $chr = ( (exists $es{$cntrl})
1694 ? $es{$cntrl}
Petr Baudis25dfd172008-10-01 22:11:54 +0200[diff] [blame]1695 : sprintf('\%2x', ord($cntrl)) );
Jakub Narebskic84c4832008-02-17 18:48:13 +0100[diff] [blame]1696 if ($opts{-nohtml}) {
1697 return $chr;
1698 } else {
1699 return "<span class=\"cntrl\">$chr</span>";
1700 }
Jakub Narebski1d3bc0c2006-11-08 11:50:07 +0100[diff] [blame]1701}
1702
Jakub Narebski391862e2006-11-25 09:43:59 +0100[diff] [blame]1703# Alternatively use unicode control pictures codepoints,
1704# Unicode "printable representation" (PR)
Jakub Narebski1d3bc0c2006-11-08 11:50:07 +0100[diff] [blame]1705sub quot_upr {
1706 my $cntrl = shift;
Jakub Narebskic84c4832008-02-17 18:48:13 +0100[diff] [blame]1707 my %opts = @_;
1708
Jakub Narebski1d3bc0c2006-11-08 11:50:07 +0100[diff] [blame]1709 my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
Jakub Narebskic84c4832008-02-17 18:48:13 +0100[diff] [blame]1710 if ($opts{-nohtml}) {
1711 return $chr;
1712 } else {
1713 return "<span class=\"cntrl\">$chr</span>";
1714 }
Jakub Narebski1d3bc0c2006-11-08 11:50:07 +0100[diff] [blame]1715}
1716
Kay Sievers232ff552005-11-24 16:56:55 +0100[diff] [blame]1717# git may return quoted and escaped filenames
1718sub unquote {
1719 my $str = shift;
Jakub Narebski403d0902006-11-08 11:48:56 +0100[diff] [blame]1720
1721 sub unq {
1722 my $seq = shift;
1723 my %es = ( # character escape codes, aka escape sequences
1724 't' => "\t", # tab (HT, TAB)
1725 'n' => "\n", # newline (NL)
1726 'r' => "\r", # return (CR)
1727 'f' => "\f", # form feed (FF)
1728 'b' => "\b", # backspace (BS)
1729 'a' => "\a", # alarm (bell) (BEL)
1730 'e' => "\e", # escape (ESC)
1731 'v' => "\013", # vertical tab (VT)
1732 );
1733
1734 if ($seq =~ m/^[0-7]{1,3}$/) {
1735 # octal char sequence
1736 return chr(oct($seq));
1737 } elsif (exists $es{$seq}) {
1738 # C escape sequence, aka character escape code
Jakub Narebskic84c4832008-02-17 18:48:13 +0100[diff] [blame]1739 return $es{$seq};
Jakub Narebski403d0902006-11-08 11:48:56 +0100[diff] [blame]1740 }
1741 # quoted ordinary character
1742 return $seq;
1743 }
1744
Kay Sievers232ff552005-11-24 16:56:55 +0100[diff] [blame]1745 if ($str =~ m/^"(.*)"$/) {
Jakub Narebski403d0902006-11-08 11:48:56 +0100[diff] [blame]1746 # needs unquoting
Kay Sievers232ff552005-11-24 16:56:55 +0100[diff] [blame]1747 $str = $1;
Jakub Narebski403d0902006-11-08 11:48:56 +0100[diff] [blame]1748 $str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
Kay Sievers232ff552005-11-24 16:56:55 +0100[diff] [blame]1749 }
1750 return $str;
1751}
1752
Jakub Narebskif16db172006-08-06 02:08:31 +0200[diff] [blame]1753# escape tabs (convert tabs to spaces)
1754sub untabify {
1755 my $line = shift;
1756
1757 while ((my $pos = index($line, "\t")) != -1) {
1758 if (my $count = (8 - ($pos % 8))) {
1759 my $spaces = ' ' x $count;
1760 $line =~ s/\t/$spaces/;
1761 }
1762 }
1763
1764 return $line;
1765}
1766
Matthias Lederhofer32f4aac2006-09-17 00:31:01 +0200[diff] [blame]1767sub project_in_list {
1768 my $project = shift;
1769 my @list = git_get_projects_list();
1770 return @list && scalar(grep { $_->{'path'} eq $project } @list);
1771}
1772
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1773## ----------------------------------------------------------------------
1774## HTML aware string manipulation
1775
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1776# Try to chop given string on a word boundary between position
1777# $len and $len+$add_len. If there is no word boundary there,
1778# chop at $len+$add_len. Do not chop if chopped part plus ellipsis
1779# (marking chopped part) would be longer than given string.
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1780sub chop_str {
1781 my $str = shift;
1782 my $len = shift;
1783 my $add_len = shift || 10;
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1784 my $where = shift || 'right'; # 'left' | 'center' | 'right'
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1785
Anders Waldenborgdee27752008-05-21 13:44:43 +0200[diff] [blame]1786 # Make sure perl knows it is utf8 encoded so we don't
1787 # cut in the middle of a utf8 multibyte char.
1788 $str = to_utf8($str);
1789
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1790 # allow only $len chars, but don't cut a word if it would fit in $add_len
1791 # if it doesn't fit, cut it if it's still longer than the dots we would add
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1792 # remove chopped character entities entirely
1793
1794 # when chopping in the middle, distribute $len into left and right part
1795 # return early if chopping wouldn't make string shorter
1796 if ($where eq 'center') {
1797 return $str if ($len + 5 >= length($str)); # filler is length 5
1798 $len = int($len/2);
1799 } else {
1800 return $str if ($len + 4 >= length($str)); # filler is length 4
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1801 }
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1802
1803 # regexps: ending and beginning with word part up to $add_len
1804 my $endre = qr/.{$len}\w{0,$add_len}/;
1805 my $begre = qr/\w{0,$add_len}.{$len}/;
1806
1807 if ($where eq 'left') {
1808 $str =~ m/^(.*?)($begre)$/;
1809 my ($lead, $body) = ($1, $2);
1810 if (length($lead) > 4) {
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1811 $lead = " ...";
1812 }
1813 return "$lead$body";
1814
1815 } elsif ($where eq 'center') {
1816 $str =~ m/^($endre)(.*)$/;
1817 my ($left, $str) = ($1, $2);
1818 $str =~ m/^(.*?)($begre)$/;
1819 my ($mid, $right) = ($1, $2);
1820 if (length($mid) > 5) {
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1821 $mid = " ... ";
1822 }
1823 return "$left$mid$right";
1824
1825 } else {
1826 $str =~ m/^($endre)(.*)$/;
1827 my $body = $1;
1828 my $tail = $2;
1829 if (length($tail) > 4) {
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1830 $tail = "... ";
1831 }
1832 return "$body$tail";
1833 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1834}
1835
David Symondsce58ec92007-10-23 11:31:22 +1000[diff] [blame]1836# takes the same arguments as chop_str, but also wraps a <span> around the
1837# result with a title attribute if it does get chopped. Additionally, the
1838# string is HTML-escaped.
1839sub chop_and_escape_str {
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1840 my ($str) = @_;
David Symondsce58ec92007-10-23 11:31:22 +1000[diff] [blame]1841
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]1842 my $chopped = chop_str(@_);
Jürgen Kreileder168c1e02011-12-17 10:22:21 +0100[diff] [blame]1843 $str = to_utf8($str);
David Symondsce58ec92007-10-23 11:31:22 +1000[diff] [blame]1844 if ($chopped eq $str) {
1845 return esc_html($chopped);
1846 } else {
Jakub Narebski14afe772009-05-22 17:35:46 +0200[diff] [blame]1847 $str =~ s/[[:cntrl:]]/?/g;
Jakub Narebski850b90a2008-02-16 23:07:46 +0100[diff] [blame]1848 return $cgi->span({-title=>$str}, esc_html($chopped));
David Symondsce58ec92007-10-23 11:31:22 +1000[diff] [blame]1849 }
1850}
1851
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1852# Highlight selected fragments of string, using given CSS class,
1853# and escape HTML. It is assumed that fragments do not overlap.
1854# Regions are passed as list of pairs (array references).
1855#
1856# Example: esc_html_hl_regions("foobar", "mark", [ 0, 3 ]) returns
1857# '<span class="mark">foo</span>bar'
1858sub esc_html_hl_regions {
1859 my ($str, $css_class, @sel) = @_;
Jakub Narębski9768a9d2012-04-11 23:18:39 +0200[diff] [blame]1860 my %opts = grep { ref($_) ne 'ARRAY' } @sel;
1861 @sel = grep { ref($_) eq 'ARRAY' } @sel;
1862 return esc_html($str, %opts) unless @sel;
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1863
1864 my $out = '';
1865 my $pos = 0;
1866
1867 for my $s (@sel) {
Michał Kiedrowiczce61fb92012-04-11 23:18:37 +0200[diff] [blame]1868 my ($begin, $end) = @$s;
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1869
Michał Kiedrowiczcbbea3d2012-04-11 23:18:38 +0200[diff] [blame]1870 # Don't create empty <span> elements.
1871 next if $end <= $begin;
1872
Jakub Narębski9768a9d2012-04-11 23:18:39 +0200[diff] [blame]1873 my $escaped = esc_html(substr($str, $begin, $end - $begin),
1874 %opts);
Michał Kiedrowiczce61fb92012-04-11 23:18:37 +0200[diff] [blame]1875
Jakub Narębski9768a9d2012-04-11 23:18:39 +0200[diff] [blame]1876 $out .= esc_html(substr($str, $pos, $begin - $pos), %opts)
Michał Kiedrowiczce61fb92012-04-11 23:18:37 +0200[diff] [blame]1877 if ($begin - $pos > 0);
1878 $out .= $cgi->span({-class => $css_class}, $escaped);
1879
1880 $pos = $end;
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1881 }
Jakub Narębski9768a9d2012-04-11 23:18:39 +0200[diff] [blame]1882 $out .= esc_html(substr($str, $pos), %opts)
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1883 if ($pos < length($str));
1884
1885 return $out;
1886}
1887
Jakub Narebskie607b792012-02-27 02:55:22 +0100[diff] [blame]1888# return positions of beginning and end of each match
1889sub matchpos_list {
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1890 my ($str, $regexp) = @_;
Jakub Narebskie607b792012-02-27 02:55:22 +0100[diff] [blame]1891 return unless (defined $str && defined $regexp);
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1892
1893 my @matches;
1894 while ($str =~ /$regexp/g) {
1895 push @matches, [$-[0], $+[0]];
1896 }
Jakub Narebskie607b792012-02-27 02:55:22 +0100[diff] [blame]1897 return @matches;
1898}
1899
1900# highlight match (if any), and escape HTML
1901sub esc_html_match_hl {
1902 my ($str, $regexp) = @_;
1903 return esc_html($str) unless defined $regexp;
1904
1905 my @matches = matchpos_list($str, $regexp);
Jakub Narebski337da8d2012-02-27 02:55:19 +0100[diff] [blame]1906 return esc_html($str) unless @matches;
1907
1908 return esc_html_hl_regions($str, 'match', @matches);
1909}
1910
Jakub Narebskie607b792012-02-27 02:55:22 +0100[diff] [blame]1911
1912# highlight match (if any) of shortened string, and escape HTML
1913sub esc_html_match_hl_chopped {
1914 my ($str, $chopped, $regexp) = @_;
1915 return esc_html_match_hl($str, $regexp) unless defined $chopped;
1916
1917 my @matches = matchpos_list($str, $regexp);
1918 return esc_html($chopped) unless @matches;
1919
1920 # filter matches so that we mark chopped string
1921 my $tail = "... "; # see chop_str
1922 unless ($chopped =~ s/\Q$tail\E$//) {
1923 $tail = '';
1924 }
1925 my $chop_len = length($chopped);
1926 my $tail_len = length($tail);
1927 my @filtered;
1928
1929 for my $m (@matches) {
1930 if ($m->[0] > $chop_len) {
1931 push @filtered, [ $chop_len, $chop_len + $tail_len ] if ($tail_len > 0);
1932 last;
1933 } elsif ($m->[1] > $chop_len) {
1934 push @filtered, [ $m->[0], $chop_len + $tail_len ];
1935 last;
1936 }
1937 push @filtered, $m;
1938 }
1939
1940 return esc_html_hl_regions($chopped . $tail, 'match', @filtered);
1941}
1942
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1943## ----------------------------------------------------------------------
1944## functions returning short strings
1945
Jakub Narebski1f1ab5f2006-06-20 14:58:12 +0000[diff] [blame]1946# CSS class for given age value (in seconds)
1947sub age_class {
1948 my $age = shift;
1949
Jakub Narebski785cdea2007-05-13 12:39:22 +0200[diff] [blame]1950 if (!defined $age) {
1951 return "noage";
1952 } elsif ($age < 60*60*2) {
Jakub Narebski1f1ab5f2006-06-20 14:58:12 +0000[diff] [blame]1953 return "age0";
1954 } elsif ($age < 60*60*24*2) {
1955 return "age1";
1956 } else {
1957 return "age2";
1958 }
1959}
1960
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]1961# convert age in seconds to "nn units ago" string
1962sub age_string {
1963 my $age = shift;
1964 my $age_str;
1965
1966 if ($age > 60*60*24*365*2) {
1967 $age_str = (int $age/60/60/24/365);
1968 $age_str .= " years ago";
1969 } elsif ($age > 60*60*24*(365/12)*2) {
1970 $age_str = int $age/60/60/24/(365/12);
1971 $age_str .= " months ago";
1972 } elsif ($age > 60*60*24*7*2) {
1973 $age_str = int $age/60/60/24/7;
1974 $age_str .= " weeks ago";
1975 } elsif ($age > 60*60*24*2) {
1976 $age_str = int $age/60/60/24;
1977 $age_str .= " days ago";
1978 } elsif ($age > 60*60*2) {
1979 $age_str = int $age/60/60;
1980 $age_str .= " hours ago";
1981 } elsif ($age > 60*2) {
1982 $age_str = int $age/60;
1983 $age_str .= " min ago";
1984 } elsif ($age > 2) {
1985 $age_str = int $age;
1986 $age_str .= " sec ago";
1987 } else {
1988 $age_str .= " right now";
1989 }
1990 return $age_str;
1991}
1992
Jakub Narebski01ac1e32007-07-28 16:27:31 +0200[diff] [blame]1993use constant {
1994 S_IFINVALID => 0030000,
1995 S_IFGITLINK => 0160000,
1996};
1997
1998# submodule/subproject, a commit object reference
Jakub Narebski74fd8722009-05-07 19:11:29 +0200[diff] [blame]1999sub S_ISGITLINK {
Jakub Narebski01ac1e32007-07-28 16:27:31 +0200[diff] [blame]2000 my $mode = shift;
2001
2002 return (($mode & S_IFMT) == S_IFGITLINK)
2003}
2004
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2005# convert file mode in octal to symbolic file mode string
2006sub mode_str {
2007 my $mode = oct shift;
2008
Jakub Narebski01ac1e32007-07-28 16:27:31 +0200[diff] [blame]2009 if (S_ISGITLINK($mode)) {
2010 return 'm---------';
2011 } elsif (S_ISDIR($mode & S_IFMT)) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2012 return 'drwxr-xr-x';
2013 } elsif (S_ISLNK($mode)) {
2014 return 'lrwxrwxrwx';
2015 } elsif (S_ISREG($mode)) {
2016 # git cares only about the executable bit
2017 if ($mode & S_IXUSR) {
2018 return '-rwxr-xr-x';
2019 } else {
2020 return '-rw-r--r--';
2021 };
2022 } else {
2023 return '----------';
2024 }
2025}
2026
2027# convert file mode in octal to file type string
2028sub file_type {
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]2029 my $mode = shift;
2030
2031 if ($mode !~ m/^[0-7]+$/) {
2032 return $mode;
2033 } else {
2034 $mode = oct $mode;
2035 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2036
Jakub Narebski01ac1e32007-07-28 16:27:31 +0200[diff] [blame]2037 if (S_ISGITLINK($mode)) {
2038 return "submodule";
2039 } elsif (S_ISDIR($mode & S_IFMT)) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2040 return "directory";
2041 } elsif (S_ISLNK($mode)) {
2042 return "symlink";
2043 } elsif (S_ISREG($mode)) {
2044 return "file";
2045 } else {
2046 return "unknown";
2047 }
2048}
2049
Jakub Narebski744d0ac2006-11-08 17:59:41 +0100[diff] [blame]2050# convert file mode in octal to file type description string
2051sub file_type_long {
2052 my $mode = shift;
2053
2054 if ($mode !~ m/^[0-7]+$/) {
2055 return $mode;
2056 } else {
2057 $mode = oct $mode;
2058 }
2059
Jakub Narebski01ac1e32007-07-28 16:27:31 +0200[diff] [blame]2060 if (S_ISGITLINK($mode)) {
2061 return "submodule";
2062 } elsif (S_ISDIR($mode & S_IFMT)) {
Jakub Narebski744d0ac2006-11-08 17:59:41 +0100[diff] [blame]2063 return "directory";
2064 } elsif (S_ISLNK($mode)) {
2065 return "symlink";
2066 } elsif (S_ISREG($mode)) {
2067 if ($mode & S_IXUSR) {
2068 return "executable";
2069 } else {
2070 return "file";
2071 };
2072 } else {
2073 return "unknown";
2074 }
2075}
2076
2077
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2078## ----------------------------------------------------------------------
2079## functions returning short HTML fragments, or transforming HTML fragments
Pavel Roskin3dff5372007-02-03 23:49:16 -0500[diff] [blame]2080## which don't belong to other sections
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2081
Junio C Hamano225932e2006-11-09 00:57:13 -0800[diff] [blame]2082# format line of commit message.
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2083sub format_log_line_html {
2084 my $line = shift;
2085
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]2086 # Potentially abbreviated OID.
2087 my $regex = oid_nlen_regex("7,64");
2088
Junio C Hamano225932e2006-11-09 00:57:13 -0800[diff] [blame]2089 $line = esc_html($line, -nbsp=>1);
Ævar Arnfjörð Bjarmasoncf5c7252016-10-06 09:11:35 +0000[diff] [blame]2090 $line =~ s{
2091 \b
2092 (
2093 # The output of "git describe", e.g. v2.10.0-297-gf6727b0
2094 # or hadoop-20160921-113441-20-g094fb7d
2095 (?<!-) # see strbuf_check_tag_ref(). Tags can't start with -
2096 [A-Za-z0-9.-]+
2097 (?!\.) # refs can't end with ".", see check_refname_format()
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]2098 -g$regex
Ævar Arnfjörð Bjarmasoncf5c7252016-10-06 09:11:35 +0000[diff] [blame]2099 |
2100 # Just a normal looking Git SHA1
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]2101 $regex
Ævar Arnfjörð Bjarmasoncf5c7252016-10-06 09:11:35 +0000[diff] [blame]2102 )
2103 \b
2104 }{
Marcel M. Cary7d233de2009-02-17 19:00:43 -0800[diff] [blame]2105 $cgi->a({-href => href(action=>"object", hash=>$1),
2106 -class => "text"}, $1);
Ævar Arnfjörð Bjarmasoncf5c7252016-10-06 09:11:35 +0000[diff] [blame]2107 }egx;
Marcel M. Cary7d233de2009-02-17 19:00:43 -0800[diff] [blame]2108
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2109 return $line;
2110}
2111
2112# format marker of refs pointing to given object
Giuseppe Bilotta4afbaef2008-09-02 21:47:05 +0200[diff] [blame]2113
2114# the destination action is chosen based on object type and current context:
2115# - for annotated tags, we choose the tag view unless it's the current view
2116# already, in which case we go to shortlog view
2117# - for other refs, we keep the current view if we're in history, shortlog or
2118# log view, and select shortlog otherwise
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]2119sub format_ref_marker {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2120 my ($refs, $id) = @_;
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]2121 my $markers = '';
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2122
2123 if (defined $refs->{$id}) {
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]2124 foreach my $ref (@{$refs->{$id}}) {
Giuseppe Bilotta4afbaef2008-09-02 21:47:05 +0200[diff] [blame]2125 # this code exploits the fact that non-lightweight tags are the
2126 # only indirect objects, and that they are the only objects for which
2127 # we want to use tag instead of shortlog as action
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]2128 my ($type, $name) = qw();
Giuseppe Bilotta4afbaef2008-09-02 21:47:05 +0200[diff] [blame]2129 my $indirect = ($ref =~ s/\^\{\}$//);
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]2130 # e.g. tags/v2.6.11 or heads/next
2131 if ($ref =~ m!^(.*?)s?/(.*)$!) {
2132 $type = $1;
2133 $name = $2;
2134 } else {
2135 $type = "ref";
2136 $name = $ref;
2137 }
2138
Giuseppe Bilotta4afbaef2008-09-02 21:47:05 +0200[diff] [blame]2139 my $class = $type;
2140 $class .= " indirect" if $indirect;
2141
2142 my $dest_action = "shortlog";
2143
2144 if ($indirect) {
2145 $dest_action = "tag" unless $action eq "tag";
2146 } elsif ($action =~ /^(history|(short)?log)$/) {
2147 $dest_action = $action;
2148 }
2149
2150 my $dest = "";
2151 $dest .= "refs/" unless $ref =~ m!^refs/!;
2152 $dest .= $ref;
2153
2154 my $link = $cgi->a({
2155 -href => href(
2156 action=>$dest_action,
2157 hash=>$dest
Andreas Brauchli77947bb2016-07-29 16:49:37 +0200[diff] [blame]2158 )}, esc_html($name));
Giuseppe Bilotta4afbaef2008-09-02 21:47:05 +0200[diff] [blame]2159
Jakub Narebski3017ed62010-12-15 00:34:01 +0100[diff] [blame]2160 $markers .= " <span class=\"".esc_attr($class)."\" title=\"".esc_attr($ref)."\">" .
Giuseppe Bilotta4afbaef2008-09-02 21:47:05 +0200[diff] [blame]2161 $link . "</span>";
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]2162 }
2163 }
2164
2165 if ($markers) {
2166 return ' <span class="refs">'. $markers . '</span>';
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2167 } else {
2168 return "";
2169 }
2170}
2171
Jakub Narebski17d07442006-08-14 02:08:27 +0200[diff] [blame]2172# format, perhaps shortened and with markers, title line
2173sub format_subject_html {
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]2174 my ($long, $short, $href, $extra) = @_;
Jakub Narebski17d07442006-08-14 02:08:27 +0200[diff] [blame]2175 $extra = '' unless defined($extra);
2176
2177 if (length($short) < length($long)) {
Jakub Narebski14afe772009-05-22 17:35:46 +0200[diff] [blame]2178 $long =~ s/[[:cntrl:]]/?/g;
Jakub Narebski7c278012006-08-22 12:02:48 +0200[diff] [blame]2179 return $cgi->a({-href => $href, -class => "list subject",
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]2180 -title => to_utf8($long)},
Giuseppe Bilotta01b89f02009-08-23 10:28:09 +0200[diff] [blame]2181 esc_html($short)) . $extra;
Jakub Narebski17d07442006-08-14 02:08:27 +0200[diff] [blame]2182 } else {
Jakub Narebski7c278012006-08-22 12:02:48 +0200[diff] [blame]2183 return $cgi->a({-href => $href, -class => "list subject"},
Giuseppe Bilotta01b89f02009-08-23 10:28:09 +0200[diff] [blame]2184 esc_html($long)) . $extra;
Jakub Narebski17d07442006-08-14 02:08:27 +0200[diff] [blame]2185 }
2186}
2187
Giuseppe Bilotta5a371b72009-06-30 00:00:52 +0200[diff] [blame]2188# Rather than recomputing the url for an email multiple times, we cache it
2189# after the first hit. This gives a visible benefit in views where the avatar
2190# for the same email is used repeatedly (e.g. shortlog).
2191# The cache is shared by all avatar engines (currently gravatar only), which
2192# are free to use it as preferred. Since only one avatar engine is used for any
2193# given page, there's no risk for cache conflicts.
2194our %avatar_cache = ();
2195
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]2196# Compute the picon url for a given email, by using the picon search service over at
2197# http://www.cs.indiana.edu/picons/search.html
2198sub picon_url {
2199 my $email = lc shift;
2200 if (!$avatar_cache{$email}) {
2201 my ($user, $domain) = split('@', $email);
2202 $avatar_cache{$email} =
Andrej E Baranov57485582013-01-29 00:41:32 +0100[diff] [blame]2203 "//www.cs.indiana.edu/cgi-pub/kinzler/piconsearch.cgi/" .
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]2204 "$domain/$user/" .
2205 "users+domains+unknown/up/single";
2206 }
2207 return $avatar_cache{$email};
2208}
2209
Giuseppe Bilotta5a371b72009-06-30 00:00:52 +0200[diff] [blame]2210# Compute the gravatar url for a given email, if it's not in the cache already.
2211# Gravatar stores only the part of the URL before the size, since that's the
2212# one computationally more expensive. This also allows reuse of the cache for
2213# different sizes (for this particular engine).
2214sub gravatar_url {
2215 my $email = lc shift;
2216 my $size = shift;
2217 $avatar_cache{$email} ||=
Andrej E Baranov57485582013-01-29 00:41:32 +0100[diff] [blame]2218 "//www.gravatar.com/avatar/" .
Ævar Arnfjörð Bjarmason7d5b30e2018-03-03 15:38:08 +0000[diff] [blame]2219 md5_hex($email) . "?s=";
Giuseppe Bilotta5a371b72009-06-30 00:00:52 +0200[diff] [blame]2220 return $avatar_cache{$email} . $size;
2221}
2222
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]2223# Insert an avatar for the given $email at the given $size if the feature
2224# is enabled.
2225sub git_get_avatar {
2226 my ($email, %opts) = @_;
2227 my $pre_white = ($opts{-pad_before} ? "&nbsp;" : "");
2228 my $post_white = ($opts{-pad_after} ? "&nbsp;" : "");
2229 $opts{-size} ||= 'default';
2230 my $size = $avatar_size{$opts{-size}} || $avatar_size{'default'};
2231 my $url = "";
2232 if ($git_avatar eq 'gravatar') {
Giuseppe Bilotta5a371b72009-06-30 00:00:52 +0200[diff] [blame]2233 $url = gravatar_url($email, $size);
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]2234 } elsif ($git_avatar eq 'picon') {
2235 $url = picon_url($email);
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]2236 }
Giuseppe Bilotta679a1a12009-06-30 00:00:53 +0200[diff] [blame]2237 # Other providers can be added by extending the if chain, defining $url
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]2238 # as needed. If no variant puts something in $url, we assume avatars
2239 # are completely disabled/unavailable.
2240 if ($url) {
2241 return $pre_white .
2242 "<img width=\"$size\" " .
2243 "class=\"avatar\" " .
Jakub Narebski3017ed62010-12-15 00:34:01 +0100[diff] [blame]2244 "src=\"".esc_url($url)."\" " .
Giuseppe Bilotta7d25ef42009-06-30 00:00:54 +0200[diff] [blame]2245 "alt=\"\" " .
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]2246 "/>" . $post_white;
2247 } else {
2248 return "";
2249 }
2250}
2251
Stephen Boyde133d652009-10-15 21:14:59 -0700[diff] [blame]2252sub format_search_author {
2253 my ($author, $searchtype, $displaytext) = @_;
2254 my $have_search = gitweb_check_feature('search');
2255
2256 if ($have_search) {
2257 my $performed = "";
2258 if ($searchtype eq 'author') {
2259 $performed = "authored";
2260 } elsif ($searchtype eq 'committer') {
2261 $performed = "committed";
2262 }
2263
2264 return $cgi->a({-href => href(action=>"search", hash=>$hash,
2265 searchtext=>$author,
2266 searchtype=>$searchtype), class=>"list",
2267 title=>"Search for commits $performed by $author"},
2268 $displaytext);
2269
2270 } else {
2271 return $displaytext;
2272 }
2273}
2274
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]2275# format the author name of the given commit with the given tag
2276# the author name is chopped and escaped according to the other
2277# optional parameters (see chop_str).
2278sub format_author_html {
2279 my $tag = shift;
2280 my $co = shift;
2281 my $author = chop_and_escape_str($co->{'author_name'}, @_);
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]2282 return "<$tag class=\"author\">" .
Stephen Boyde133d652009-10-15 21:14:59 -0700[diff] [blame]2283 format_search_author($co->{'author_name'}, "author",
2284 git_get_avatar($co->{'author_email'}, -pad_after => 1) .
2285 $author) .
2286 "</$tag>";
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]2287}
2288
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]2289# format git diff header line, i.e. "diff --(git|combined|cc) ..."
2290sub format_git_diff_header_line {
2291 my $line = shift;
2292 my $diffinfo = shift;
2293 my ($from, $to) = @_;
2294
2295 if ($diffinfo->{'nparents'}) {
2296 # combined diff
2297 $line =~ s!^(diff (.*?) )"?.*$!$1!;
2298 if ($to->{'href'}) {
2299 $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
2300 esc_path($to->{'file'}));
2301 } else { # file was deleted (no href)
2302 $line .= esc_path($to->{'file'});
2303 }
2304 } else {
2305 # "ordinary" diff
2306 $line =~ s!^(diff (.*?) )"?a/.*$!$1!;
2307 if ($from->{'href'}) {
2308 $line .= $cgi->a({-href => $from->{'href'}, -class => "path"},
2309 'a/' . esc_path($from->{'file'}));
2310 } else { # file was added (no href)
2311 $line .= 'a/' . esc_path($from->{'file'});
2312 }
2313 $line .= ' ';
2314 if ($to->{'href'}) {
2315 $line .= $cgi->a({-href => $to->{'href'}, -class => "path"},
2316 'b/' . esc_path($to->{'file'}));
2317 } else { # file was deleted
2318 $line .= 'b/' . esc_path($to->{'file'});
2319 }
2320 }
2321
2322 return "<div class=\"diff header\">$line</div>\n";
2323}
2324
2325# format extended diff header line, before patch itself
2326sub format_extended_diff_header_line {
2327 my $line = shift;
2328 my $diffinfo = shift;
2329 my ($from, $to) = @_;
2330
2331 # match <path>
2332 if ($line =~ s!^((copy|rename) from ).*$!$1! && $from->{'href'}) {
2333 $line .= $cgi->a({-href=>$from->{'href'}, -class=>"path"},
2334 esc_path($from->{'file'}));
2335 }
2336 if ($line =~ s!^((copy|rename) to ).*$!$1! && $to->{'href'}) {
2337 $line .= $cgi->a({-href=>$to->{'href'}, -class=>"path"},
2338 esc_path($to->{'file'}));
2339 }
2340 # match single <mode>
2341 if ($line =~ m/\s(\d{6})$/) {
2342 $line .= '<span class="info"> (' .
2343 file_type_long($1) .
2344 ')</span>';
2345 }
2346 # match <hash>
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]2347 if ($line =~ oid_nlen_prefix_infix_regex($sha1_len, "index ", ",") |
2348 $line =~ oid_nlen_prefix_infix_regex($sha256_len, "index ", ",")) {
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]2349 # can match only for combined diff
2350 $line = 'index ';
2351 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2352 if ($from->{'href'}[$i]) {
2353 $line .= $cgi->a({-href=>$from->{'href'}[$i],
2354 -class=>"hash"},
2355 substr($diffinfo->{'from_id'}[$i],0,7));
2356 } else {
2357 $line .= '0' x 7;
2358 }
2359 # separator
2360 $line .= ',' if ($i < $diffinfo->{'nparents'} - 1);
2361 }
2362 $line .= '..';
2363 if ($to->{'href'}) {
2364 $line .= $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
2365 substr($diffinfo->{'to_id'},0,7));
2366 } else {
2367 $line .= '0' x 7;
2368 }
2369
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]2370 } elsif ($line =~ oid_nlen_prefix_infix_regex($sha1_len, "index ", "..") |
2371 $line =~ oid_nlen_prefix_infix_regex($sha256_len, "index ", "..")) {
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]2372 # can match only for ordinary diff
2373 my ($from_link, $to_link);
2374 if ($from->{'href'}) {
2375 $from_link = $cgi->a({-href=>$from->{'href'}, -class=>"hash"},
2376 substr($diffinfo->{'from_id'},0,7));
2377 } else {
2378 $from_link = '0' x 7;
2379 }
2380 if ($to->{'href'}) {
2381 $to_link = $cgi->a({-href=>$to->{'href'}, -class=>"hash"},
2382 substr($diffinfo->{'to_id'},0,7));
2383 } else {
2384 $to_link = '0' x 7;
2385 }
2386 my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
2387 $line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
2388 }
2389
2390 return $line . "<br/>\n";
2391}
2392
2393# format from-file/to-file diff header
2394sub format_diff_from_to_header {
Jakub Narebski91af4ce2007-06-08 13:32:44 +0200[diff] [blame]2395 my ($from_line, $to_line, $diffinfo, $from, $to, @parents) = @_;
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]2396 my $line;
2397 my $result = '';
2398
2399 $line = $from_line;
2400 #assert($line =~ m/^---/) if DEBUG;
Jakub Narebskideaa01a2007-06-08 13:29:49 +0200[diff] [blame]2401 # no extra formatting for "^--- /dev/null"
2402 if (! $diffinfo->{'nparents'}) {
2403 # ordinary (single parent) diff
2404 if ($line =~ m!^--- "?a/!) {
2405 if ($from->{'href'}) {
2406 $line = '--- a/' .
2407 $cgi->a({-href=>$from->{'href'}, -class=>"path"},
2408 esc_path($from->{'file'}));
2409 } else {
2410 $line = '--- a/' .
2411 esc_path($from->{'file'});
2412 }
2413 }
2414 $result .= qq!<div class="diff from_file">$line</div>\n!;
2415
2416 } else {
2417 # combined diff (merge commit)
2418 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
2419 if ($from->{'href'}[$i]) {
2420 $line = '--- ' .
Jakub Narebski91af4ce2007-06-08 13:32:44 +0200[diff] [blame]2421 $cgi->a({-href=>href(action=>"blobdiff",
2422 hash_parent=>$diffinfo->{'from_id'}[$i],
2423 hash_parent_base=>$parents[$i],
2424 file_parent=>$from->{'file'}[$i],
2425 hash=>$diffinfo->{'to_id'},
2426 hash_base=>$hash,
2427 file_name=>$to->{'file'}),
2428 -class=>"path",
2429 -title=>"diff" . ($i+1)},
2430 $i+1) .
2431 '/' .
Jakub Narebskideaa01a2007-06-08 13:29:49 +0200[diff] [blame]2432 $cgi->a({-href=>$from->{'href'}[$i], -class=>"path"},
2433 esc_path($from->{'file'}[$i]));
2434 } else {
2435 $line = '--- /dev/null';
2436 }
2437 $result .= qq!<div class="diff from_file">$line</div>\n!;
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]2438 }
2439 }
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]2440
2441 $line = $to_line;
2442 #assert($line =~ m/^\+\+\+/) if DEBUG;
2443 # no extra formatting for "^+++ /dev/null"
2444 if ($line =~ m!^\+\+\+ "?b/!) {
2445 if ($to->{'href'}) {
2446 $line = '+++ b/' .
2447 $cgi->a({-href=>$to->{'href'}, -class=>"path"},
2448 esc_path($to->{'file'}));
2449 } else {
2450 $line = '+++ b/' .
2451 esc_path($to->{'file'});
2452 }
2453 }
2454 $result .= qq!<div class="diff to_file">$line</div>\n!;
2455
2456 return $result;
2457}
2458
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]2459# create note for patch simplified by combined diff
2460sub format_diff_cc_simplified {
2461 my ($diffinfo, @parents) = @_;
2462 my $result = '';
2463
2464 $result .= "<div class=\"diff header\">" .
2465 "diff --cc ";
2466 if (!is_deleted($diffinfo)) {
2467 $result .= $cgi->a({-href => href(action=>"blob",
2468 hash_base=>$hash,
2469 hash=>$diffinfo->{'to_id'},
2470 file_name=>$diffinfo->{'to_file'}),
2471 -class => "path"},
2472 esc_path($diffinfo->{'to_file'}));
2473 } else {
2474 $result .= esc_path($diffinfo->{'to_file'});
2475 }
2476 $result .= "</div>\n" . # class="diff header"
2477 "<div class=\"diff nodifferences\">" .
2478 "Simple merge" .
2479 "</div>\n"; # class="diff nodifferences"
2480
2481 return $result;
2482}
2483
Jakub Narebski20a864c2011-10-31 00:36:20 +0100[diff] [blame]2484sub diff_line_class {
2485 my ($line, $from, $to) = @_;
2486
2487 # ordinary diff
2488 my $num_sign = 1;
2489 # combined diff
2490 if ($from && $to && ref($from->{'href'}) eq "ARRAY") {
2491 $num_sign = scalar @{$from->{'href'}};
2492 }
2493
2494 my @diff_line_classifier = (
2495 { regexp => qr/^\@\@{$num_sign} /, class => "chunk_header"},
2496 { regexp => qr/^\\/, class => "incomplete" },
2497 { regexp => qr/^ {$num_sign}/, class => "ctx" },
2498 # classifier for context must come before classifier add/rem,
2499 # or we would have to use more complicated regexp, for example
2500 # qr/(?= {0,$m}\+)[+ ]{$num_sign}/, where $m = $num_sign - 1;
2501 { regexp => qr/^[+ ]{$num_sign}/, class => "add" },
2502 { regexp => qr/^[- ]{$num_sign}/, class => "rem" },
2503 );
2504 for my $clsfy (@diff_line_classifier) {
2505 return $clsfy->{'class'}
2506 if ($line =~ $clsfy->{'regexp'});
2507 }
2508
2509 # fallback
2510 return "";
2511}
2512
Jakub Narebskif1310cf2011-10-31 00:36:21 +0100[diff] [blame]2513# assumes that $from and $to are defined and correctly filled,
2514# and that $line holds a line of chunk header for unified diff
2515sub format_unidiff_chunk_header {
2516 my ($line, $from, $to) = @_;
2517
2518 my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
2519 $line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
2520
2521 $from_lines = 0 unless defined $from_lines;
2522 $to_lines = 0 unless defined $to_lines;
2523
2524 if ($from->{'href'}) {
2525 $from_text = $cgi->a({-href=>"$from->{'href'}#l$from_start",
2526 -class=>"list"}, $from_text);
2527 }
2528 if ($to->{'href'}) {
2529 $to_text = $cgi->a({-href=>"$to->{'href'}#l$to_start",
2530 -class=>"list"}, $to_text);
2531 }
2532 $line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
2533 "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
2534 return $line;
2535}
2536
2537# assumes that $from and $to are defined and correctly filled,
2538# and that $line holds a line of chunk header for combined diff
2539sub format_cc_diff_chunk_header {
2540 my ($line, $from, $to) = @_;
2541
2542 my ($prefix, $ranges, $section) = $line =~ m/^(\@+) (.*?) \@+(.*)$/;
2543 my (@from_text, @from_start, @from_nlines, $to_text, $to_start, $to_nlines);
2544
2545 @from_text = split(' ', $ranges);
2546 for (my $i = 0; $i < @from_text; ++$i) {
2547 ($from_start[$i], $from_nlines[$i]) =
2548 (split(',', substr($from_text[$i], 1)), 0);
2549 }
2550
2551 $to_text = pop @from_text;
2552 $to_start = pop @from_start;
2553 $to_nlines = pop @from_nlines;
2554
2555 $line = "<span class=\"chunk_info\">$prefix ";
2556 for (my $i = 0; $i < @from_text; ++$i) {
2557 if ($from->{'href'}[$i]) {
2558 $line .= $cgi->a({-href=>"$from->{'href'}[$i]#l$from_start[$i]",
2559 -class=>"list"}, $from_text[$i]);
2560 } else {
2561 $line .= $from_text[$i];
2562 }
2563 $line .= " ";
2564 }
2565 if ($to->{'href'}) {
2566 $line .= $cgi->a({-href=>"$to->{'href'}#l$to_start",
2567 -class=>"list"}, $to_text);
2568 } else {
2569 $line .= $to_text;
2570 }
2571 $line .= " $prefix</span>" .
2572 "<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
2573 return $line;
2574}
2575
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]2576# process patch (diff) line (not to be used for diff headers),
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]2577# returning HTML-formatted (but not wrapped) line.
2578# If the line is passed as a reference, it is treated as HTML and not
2579# esc_html()'ed.
Michał Kiedrowiczf4a81022012-04-11 23:18:42 +0200[diff] [blame]2580sub format_diff_line {
2581 my ($line, $diff_class, $from, $to) = @_;
Jakub Narebski20a864c2011-10-31 00:36:20 +0100[diff] [blame]2582
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]2583 if (ref($line)) {
2584 $line = $$line;
Michał Kiedrowiczf4a81022012-04-11 23:18:42 +0200[diff] [blame]2585 } else {
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]2586 chomp $line;
2587 $line = untabify($line);
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]2588
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]2589 if ($from && $to && $line =~ m/^\@{2} /) {
2590 $line = format_unidiff_chunk_header($line, $from, $to);
2591 } elsif ($from && $to && $line =~ m/^\@{3}/) {
2592 $line = format_cc_diff_chunk_header($line, $from, $to);
2593 } else {
2594 $line = esc_html($line, -nbsp=>1);
2595 }
Jakub Narebski59e3b142006-11-18 23:35:40 +0100[diff] [blame]2596 }
Michał Kiedrowiczf4a81022012-04-11 23:18:42 +0200[diff] [blame]2597
2598 my $diff_classes = "diff";
2599 $diff_classes .= " $diff_class" if ($diff_class);
2600 $line = "<div class=\"$diff_classes\">$line</div>\n";
2601
2602 return $line;
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]2603}
2604
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]2605# Generates undef or something like "_snapshot_" or "snapshot (_tbz2_ _zip_)",
2606# linked. Pass the hash of the tree/commit to snapshot.
2607sub format_snapshot_links {
2608 my ($hash) = @_;
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]2609 my $num_fmts = @snapshot_fmts;
2610 if ($num_fmts > 1) {
2611 # A parenthesized list of links bearing format names.
Jakub Narebskia7817852007-07-22 23:41:20 +0200[diff] [blame]2612 # e.g. "snapshot (_tar.gz_ _zip_)"
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]2613 return "snapshot (" . join(' ', map
2614 $cgi->a({
2615 -href => href(
2616 action=>"snapshot",
2617 hash=>$hash,
2618 snapshot_format=>$_
2619 )
2620 }, $known_snapshot_formats{$_}{'display'})
2621 , @snapshot_fmts) . ")";
2622 } elsif ($num_fmts == 1) {
2623 # A single "snapshot" link whose tooltip bears the format name.
Jakub Narebskia7817852007-07-22 23:41:20 +0200[diff] [blame]2624 # i.e. "_snapshot_"
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]2625 my ($fmt) = @snapshot_fmts;
Jakub Narebskia7817852007-07-22 23:41:20 +0200[diff] [blame]2626 return
2627 $cgi->a({
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]2628 -href => href(
2629 action=>"snapshot",
2630 hash=>$hash,
2631 snapshot_format=>$fmt
2632 ),
2633 -title => "in format: $known_snapshot_formats{$fmt}{'display'}"
2634 }, "snapshot");
2635 } else { # $num_fmts == 0
2636 return undef;
2637 }
2638}
2639
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]2640## ......................................................................
2641## functions returning values to be passed, perhaps after some
2642## transformation, to other functions; e.g. returning arguments to href()
2643
2644# returns hash to be passed to href to generate gitweb URL
2645# in -title key it returns description of link
2646sub get_feed_info {
2647 my $format = shift || 'Atom';
2648 my %res = (action => lc($format));
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]2649 my $matched_ref = 0;
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]2650
2651 # feed links are possible only for project views
2652 return unless (defined $project);
2653 # some views should link to OPML, or to generic project feed,
2654 # or don't have specific feed yet (so they should use generic)
Jakub Narebski18ab83e2012-01-07 11:47:38 +0100[diff] [blame]2655 return if (!$action || $action =~ /^(?:tags|heads|forks|tag|search)$/x);
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]2656
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]2657 my $branch = undef;
2658 # branches refs uses 'refs/' + $get_branch_refs()[x] + '/' prefix
2659 # (fullname) to differentiate from tag links; this also makes
2660 # possible to detect branch links
2661 for my $ref (get_branch_refs()) {
2662 if ((defined $hash_base && $hash_base =~ m!^refs/\Q$ref\E/(.*)$!) ||
2663 (defined $hash && $hash =~ m!^refs/\Q$ref\E/(.*)$!)) {
2664 $branch = $1;
2665 $matched_ref = $ref;
2666 last;
2667 }
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]2668 }
2669 # find log type for feed description (title)
2670 my $type = 'log';
2671 if (defined $file_name) {
2672 $type = "history of $file_name";
2673 $type .= "/" if ($action eq 'tree');
2674 $type .= " on '$branch'" if (defined $branch);
2675 } else {
2676 $type = "log of $branch" if (defined $branch);
2677 }
2678
2679 $res{-title} = $type;
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]2680 $res{'hash'} = (defined $branch ? "refs/$matched_ref/$branch" : undef);
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]2681 $res{'file_name'} = $file_name;
2682
2683 return %res;
2684}
2685
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2686## ----------------------------------------------------------------------
2687## git utility subroutines, invoking git commands
2688
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2689# returns path to the core git executable and the --git-dir parameter as list
2690sub git_cmd {
Jakub Narebskiaa7dd052009-09-01 13:39:16 +0200[diff] [blame]2691 $number_of_git_cmds++;
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2692 return $GIT, '--git-dir='.$git_dir;
2693}
2694
Lea Wiemann516381d2008-06-17 23:46:35 +0200[diff] [blame]2695# quote the given arguments for passing them to the shell
2696# quote_command("command", "arg 1", "arg with ' and ! characters")
2697# => "'command' 'arg 1' 'arg with '\'' and '\!' characters'"
2698# Try to avoid using this function wherever possible.
2699sub quote_command {
2700 return join(' ',
Jakub Narebski68cedb12009-05-10 02:40:37 +0200[diff] [blame]2701 map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2702}
2703
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2704# get HEAD ref of given project as hash
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]2705sub git_get_head_hash {
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]2706 return git_get_full_hash(shift, 'HEAD');
2707}
2708
2709sub git_get_full_hash {
2710 return git_get_hash(@_);
2711}
2712
2713sub git_get_short_hash {
2714 return git_get_hash(@_, '--short=7');
2715}
2716
2717sub git_get_hash {
2718 my ($project, $hash, @options) = @_;
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2719 my $o_git_dir = $git_dir;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2720 my $retval = undef;
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2721 $git_dir = "$projectroot/$project";
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]2722 if (open my $fd, '-|', git_cmd(), 'rev-parse',
2723 '--verify', '-q', @options, $hash) {
2724 $retval = <$fd>;
2725 chomp $retval if defined $retval;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2726 close $fd;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2727 }
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2728 if (defined $o_git_dir) {
2729 $git_dir = $o_git_dir;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2730 }
2731 return $retval;
2732}
2733
2734# get type of given object
2735sub git_get_type {
2736 my $hash = shift;
2737
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2738 open my $fd, "-|", git_cmd(), "cat-file", '-t', $hash or return;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2739 my $type = <$fd>;
2740 close $fd or return;
2741 chomp $type;
2742 return $type;
2743}
2744
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2745# repository configuration
2746our $config_file = '';
2747our %config;
2748
2749# store multiple values for single key as anonymous array reference
2750# single values stored directly in the hash, not as [ <value> ]
2751sub hash_set_multi {
2752 my ($hash, $key, $value) = @_;
2753
2754 if (!exists $hash->{$key}) {
2755 $hash->{$key} = $value;
2756 } elsif (!ref $hash->{$key}) {
2757 $hash->{$key} = [ $hash->{$key}, $value ];
2758 } else {
2759 push @{$hash->{$key}}, $value;
2760 }
2761}
2762
2763# return hash of git project configuration
2764# optionally limited to some section, e.g. 'gitweb'
2765sub git_parse_project_config {
2766 my $section_regexp = shift;
2767 my %config;
2768
2769 local $/ = "\0";
2770
2771 open my $fh, "-|", git_cmd(), "config", '-z', '-l',
2772 or return;
2773
2774 while (my $keyval = <$fh>) {
2775 chomp $keyval;
2776 my ($key, $value) = split(/\n/, $keyval, 2);
2777
2778 hash_set_multi(\%config, $key, $value)
2779 if (!defined $section_regexp || $key =~ /^(?:$section_regexp)\./o);
2780 }
2781 close $fh;
2782
2783 return %config;
2784}
2785
Marcel M. Carydf5d10a2009-02-18 14:09:41 +0100[diff] [blame]2786# convert config value to boolean: 'true' or 'false'
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2787# no value, number > 0, 'true' and 'yes' values are true
2788# rest of values are treated as false (never as error)
2789sub config_to_bool {
2790 my $val = shift;
2791
Marcel M. Carydf5d10a2009-02-18 14:09:41 +0100[diff] [blame]2792 return 1 if !defined $val; # section.key
2793
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2794 # strip leading and trailing whitespace
2795 $val =~ s/^\s+//;
2796 $val =~ s/\s+$//;
2797
Marcel M. Carydf5d10a2009-02-18 14:09:41 +0100[diff] [blame]2798 return (($val =~ /^\d+$/ && $val) || # section.key = 1
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2799 ($val =~ /^(?:true|yes)$/i)); # section.key = true
2800}
2801
2802# convert config value to simple decimal number
2803# an optional value suffix of 'k', 'm', or 'g' will cause the value
2804# to be multiplied by 1024, 1048576, or 1073741824
2805sub config_to_int {
2806 my $val = shift;
2807
2808 # strip leading and trailing whitespace
2809 $val =~ s/^\s+//;
2810 $val =~ s/\s+$//;
2811
2812 if (my ($num, $unit) = ($val =~ /^([0-9]*)([kmg])$/i)) {
2813 $unit = lc($unit);
2814 # unknown unit is treated as 1
2815 return $num * ($unit eq 'g' ? 1073741824 :
2816 $unit eq 'm' ? 1048576 :
2817 $unit eq 'k' ? 1024 : 1);
2818 }
2819 return $val;
2820}
2821
2822# convert config value to array reference, if needed
2823sub config_to_multi {
2824 my $val = shift;
2825
Jakub Narebskid76a5852007-12-20 10:48:09 +0100[diff] [blame]2826 return ref($val) ? $val : (defined($val) ? [ $val ] : []);
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2827}
2828
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2829sub git_get_project_config {
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]2830 my ($key, $type) = @_;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2831
Jakub Narebski7a49c252010-03-27 20:26:59 +0100[diff] [blame]2832 return unless defined $git_dir;
Jakub Narebski9be36142010-03-01 22:51:34 +0100[diff] [blame]2833
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2834 # key sanity check
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2835 return unless ($key);
Jakub Narebski14569cd2011-07-28 23:38:03 +0200[diff] [blame]2836 # only subsection, if exists, is case sensitive,
2837 # and not lowercased by 'git config -z -l'
2838 if (my ($hi, $mi, $lo) = ($key =~ /^([^.]*)\.(.*)\.([^.]*)$/)) {
Phil Pennockaf507942012-11-05 18:50:47 -0500[diff] [blame]2839 $lo =~ s/_//g;
Jakub Narebski14569cd2011-07-28 23:38:03 +0200[diff] [blame]2840 $key = join(".", lc($hi), $mi, lc($lo));
Phil Pennockaf507942012-11-05 18:50:47 -0500[diff] [blame]2841 return if ($lo =~ /\W/ || $hi =~ /\W/);
Jakub Narebski14569cd2011-07-28 23:38:03 +0200[diff] [blame]2842 } else {
2843 $key = lc($key);
Phil Pennockaf507942012-11-05 18:50:47 -0500[diff] [blame]2844 $key =~ s/_//g;
2845 return if ($key =~ /\W/);
Jakub Narebski14569cd2011-07-28 23:38:03 +0200[diff] [blame]2846 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2847 $key =~ s/^gitweb\.//;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2848
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2849 # type sanity check
2850 if (defined $type) {
2851 $type =~ s/^--//;
2852 $type = undef
2853 unless ($type eq 'bool' || $type eq 'int');
2854 }
2855
2856 # get config
2857 if (!defined $config_file ||
2858 $config_file ne "$git_dir/config") {
2859 %config = git_parse_project_config('gitweb');
2860 $config_file = "$git_dir/config";
2861 }
2862
Marcel M. Carydf5d10a2009-02-18 14:09:41 +0100[diff] [blame]2863 # check if config variable (key) exists
2864 return unless exists $config{"gitweb.$key"};
2865
Jakub Narebskib2019272007-11-03 00:41:19 +0100[diff] [blame]2866 # ensure given type
2867 if (!defined $type) {
2868 return $config{"gitweb.$key"};
2869 } elsif ($type eq 'bool') {
2870 # backward compatibility: 'git config --bool' returns true/false
2871 return config_to_bool($config{"gitweb.$key"}) ? 'true' : 'false';
2872 } elsif ($type eq 'int') {
2873 return config_to_int($config{"gitweb.$key"});
2874 }
2875 return $config{"gitweb.$key"};
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2876}
2877
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2878# get hash of given path at given ref
2879sub git_get_hash_by_path {
2880 my $base = shift;
2881 my $path = shift || return undef;
Jakub Narebski1d782b02006-09-21 18:09:12 +0200[diff] [blame]2882 my $type = shift;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2883
Jakub Narebski4b02f482006-09-26 01:54:24 +0200[diff] [blame]2884 $path =~ s,/+$,,;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2885
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]2886 open my $fd, "-|", git_cmd(), "ls-tree", $base, "--", $path
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]2887 or die_error(500, "Open git-ls-tree failed");
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2888 my $line = <$fd>;
2889 close $fd or return undef;
2890
Jakub Narebski198a2a82007-05-12 21:16:34 +0200[diff] [blame]2891 if (!defined $line) {
2892 # there is no tree or hash given by $path at $base
2893 return undef;
2894 }
2895
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2896 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]2897 $line =~ m/^([0-9]+) (.+) ($oid_regex)\t/;
Jakub Narebski1d782b02006-09-21 18:09:12 +0200[diff] [blame]2898 if (defined $type && $type ne $2) {
2899 # type doesn't match
2900 return undef;
2901 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2902 return $3;
2903}
2904
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]2905# get path of entry with given hash at given tree-ish (ref)
2906# used to get 'from' filename for combined diff (merge commit) for renames
2907sub git_get_path_by_hash {
2908 my $base = shift || return;
2909 my $hash = shift || return;
2910
2911 local $/ = "\0";
2912
2913 open my $fd, "-|", git_cmd(), "ls-tree", '-r', '-t', '-z', $base
2914 or return undef;
2915 while (my $line = <$fd>) {
2916 chomp $line;
2917
2918 #'040000 tree 595596a6a9117ddba9fe379b6b012b558bac8423 gitweb'
2919 #'100644 blob e02e90f0429be0d2a69b76571101f20b8f75530f gitweb/README'
2920 if ($line =~ m/(?:[0-9]+) (?:.+) $hash\t(.+)$/) {
2921 close $fd;
2922 return $1;
2923 }
2924 }
2925 close $fd;
2926 return undef;
2927}
2928
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2929## ......................................................................
2930## git utility functions, directly accessing git repository
2931
Sebastien Ceveye4e3b322011-04-29 19:52:00 +0200[diff] [blame]2932# get the value of config variable either from file named as the variable
2933# itself in the repository ($GIT_DIR/$name file), or from gitweb.$name
2934# configuration variable in the repository config file.
2935sub git_get_file_or_project_config {
2936 my ($path, $name) = @_;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2937
Jakub Narebski0e121a22007-11-03 00:41:20 +0100[diff] [blame]2938 $git_dir = "$projectroot/$path";
Sebastien Ceveye4e3b322011-04-29 19:52:00 +0200[diff] [blame]2939 open my $fd, '<', "$git_dir/$name"
2940 or return git_get_project_config($name);
2941 my $conf = <$fd>;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2942 close $fd;
Sebastien Ceveye4e3b322011-04-29 19:52:00 +0200[diff] [blame]2943 if (defined $conf) {
2944 chomp $conf;
Junio C Hamano2eb54ef2007-05-16 21:04:16 -0700[diff] [blame]2945 }
Sebastien Ceveye4e3b322011-04-29 19:52:00 +0200[diff] [blame]2946 return $conf;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2947}
2948
Sebastien Ceveye4e3b322011-04-29 19:52:00 +0200[diff] [blame]2949sub git_get_project_description {
2950 my $path = shift;
2951 return git_get_file_or_project_config($path, 'description');
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]2952}
2953
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]2954sub git_get_project_category {
2955 my $path = shift;
2956 return git_get_file_or_project_config($path, 'category');
2957}
2958
2959
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]2960# supported formats:
2961# * $GIT_DIR/ctags/<tagname> file (in 'ctags' subdirectory)
2962# - if its contents is a number, use it as tag weight,
2963# - otherwise add a tag with weight 1
2964# * $GIT_DIR/ctags file, each line is a tag (with weight 1)
2965# the same value multiple times increases tag weight
2966# * `gitweb.ctag' multi-valued repo config variable
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]2967sub git_get_project_ctags {
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]2968 my $project = shift;
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]2969 my $ctags = {};
2970
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]2971 $git_dir = "$projectroot/$project";
2972 if (opendir my $dh, "$git_dir/ctags") {
2973 my @files = grep { -f $_ } map { "$git_dir/ctags/$_" } readdir($dh);
2974 foreach my $tagfile (@files) {
2975 open my $ct, '<', $tagfile
2976 or next;
2977 my $val = <$ct>;
2978 chomp $val if $val;
2979 close $ct;
2980
2981 (my $ctag = $tagfile) =~ s#.*/##;
Jonathan Nieder2c162b52011-06-09 02:08:57 -0500[diff] [blame]2982 if ($val =~ /^\d+$/) {
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]2983 $ctags->{$ctag} = $val;
2984 } else {
2985 $ctags->{$ctag} = 1;
2986 }
2987 }
2988 closedir $dh;
2989
2990 } elsif (open my $fh, '<', "$git_dir/ctags") {
2991 while (my $line = <$fh>) {
2992 chomp $line;
2993 $ctags->{$line}++ if $line;
2994 }
2995 close $fh;
2996
2997 } else {
2998 my $taglist = config_to_multi(git_get_project_config('ctag'));
2999 foreach my $tag (@$taglist) {
3000 $ctags->{$tag}++;
3001 }
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3002 }
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3003
3004 return $ctags;
3005}
3006
3007# return hash, where keys are content tags ('ctags'),
3008# and values are sum of weights of given tag in every project
3009sub git_gather_all_ctags {
3010 my $projects = shift;
3011 my $ctags = {};
3012
3013 foreach my $p (@$projects) {
3014 foreach my $ct (keys %{$p->{'ctags'}}) {
3015 $ctags->{$ct} += $p->{'ctags'}->{$ct};
3016 }
3017 }
3018
3019 return $ctags;
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3020}
3021
3022sub git_populate_project_tagcloud {
3023 my $ctags = shift;
3024
3025 # First, merge different-cased tags; tags vote on casing
3026 my %ctags_lc;
3027 foreach (keys %$ctags) {
3028 $ctags_lc{lc $_}->{count} += $ctags->{$_};
3029 if (not $ctags_lc{lc $_}->{topcount}
3030 or $ctags_lc{lc $_}->{topcount} < $ctags->{$_}) {
3031 $ctags_lc{lc $_}->{topcount} = $ctags->{$_};
3032 $ctags_lc{lc $_}->{topname} = $_;
3033 }
3034 }
3035
3036 my $cloud;
Jakub Narebski84d9e2d2012-02-03 13:44:54 +0100[diff] [blame]3037 my $matched = $input_params{'ctag'};
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3038 if (eval { require HTML::TagCloud; 1; }) {
3039 $cloud = HTML::TagCloud->new;
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3040 foreach my $ctag (sort keys %ctags_lc) {
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3041 # Pad the title with spaces so that the cloud looks
3042 # less crammed.
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3043 my $title = esc_html($ctags_lc{$ctag}->{topname});
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3044 $title =~ s/ /&nbsp;/g;
3045 $title =~ s/^/&nbsp;/g;
3046 $title =~ s/$/&nbsp;/g;
Jakub Narebski4b9447f2011-04-29 19:51:58 +0200[diff] [blame]3047 if (defined $matched && $matched eq $ctag) {
3048 $title = qq(<span class="match">$title</span>);
3049 }
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3050 $cloud->add($title, href(project=>undef, ctag=>$ctag),
3051 $ctags_lc{$ctag}->{count});
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3052 }
3053 } else {
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3054 $cloud = {};
3055 foreach my $ctag (keys %ctags_lc) {
Jakub Narebski4b9447f2011-04-29 19:51:58 +0200[diff] [blame]3056 my $title = esc_html($ctags_lc{$ctag}->{topname}, -nbsp=>1);
3057 if (defined $matched && $matched eq $ctag) {
3058 $title = qq(<span class="match">$title</span>);
3059 }
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3060 $cloud->{$ctag}{count} = $ctags_lc{$ctag}->{count};
3061 $cloud->{$ctag}{ctag} =
Jakub Narebski4b9447f2011-04-29 19:51:58 +0200[diff] [blame]3062 $cgi->a({-href=>href(project=>undef, ctag=>$ctag)}, $title);
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3063 }
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3064 }
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3065 return $cloud;
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3066}
3067
3068sub git_show_project_tagcloud {
3069 my ($cloud, $count) = @_;
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3070 if (ref $cloud eq 'HTML::TagCloud') {
3071 return $cloud->html_and_css($count);
3072 } else {
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]3073 my @tags = sort { $cloud->{$a}->{'count'} <=> $cloud->{$b}->{'count'} } keys %$cloud;
3074 return
3075 '<div id="htmltagcloud"'.($project ? '' : ' align="center"').'>' .
3076 join (', ', map {
3077 $cloud->{$_}->{'ctag'}
3078 } splice(@tags, 0, $count)) .
3079 '</div>';
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]3080 }
3081}
3082
Jakub Narebskie79ca7c2006-08-16 14:50:34 +0200[diff] [blame]3083sub git_get_project_url_list {
3084 my $path = shift;
3085
Jakub Narebski0e121a22007-11-03 00:41:20 +0100[diff] [blame]3086 $git_dir = "$projectroot/$path";
Jakub Narebskidff2b6d2009-05-10 02:38:34 +0200[diff] [blame]3087 open my $fd, '<', "$git_dir/cloneurl"
Jakub Narebski0e121a22007-11-03 00:41:20 +0100[diff] [blame]3088 or return wantarray ?
3089 @{ config_to_multi(git_get_project_config('url')) } :
3090 config_to_multi(git_get_project_config('url'));
Jakub Narebskie79ca7c2006-08-16 14:50:34 +0200[diff] [blame]3091 my @git_project_url_list = map { chomp; $_ } <$fd>;
3092 close $fd;
3093
3094 return wantarray ? @git_project_url_list : \@git_project_url_list;
3095}
3096
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]3097sub git_get_projects_list {
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3098 my $filter = shift || '';
Bernhard R. Link348a6582012-01-30 21:06:38 +0100[diff] [blame]3099 my $paranoid = shift;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3100 my @list;
3101
3102 if (-d $projects_list) {
3103 # search in directory
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3104 my $dir = $projects_list;
Aneesh Kumar K.V6768d6b2006-11-03 10:41:45 +0530[diff] [blame]3105 # remove the trailing "/"
3106 $dir =~ s!/+$!!;
Matthieu Moyac593b72012-01-04 11:07:45 +0100[diff] [blame]3107 my $pfxlen = length("$dir");
3108 my $pfxdepth = ($dir =~ tr!/!!);
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3109 # when filtering, search only given subdirectory
Bernhard R. Link348a6582012-01-30 21:06:38 +0100[diff] [blame]3110 if ($filter && !$paranoid) {
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3111 $dir .= "/$filter";
3112 $dir =~ s!/+$!!;
3113 }
Jakub Narebskic0011ff2006-09-14 22:18:59 +0200[diff] [blame]3114
3115 File::Find::find({
3116 follow_fast => 1, # follow symbolic links
Junio C Hamanod20602e2007-07-27 01:23:03 -0700[diff] [blame]3117 follow_skip => 2, # ignore duplicates
Jakub Narebskic0011ff2006-09-14 22:18:59 +0200[diff] [blame]3118 dangling_symlinks => 0, # ignore dangling symlinks, silently
3119 wanted => sub {
Jakub Narebskiee1d8ee2010-04-30 18:30:31 +0200[diff] [blame]3120 # global variables
3121 our $project_maxdepth;
3122 our $projectroot;
Jakub Narebskic0011ff2006-09-14 22:18:59 +0200[diff] [blame]3123 # skip project-list toplevel, if we get it.
3124 return if (m!^[/.]$!);
3125 # only directories can be git repositories
3126 return unless (-d $_);
Hielke Christian Braun46a13852017-07-18 10:41:54 +0200[diff] [blame]3127 # need search permission
3128 return unless (-x $_);
Luke Luca5e9492007-10-16 20:45:25 -0700[diff] [blame]3129 # don't traverse too deep (Find is super slow on os x)
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3130 # $project_maxdepth excludes depth of $projectroot
Luke Luca5e9492007-10-16 20:45:25 -0700[diff] [blame]3131 if (($File::Find::name =~ tr!/!!) - $pfxdepth > $project_maxdepth) {
3132 $File::Find::prune = 1;
3133 return;
3134 }
Jakub Narebskic0011ff2006-09-14 22:18:59 +0200[diff] [blame]3135
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3136 my $path = substr($File::Find::name, $pfxlen + 1);
Bernhard R. Link348a6582012-01-30 21:06:38 +0100[diff] [blame]3137 # paranoidly only filter here
3138 if ($paranoid && $filter && $path !~ m!^\Q$filter\E/!) {
3139 next;
3140 }
Jakub Narebskic0011ff2006-09-14 22:18:59 +0200[diff] [blame]3141 # we check related file in $projectroot
Devin Doucettefb3bb3d2008-12-27 02:39:31 -0700[diff] [blame]3142 if (check_export_ok("$projectroot/$path")) {
3143 push @list, { path => $path };
Jakub Narebskic0011ff2006-09-14 22:18:59 +0200[diff] [blame]3144 $File::Find::prune = 1;
3145 }
3146 },
3147 }, "$dir");
3148
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3149 } elsif (-f $projects_list) {
3150 # read from file(url-encoded):
3151 # 'git%2Fgit.git Linus+Torvalds'
3152 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
3153 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
Jakub Narebskidff2b6d2009-05-10 02:38:34 +0200[diff] [blame]3154 open my $fd, '<', $projects_list or return;
Frank Lichtenheldc2b8b132007-04-06 23:58:11 +0200[diff] [blame]3155 PROJECT:
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3156 while (my $line = <$fd>) {
3157 chomp $line;
3158 my ($path, $owner) = split ' ', $line;
3159 $path = unescape($path);
3160 $owner = unescape($owner);
3161 if (!defined $path) {
3162 next;
3163 }
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3164 # if $filter is rpovided, check if $path begins with $filter
3165 if ($filter && $path !~ m!^\Q$filter\E/!) {
3166 next;
Junio C Hamano83ee94c2006-11-07 22:37:17 -0800[diff] [blame]3167 }
Junio C Hamano2172ce42006-10-03 02:30:47 -0700[diff] [blame]3168 if (check_export_ok("$projectroot/$path")) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3169 my $pr = {
Kacper Kornet75e0dff2012-04-24 19:50:05 +0200[diff] [blame]3170 path => $path
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3171 };
Kacper Kornet75e0dff2012-04-24 19:50:05 +0200[diff] [blame]3172 if ($owner) {
3173 $pr->{'owner'} = to_utf8($owner);
3174 }
Frank Lichtenheldc2b8b132007-04-06 23:58:11 +0200[diff] [blame]3175 push @list, $pr;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3176 }
3177 }
3178 close $fd;
3179 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3180 return @list;
3181}
3182
Ville Skyttä64127572017-06-25 13:20:41 +0300[diff] [blame]3183# written with help of Tree::Trie module (Perl Artistic License, GPL compatible)
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3184# as side effects it sets 'forks' field to list of forks for forked projects
3185sub filter_forks_from_projects_list {
3186 my $projects = shift;
3187
3188 my %trie; # prefix tree of directories (path components)
3189 # generate trie out of those directories that might contain forks
3190 foreach my $pr (@$projects) {
3191 my $path = $pr->{'path'};
3192 $path =~ s/\.git$//; # forks of 'repo.git' are in 'repo/' directory
3193 next if ($path =~ m!/$!); # skip non-bare repositories, e.g. 'repo/.git'
3194 next unless ($path); # skip '.git' repository: tests, git-instaweb
Julien Muchembled53c632f2011-10-21 21:04:21 +0200[diff] [blame]3195 next unless (-d "$projectroot/$path"); # containing directory exists
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3196 $pr->{'forks'} = []; # there can be 0 or more forks of project
3197
3198 # add to trie
3199 my @dirs = split('/', $path);
3200 # walk the trie, until either runs out of components or out of trie
3201 my $ref = \%trie;
3202 while (scalar @dirs &&
3203 exists($ref->{$dirs[0]})) {
3204 $ref = $ref->{shift @dirs};
3205 }
3206 # create rest of trie structure from rest of components
3207 foreach my $dir (@dirs) {
3208 $ref = $ref->{$dir} = {};
3209 }
3210 # create end marker, store $pr as a data
3211 $ref->{''} = $pr if (!exists $ref->{''});
3212 }
3213
3214 # filter out forks, by finding shortest prefix match for paths
3215 my @filtered;
3216 PROJECT:
3217 foreach my $pr (@$projects) {
3218 # trie lookup
3219 my $ref = \%trie;
3220 DIR:
3221 foreach my $dir (split('/', $pr->{'path'})) {
3222 if (exists $ref->{''}) {
3223 # found [shortest] prefix, is a fork - skip it
3224 push @{$ref->{''}{'forks'}}, $pr;
3225 next PROJECT;
3226 }
3227 if (!exists $ref->{$dir}) {
3228 # not in trie, cannot have prefix, not a fork
3229 push @filtered, $pr;
3230 next PROJECT;
3231 }
3232 # If the dir is there, we just walk one step down the trie.
3233 $ref = $ref->{$dir};
3234 }
3235 # we ran out of trie
3236 # (shouldn't happen: it's either no match, or end marker)
3237 push @filtered, $pr;
3238 }
3239
3240 return @filtered;
3241}
3242
3243# note: fill_project_list_info must be run first,
3244# for 'descr_long' and 'ctags' to be filled
3245sub search_projects_list {
3246 my ($projlist, %opts) = @_;
3247 my $tagfilter = $opts{'tagfilter'};
Jakub Narebskie65ceb62012-03-02 23:34:24 +0100[diff] [blame]3248 my $search_re = $opts{'search_regexp'};
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3249
3250 return @$projlist
Jakub Narebskie65ceb62012-03-02 23:34:24 +0100[diff] [blame]3251 unless ($tagfilter || $search_re);
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3252
Jakub Narebski07b257f2012-02-23 16:54:48 +0100[diff] [blame]3253 # searching projects require filling to be run before it;
3254 fill_project_list_info($projlist,
3255 $tagfilter ? 'ctags' : (),
Junio C Hamanoaa145bf2012-03-08 13:04:49 -0800[diff] [blame]3256 $search_re ? ('path', 'descr') : ());
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3257 my @projects;
3258 PROJECT:
3259 foreach my $pr (@$projlist) {
3260
3261 if ($tagfilter) {
3262 next unless ref($pr->{'ctags'}) eq 'HASH';
3263 next unless
3264 grep { lc($_) eq lc($tagfilter) } keys %{$pr->{'ctags'}};
3265 }
3266
Jakub Narebskie65ceb62012-03-02 23:34:24 +0100[diff] [blame]3267 if ($search_re) {
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3268 next unless
Jakub Narebskie65ceb62012-03-02 23:34:24 +0100[diff] [blame]3269 $pr->{'path'} =~ /$search_re/ ||
3270 $pr->{'descr_long'} =~ /$search_re/;
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]3271 }
3272
3273 push @projects, $pr;
3274 }
3275
3276 return @projects;
3277}
3278
Junio C Hamano47852452007-07-03 22:10:42 -0700[diff] [blame]3279our $gitweb_project_owner = undef;
3280sub git_get_project_list_from_file {
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]3281
Junio C Hamano47852452007-07-03 22:10:42 -0700[diff] [blame]3282 return if (defined $gitweb_project_owner);
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]3283
Junio C Hamano47852452007-07-03 22:10:42 -0700[diff] [blame]3284 $gitweb_project_owner = {};
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]3285 # read from file (url-encoded):
3286 # 'git%2Fgit.git Linus+Torvalds'
3287 # 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
3288 # 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
3289 if (-f $projects_list) {
Jakub Narebskidff2b6d2009-05-10 02:38:34 +0200[diff] [blame]3290 open(my $fd, '<', $projects_list);
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]3291 while (my $line = <$fd>) {
3292 chomp $line;
3293 my ($pr, $ow) = split ' ', $line;
3294 $pr = unescape($pr);
3295 $ow = unescape($ow);
Junio C Hamano47852452007-07-03 22:10:42 -0700[diff] [blame]3296 $gitweb_project_owner->{$pr} = to_utf8($ow);
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]3297 }
3298 close $fd;
3299 }
Junio C Hamano47852452007-07-03 22:10:42 -0700[diff] [blame]3300}
3301
3302sub git_get_project_owner {
3303 my $project = shift;
3304 my $owner;
3305
3306 return undef unless $project;
Bruno Ribasb59012e2008-02-08 14:38:04 -0200[diff] [blame]3307 $git_dir = "$projectroot/$project";
Junio C Hamano47852452007-07-03 22:10:42 -0700[diff] [blame]3308
3309 if (!defined $gitweb_project_owner) {
3310 git_get_project_list_from_file();
3311 }
3312
3313 if (exists $gitweb_project_owner->{$project}) {
3314 $owner = $gitweb_project_owner->{$project};
3315 }
Bruno Ribasb59012e2008-02-08 14:38:04 -0200[diff] [blame]3316 if (!defined $owner){
3317 $owner = git_get_project_config('owner');
3318 }
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]3319 if (!defined $owner) {
Bruno Ribasb59012e2008-02-08 14:38:04 -0200[diff] [blame]3320 $owner = get_file_owner("$git_dir");
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]3321 }
3322
3323 return $owner;
3324}
3325
Jakub Narebskic60c56c2006-10-28 19:43:40 +0200[diff] [blame]3326sub git_get_last_activity {
3327 my ($path) = @_;
3328 my $fd;
3329
3330 $git_dir = "$projectroot/$path";
3331 open($fd, "-|", git_cmd(), 'for-each-ref',
Robert Fitzsimons0ff5ec72006-12-22 19:38:13 +0000[diff] [blame]3332 '--format=%(committer)',
Jakub Narebskic60c56c2006-10-28 19:43:40 +0200[diff] [blame]3333 '--sort=-committerdate',
Robert Fitzsimons0ff5ec72006-12-22 19:38:13 +0000[diff] [blame]3334 '--count=1',
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]3335 map { "refs/$_" } get_branch_refs ()) or return;
Jakub Narebskic60c56c2006-10-28 19:43:40 +0200[diff] [blame]3336 my $most_recent = <$fd>;
3337 close $fd or return;
Jakub Narebski785cdea2007-05-13 12:39:22 +0200[diff] [blame]3338 if (defined $most_recent &&
3339 $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
Jakub Narebskic60c56c2006-10-28 19:43:40 +0200[diff] [blame]3340 my $timestamp = $1;
3341 my $age = time - $timestamp;
3342 return ($age, age_string($age));
3343 }
Matt McCutchenc9563952007-06-28 18:15:22 -0400[diff] [blame]3344 return (undef, undef);
Jakub Narebskic60c56c2006-10-28 19:43:40 +0200[diff] [blame]3345}
3346
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]3347# Implementation note: when a single remote is wanted, we cannot use 'git
3348# remote show -n' because that command always work (assuming it's a remote URL
3349# if it's not defined), and we cannot use 'git remote show' because that would
3350# try to make a network roundtrip. So the only way to find if that particular
3351# remote is defined is to walk the list provided by 'git remote -v' and stop if
3352# and when we find what we want.
3353sub git_get_remotes_list {
3354 my $wanted = shift;
3355 my %remotes = ();
3356
3357 open my $fd, '-|' , git_cmd(), 'remote', '-v';
3358 return unless $fd;
3359 while (my $remote = <$fd>) {
3360 chomp $remote;
3361 $remote =~ s!\t(.*?)\s+\((\w+)\)$!!;
3362 next if $wanted and not $remote eq $wanted;
3363 my ($url, $key) = ($1, $2);
3364
3365 $remotes{$remote} ||= { 'heads' => () };
3366 $remotes{$remote}{$key} = $url;
3367 }
3368 close $fd or return;
3369 return wantarray ? %remotes : \%remotes;
3370}
3371
3372# Takes a hash of remotes as first parameter and fills it by adding the
3373# available remote heads for each of the indicated remotes.
3374sub fill_remote_heads {
3375 my $remotes = shift;
3376 my @heads = map { "remotes/$_" } keys %$remotes;
3377 my @remoteheads = git_get_heads_list(undef, @heads);
3378 foreach my $remote (keys %$remotes) {
3379 $remotes->{$remote}{'heads'} = [ grep {
3380 $_->{'name'} =~ s!^$remote/!!
3381 } @remoteheads ];
3382 }
3383}
3384
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]3385sub git_get_references {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3386 my $type = shift || "";
3387 my %refs;
Jakub Narebski28b9d9f2006-11-25 11:32:08 +0100[diff] [blame]3388 # 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
3389 # c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
3390 open my $fd, "-|", git_cmd(), "show-ref", "--dereference",
3391 ($type ? ("--", "refs/$type") : ()) # use -- <pattern> if $type
Jakub Narebski9704d752006-09-19 14:31:49 +0200[diff] [blame]3392 or return;
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]3393
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3394 while (my $line = <$fd>) {
3395 chomp $line;
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3396 if ($line =~ m!^($oid_regex)\srefs/($type.*)$!) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3397 if (defined $refs{$1}) {
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]3398 push @{$refs{$1}}, $2;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3399 } else {
Jakub Narebskid294e1c2006-08-14 02:14:20 +0200[diff] [blame]3400 $refs{$1} = [ $2 ];
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3401 }
3402 }
3403 }
3404 close $fd or return;
3405 return \%refs;
3406}
3407
Jakub Narebski56a322f2006-08-24 19:41:23 +0200[diff] [blame]3408sub git_get_rev_name_tags {
3409 my $hash = shift || return undef;
3410
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]3411 open my $fd, "-|", git_cmd(), "name-rev", "--tags", $hash
Jakub Narebski56a322f2006-08-24 19:41:23 +0200[diff] [blame]3412 or return;
3413 my $name_rev = <$fd>;
3414 close $fd;
3415
3416 if ($name_rev =~ m|^$hash tags/(.*)$|) {
3417 return $1;
3418 } else {
3419 # catches also '$hash undefined' output
3420 return undef;
3421 }
3422}
3423
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3424## ----------------------------------------------------------------------
3425## parse to hash functions
3426
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]3427sub parse_date {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3428 my $epoch = shift;
3429 my $tz = shift || "-0000";
3430
3431 my %date;
3432 my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
3433 my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
3434 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
3435 $date{'hour'} = $hour;
3436 $date{'minute'} = $min;
3437 $date{'mday'} = $mday;
3438 $date{'day'} = $days[$wday];
3439 $date{'month'} = $months[$mon];
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]3440 $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
3441 $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]3442 $date{'mday-time'} = sprintf "%d %s %02d:%02d",
3443 $mday, $months[$mon], $hour ,$min;
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]3444 $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
Vincent Zanottia62d6d82007-11-10 19:55:27 +0100[diff] [blame]3445 1900+$year, 1+$mon, $mday, $hour ,$min, $sec;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3446
Jakub Narebski2b1e1722011-03-25 20:20:49 +0100[diff] [blame]3447 my ($tz_sign, $tz_hour, $tz_min) =
3448 ($tz =~ m/^([-+])(\d\d)(\d\d)$/);
3449 $tz_sign = ($tz_sign eq '-' ? -1 : +1);
3450 my $local = $epoch + $tz_sign*((($tz_hour*60) + $tz_min)*60);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3451 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
3452 $date{'hour_local'} = $hour;
3453 $date{'minute_local'} = $min;
3454 $date{'tz_local'} = $tz;
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]3455 $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
3456 1900+$year, $mon+1, $mday,
3457 $hour, $min, $sec, $tz);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3458 return %date;
3459}
3460
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]3461sub hide_mailaddrs_if_private {
3462 my $line = shift;
3463 return $line unless gitweb_check_feature('email-privacy');
3464 $line =~ s/<[^@>]+@[^>]+>/<redacted>/g;
3465 return $line;
3466}
3467
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]3468sub parse_tag {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3469 my $tag_id = shift;
3470 my %tag;
3471 my @comment;
3472
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]3473 open my $fd, "-|", git_cmd(), "cat-file", "tag", $tag_id or return;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3474 $tag{'id'} = $tag_id;
3475 while (my $line = <$fd>) {
3476 chomp $line;
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3477 if ($line =~ m/^object ($oid_regex)$/) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3478 $tag{'object'} = $1;
3479 } elsif ($line =~ m/^type (.+)$/) {
3480 $tag{'type'} = $1;
3481 } elsif ($line =~ m/^tag (.+)$/) {
3482 $tag{'name'} = $1;
3483 } elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]3484 $tag{'author'} = hide_mailaddrs_if_private($1);
Giuseppe Bilottaba924732009-06-30 00:00:50 +0200[diff] [blame]3485 $tag{'author_epoch'} = $2;
3486 $tag{'author_tz'} = $3;
3487 if ($tag{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3488 $tag{'author_name'} = $1;
3489 $tag{'author_email'} = $2;
3490 } else {
3491 $tag{'author_name'} = $tag{'author'};
3492 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3493 } elsif ($line =~ m/--BEGIN/) {
3494 push @comment, $line;
3495 last;
3496 } elsif ($line eq "") {
3497 last;
3498 }
3499 }
3500 push @comment, <$fd>;
3501 $tag{'comment'} = \@comment;
3502 close $fd or return;
3503 if (!defined $tag{'name'}) {
3504 return
3505 };
3506 return %tag
3507}
3508
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3509sub parse_commit_text {
Robert Fitzsimonsccdfdea2006-12-27 14:22:21 +0000[diff] [blame]3510 my ($commit_text, $withparents) = @_;
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3511 my @commit_lines = split '\n', $commit_text;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3512 my %co;
3513
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3514 pop @commit_lines; # Remove '\0'
3515
Jakub Narebski198a2a82007-05-12 21:16:34 +0200[diff] [blame]3516 if (! @commit_lines) {
3517 return;
3518 }
3519
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3520 my $header = shift @commit_lines;
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3521 if ($header !~ m/^$oid_regex/) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3522 return;
3523 }
Robert Fitzsimonsccdfdea2006-12-27 14:22:21 +0000[diff] [blame]3524 ($co{'id'}, my @parents) = split ' ', $header;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3525 while (my $line = shift @commit_lines) {
3526 last if $line eq "\n";
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3527 if ($line =~ m/^tree ($oid_regex)$/) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3528 $co{'tree'} = $1;
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3529 } elsif ((!defined $withparents) && ($line =~ m/^parent ($oid_regex)$/)) {
Robert Fitzsimons208b2df2006-12-24 14:31:43 +0000[diff] [blame]3530 push @parents, $1;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3531 } elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]3532 $co{'author'} = hide_mailaddrs_if_private(to_utf8($1));
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3533 $co{'author_epoch'} = $2;
3534 $co{'author_tz'} = $3;
Jakub Narebskiba00b8c2006-11-25 15:54:32 +0100[diff] [blame]3535 if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
3536 $co{'author_name'} = $1;
3537 $co{'author_email'} = $2;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3538 } else {
3539 $co{'author_name'} = $co{'author'};
3540 }
3541 } elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]3542 $co{'committer'} = hide_mailaddrs_if_private(to_utf8($1));
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3543 $co{'committer_epoch'} = $2;
3544 $co{'committer_tz'} = $3;
Jakub Narebskiba00b8c2006-11-25 15:54:32 +0100[diff] [blame]3545 if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
3546 $co{'committer_name'} = $1;
3547 $co{'committer_email'} = $2;
3548 } else {
3549 $co{'committer_name'} = $co{'committer'};
3550 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3551 }
3552 }
3553 if (!defined $co{'tree'}) {
3554 return;
3555 };
Robert Fitzsimons208b2df2006-12-24 14:31:43 +0000[diff] [blame]3556 $co{'parents'} = \@parents;
3557 $co{'parent'} = $parents[0];
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3558
3559 foreach my $title (@commit_lines) {
3560 $title =~ s/^ //;
3561 if ($title ne "") {
3562 $co{'title'} = chop_str($title, 80, 5);
3563 # remove leading stuff of merges to make the interesting part visible
3564 if (length($title) > 50) {
3565 $title =~ s/^Automatic //;
3566 $title =~ s/^merge (of|with) /Merge ... /i;
3567 if (length($title) > 50) {
3568 $title =~ s/(http|rsync):\/\///;
3569 }
3570 if (length($title) > 50) {
3571 $title =~ s/(master|www|rsync)\.//;
3572 }
3573 if (length($title) > 50) {
3574 $title =~ s/kernel.org:?//;
3575 }
3576 if (length($title) > 50) {
3577 $title =~ s/\/pub\/scm//;
3578 }
3579 }
3580 $co{'title_short'} = chop_str($title, 50, 5);
3581 last;
3582 }
3583 }
Joey Hess53c39672008-09-05 14:26:29 -0400[diff] [blame]3584 if (! defined $co{'title'} || $co{'title'} eq "") {
Petr Baudis7e0fe5c2006-10-06 18:55:04 +0200[diff] [blame]3585 $co{'title'} = $co{'title_short'} = '(no commit message)';
3586 }
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]3587 # remove added spaces, redact e-mail addresses if applicable.
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3588 foreach my $line (@commit_lines) {
3589 $line =~ s/^ //;
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]3590 $line = hide_mailaddrs_if_private($line);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3591 }
3592 $co{'comment'} = \@commit_lines;
3593
3594 my $age = time - $co{'committer_epoch'};
3595 $co{'age'} = $age;
3596 $co{'age_string'} = age_string($age);
3597 my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
3598 if ($age > 60*60*24*7*2) {
3599 $co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3600 $co{'age_string_age'} = $co{'age_string'};
3601 } else {
3602 $co{'age_string_date'} = $co{'age_string'};
3603 $co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
3604 }
3605 return %co;
3606}
3607
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3608sub parse_commit {
3609 my ($commit_id) = @_;
3610 my %co;
3611
3612 local $/ = "\0";
3613
3614 open my $fd, "-|", git_cmd(), "rev-list",
Robert Fitzsimonsccdfdea2006-12-27 14:22:21 +0000[diff] [blame]3615 "--parents",
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3616 "--header",
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3617 "--max-count=1",
3618 $commit_id,
3619 "--",
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]3620 or die_error(500, "Open git-rev-list failed");
Robert Fitzsimonsccdfdea2006-12-27 14:22:21 +0000[diff] [blame]3621 %co = parse_commit_text(<$fd>, 1);
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3622 close $fd;
3623
3624 return %co;
3625}
3626
3627sub parse_commits {
Jakub Narebski311e5522008-02-26 13:22:06 +0100[diff] [blame]3628 my ($commit_id, $maxcount, $skip, $filename, @args) = @_;
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3629 my @cos;
3630
3631 $maxcount ||= 1;
3632 $skip ||= 0;
3633
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3634 local $/ = "\0";
3635
3636 open my $fd, "-|", git_cmd(), "rev-list",
3637 "--header",
Jakub Narebski311e5522008-02-26 13:22:06 +0100[diff] [blame]3638 @args,
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3639 ("--max-count=" . $maxcount),
Robert Fitzsimonsf47efbb2006-12-24 14:31:49 +0000[diff] [blame]3640 ("--skip=" . $skip),
Miklos Vajna868bc062007-07-12 20:39:27 +0200[diff] [blame]3641 @extra_options,
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3642 $commit_id,
3643 "--",
3644 ($filename ? ($filename) : ())
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]3645 or die_error(500, "Open git-rev-list failed");
Robert Fitzsimons756bbf52006-12-24 14:31:42 +0000[diff] [blame]3646 while (my $line = <$fd>) {
3647 my %co = parse_commit_text($line);
3648 push @cos, \%co;
3649 }
3650 close $fd;
3651
3652 return wantarray ? @cos : \@cos;
3653}
3654
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]3655# parse line of git-diff-tree "raw" output
Jakub Narebski740e67f2006-08-21 23:07:00 +0200[diff] [blame]3656sub parse_difftree_raw_line {
3657 my $line = shift;
3658 my %res;
3659
3660 # ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
3661 # ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3662 if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ($oid_regex) ($oid_regex) (.)([0-9]{0,3})\t(.*)$/) {
Jakub Narebski740e67f2006-08-21 23:07:00 +0200[diff] [blame]3663 $res{'from_mode'} = $1;
3664 $res{'to_mode'} = $2;
3665 $res{'from_id'} = $3;
3666 $res{'to_id'} = $4;
Jakub Narebski4ed4a342008-04-05 21:13:24 +0100[diff] [blame]3667 $res{'status'} = $5;
Jakub Narebski740e67f2006-08-21 23:07:00 +0200[diff] [blame]3668 $res{'similarity'} = $6;
3669 if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]3670 ($res{'from_file'}, $res{'to_file'}) = map { unquote($_) } split("\t", $7);
Jakub Narebski740e67f2006-08-21 23:07:00 +0200[diff] [blame]3671 } else {
Jakub Narebski9d301452007-11-01 12:38:08 +0100[diff] [blame]3672 $res{'from_file'} = $res{'to_file'} = $res{'file'} = unquote($7);
Jakub Narebski740e67f2006-08-21 23:07:00 +0200[diff] [blame]3673 }
3674 }
Jakub Narebski78bc4032007-05-07 01:10:03 +0200[diff] [blame]3675 # '::100755 100755 100755 60e79ca1b01bc8b057abe17ddab484699a7f5fdb 94067cc5f73388f33722d52ae02f44692bc07490 94067cc5f73388f33722d52ae02f44692bc07490 MR git-gui/git-gui.sh'
3676 # combined diff (for merge commit)
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3677 elsif ($line =~ s/^(::+)((?:[0-7]{6} )+)((?:$oid_regex )+)([a-zA-Z]+)\t(.*)$//) {
Jakub Narebski78bc4032007-05-07 01:10:03 +0200[diff] [blame]3678 $res{'nparents'} = length($1);
3679 $res{'from_mode'} = [ split(' ', $2) ];
3680 $res{'to_mode'} = pop @{$res{'from_mode'}};
3681 $res{'from_id'} = [ split(' ', $3) ];
3682 $res{'to_id'} = pop @{$res{'from_id'}};
3683 $res{'status'} = [ split('', $4) ];
3684 $res{'to_file'} = unquote($5);
3685 }
Jakub Narebski740e67f2006-08-21 23:07:00 +0200[diff] [blame]3686 # 'c512b523472485aef4fff9e57b229d9d243c967f'
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3687 elsif ($line =~ m/^($oid_regex)$/) {
Jakub Narebski0edcb372006-08-31 00:36:04 +0200[diff] [blame]3688 $res{'commit'} = $1;
3689 }
Jakub Narebski740e67f2006-08-21 23:07:00 +0200[diff] [blame]3690
3691 return wantarray ? %res : \%res;
3692}
3693
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]3694# wrapper: return parsed line of git-diff-tree "raw" output
3695# (the argument might be raw line, or parsed info)
3696sub parsed_difftree_line {
3697 my $line_or_ref = shift;
3698
3699 if (ref($line_or_ref) eq "HASH") {
3700 # pre-parsed (or generated by hand)
3701 return $line_or_ref;
3702 } else {
3703 return parse_difftree_raw_line($line_or_ref);
3704 }
3705}
3706
Jakub Narebskicb849b42006-08-31 00:32:15 +0200[diff] [blame]3707# parse line of git-ls-tree output
Jakub Narebski74fd8722009-05-07 19:11:29 +0200[diff] [blame]3708sub parse_ls_tree_line {
Jakub Narebskicb849b42006-08-31 00:32:15 +0200[diff] [blame]3709 my $line = shift;
3710 my %opts = @_;
3711 my %res;
3712
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]3713 if ($opts{'-l'}) {
3714 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa 16717 panic.c'
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3715 $line =~ m/^([0-9]+) (.+) ($oid_regex) +(-|[0-9]+)\t(.+)$/s;
Jakub Narebskicb849b42006-08-31 00:32:15 +0200[diff] [blame]3716
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]3717 $res{'mode'} = $1;
3718 $res{'type'} = $2;
3719 $res{'hash'} = $3;
3720 $res{'size'} = $4;
3721 if ($opts{'-z'}) {
3722 $res{'name'} = $5;
3723 } else {
3724 $res{'name'} = unquote($5);
3725 }
Jakub Narebskicb849b42006-08-31 00:32:15 +0200[diff] [blame]3726 } else {
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]3727 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]3728 $line =~ m/^([0-9]+) (.+) ($oid_regex)\t(.+)$/s;
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]3729
3730 $res{'mode'} = $1;
3731 $res{'type'} = $2;
3732 $res{'hash'} = $3;
3733 if ($opts{'-z'}) {
3734 $res{'name'} = $4;
3735 } else {
3736 $res{'name'} = unquote($4);
3737 }
Jakub Narebskicb849b42006-08-31 00:32:15 +0200[diff] [blame]3738 }
3739
3740 return wantarray ? %res : \%res;
3741}
3742
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]3743# generates _two_ hashes, references to which are passed as 2 and 3 argument
3744sub parse_from_to_diffinfo {
3745 my ($diffinfo, $from, $to, @parents) = @_;
3746
3747 if ($diffinfo->{'nparents'}) {
3748 # combined diff
3749 $from->{'file'} = [];
3750 $from->{'href'} = [];
3751 fill_from_file_info($diffinfo, @parents)
3752 unless exists $diffinfo->{'from_file'};
3753 for (my $i = 0; $i < $diffinfo->{'nparents'}; $i++) {
Jakub Narebski9d301452007-11-01 12:38:08 +0100[diff] [blame]3754 $from->{'file'}[$i] =
3755 defined $diffinfo->{'from_file'}[$i] ?
3756 $diffinfo->{'from_file'}[$i] :
3757 $diffinfo->{'to_file'};
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]3758 if ($diffinfo->{'status'}[$i] ne "A") { # not new (added) file
3759 $from->{'href'}[$i] = href(action=>"blob",
3760 hash_base=>$parents[$i],
3761 hash=>$diffinfo->{'from_id'}[$i],
3762 file_name=>$from->{'file'}[$i]);
3763 } else {
3764 $from->{'href'}[$i] = undef;
3765 }
3766 }
3767 } else {
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]3768 # ordinary (not combined) diff
Jakub Narebski9d301452007-11-01 12:38:08 +0100[diff] [blame]3769 $from->{'file'} = $diffinfo->{'from_file'};
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]3770 if ($diffinfo->{'status'} ne "A") { # not new (added) file
3771 $from->{'href'} = href(action=>"blob", hash_base=>$hash_parent,
3772 hash=>$diffinfo->{'from_id'},
3773 file_name=>$from->{'file'});
3774 } else {
3775 delete $from->{'href'};
3776 }
3777 }
3778
Jakub Narebski9d301452007-11-01 12:38:08 +0100[diff] [blame]3779 $to->{'file'} = $diffinfo->{'to_file'};
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]3780 if (!is_deleted($diffinfo)) { # file exists in result
3781 $to->{'href'} = href(action=>"blob", hash_base=>$hash,
3782 hash=>$diffinfo->{'to_id'},
3783 file_name=>$to->{'file'});
3784 } else {
3785 delete $to->{'href'};
3786 }
3787}
3788
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3789## ......................................................................
3790## parse to array of hashes functions
3791
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3792sub git_get_heads_list {
Giuseppe Bilotta9b3f3de2010-11-11 13:26:10 +0100[diff] [blame]3793 my ($limit, @classes) = @_;
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]3794 @classes = get_branch_refs() unless @classes;
Giuseppe Bilotta9b3f3de2010-11-11 13:26:10 +0100[diff] [blame]3795 my @patterns = map { "refs/$_" } @classes;
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3796 my @headslist;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3797
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3798 open my $fd, '-|', git_cmd(), 'for-each-ref',
3799 ($limit ? '--count='.($limit+1) : ()), '--sort=-committerdate',
3800 '--format=%(objectname) %(refname) %(subject)%00%(committer)',
Giuseppe Bilotta9b3f3de2010-11-11 13:26:10 +0100[diff] [blame]3801 @patterns
Jakub Narebskic83a77e2006-09-15 03:43:28 +0200[diff] [blame]3802 or return;
3803 while (my $line = <$fd>) {
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3804 my %ref_item;
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]3805
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3806 chomp $line;
3807 my ($refinfo, $committerinfo) = split(/\0/, $line);
3808 my ($hash, $name, $title) = split(' ', $refinfo, 3);
3809 my ($committer, $epoch, $tz) =
3810 ($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
Jakub Narebskibf901f82007-12-15 15:40:28 +0100[diff] [blame]3811 $ref_item{'fullname'} = $name;
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]3812 my $strip_refs = join '|', map { quotemeta } get_branch_refs();
3813 $name =~ s!^refs/($strip_refs|remotes)/!!;
Krzesimir Nowake3747472013-12-11 12:54:44 +0100[diff] [blame]3814 $ref_item{'name'} = $name;
3815 # for refs neither in 'heads' nor 'remotes' we want to
3816 # show their ref dir
3817 my $ref_dir = (defined $1) ? $1 : '';
3818 if ($ref_dir ne '' and $ref_dir ne 'heads' and $ref_dir ne 'remotes') {
3819 $ref_item{'name'} .= ' (' . $ref_dir . ')';
3820 }
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3821
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3822 $ref_item{'id'} = $hash;
3823 $ref_item{'title'} = $title || '(no commit message)';
3824 $ref_item{'epoch'} = $epoch;
3825 if ($epoch) {
3826 $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
3827 } else {
3828 $ref_item{'age'} = "unknown";
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3829 }
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3830
3831 push @headslist, \%ref_item;
Jakub Narebskic83a77e2006-09-15 03:43:28 +0200[diff] [blame]3832 }
3833 close $fd;
Junio C Hamano7a13b992006-07-31 19:18:34 -0700[diff] [blame]3834
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3835 return wantarray ? @headslist : \@headslist;
3836}
Jakub Narebskic83a77e2006-09-15 03:43:28 +0200[diff] [blame]3837
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3838sub git_get_tags_list {
3839 my $limit = shift;
3840 my @tagslist;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3841
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3842 open my $fd, '-|', git_cmd(), 'for-each-ref',
3843 ($limit ? '--count='.($limit+1) : ()), '--sort=-creatordate',
3844 '--format=%(objectname) %(objecttype) %(refname) '.
3845 '%(*objectname) %(*objecttype) %(subject)%00%(creator)',
3846 'refs/tags'
3847 or return;
3848 while (my $line = <$fd>) {
3849 my %ref_item;
3850
3851 chomp $line;
3852 my ($refinfo, $creatorinfo) = split(/\0/, $line);
3853 my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
3854 my ($creator, $epoch, $tz) =
3855 ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
Jakub Narebskibf901f82007-12-15 15:40:28 +0100[diff] [blame]3856 $ref_item{'fullname'} = $name;
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3857 $name =~ s!^refs/tags/!!;
3858
3859 $ref_item{'type'} = $type;
3860 $ref_item{'id'} = $id;
3861 $ref_item{'name'} = $name;
3862 if ($type eq "tag") {
3863 $ref_item{'subject'} = $title;
3864 $ref_item{'reftype'} = $reftype;
3865 $ref_item{'refid'} = $refid;
3866 } else {
3867 $ref_item{'reftype'} = $type;
3868 $ref_item{'refid'} = $id;
3869 }
3870
3871 if ($type eq "tag" || $type eq "commit") {
3872 $ref_item{'epoch'} = $epoch;
3873 if ($epoch) {
3874 $ref_item{'age'} = age_string(time - $ref_item{'epoch'});
3875 } else {
3876 $ref_item{'age'} = "unknown";
3877 }
3878 }
3879
3880 push @tagslist, \%ref_item;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3881 }
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]3882 close $fd;
3883
3884 return wantarray ? @tagslist : \@tagslist;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3885}
3886
3887## ----------------------------------------------------------------------
3888## filesystem-related functions
3889
3890sub get_file_owner {
3891 my $path = shift;
3892
3893 my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
3894 my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
3895 if (!defined $gcos) {
3896 return undef;
3897 }
3898 my $owner = $gcos;
3899 $owner =~ s/[,;].*$//;
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]3900 return to_utf8($owner);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3901}
3902
Jakub Narebski2dcb5e12008-12-01 19:01:42 +0100[diff] [blame]3903# assume that file exists
3904sub insert_file {
3905 my $filename = shift;
3906
3907 open my $fd, '<', $filename;
Jakub Narebski45868642008-12-08 14:13:21 +0100[diff] [blame]3908 print map { to_utf8($_) } <$fd>;
Jakub Narebski2dcb5e12008-12-01 19:01:42 +0100[diff] [blame]3909 close $fd;
3910}
3911
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3912## ......................................................................
3913## mimetype related functions
3914
3915sub mimetype_guess_file {
3916 my $filename = shift;
3917 my $mimemap = shift;
3918 -r $mimemap or return undef;
3919
3920 my %mimemap;
Jakub Narebskidff2b6d2009-05-10 02:38:34 +0200[diff] [blame]3921 open(my $mh, '<', $mimemap) or return undef;
Jakub Narebskiad87e4f2009-05-11 03:21:06 +0200[diff] [blame]3922 while (<$mh>) {
Jakub Narebski618918e2006-08-14 02:15:22 +0200[diff] [blame]3923 next if m/^#/; # skip comments
Ludwig Nussel93a6ad12011-06-15 08:10:08 +0200[diff] [blame]3924 my ($mimetype, @exts) = split(/\s+/);
3925 foreach my $ext (@exts) {
3926 $mimemap{$ext} = $mimetype;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3927 }
3928 }
Jakub Narebskiad87e4f2009-05-11 03:21:06 +0200[diff] [blame]3929 close($mh);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3930
Jakub Narebski80593192006-09-19 13:57:03 +0200[diff] [blame]3931 $filename =~ /\.([^.]*)$/;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3932 return $mimemap{$1};
3933}
3934
3935sub mimetype_guess {
3936 my $filename = shift;
3937 my $mime;
3938 $filename =~ /\./ or return undef;
3939
3940 if ($mimetypes_file) {
3941 my $file = $mimetypes_file;
Jakub Narebskid5aa50d2006-08-14 02:16:33 +0200[diff] [blame]3942 if ($file !~ m!^/!) { # if it is relative path
3943 # it is relative to project
3944 $file = "$projectroot/$project/$file";
3945 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3946 $mime = mimetype_guess_file($filename, $file);
3947 }
3948 $mime ||= mimetype_guess_file($filename, '/etc/mime.types');
3949 return $mime;
3950}
3951
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]3952sub blob_mimetype {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3953 my $fd = shift;
3954 my $filename = shift;
3955
3956 if ($filename) {
3957 my $mime = mimetype_guess($filename);
3958 $mime and return $mime;
3959 }
3960
3961 # just in case
3962 return $default_blob_plain_mimetype unless $fd;
3963
3964 if (-T $fd) {
Jakub Narebski7f718e82008-06-03 16:47:10 +0200[diff] [blame]3965 return 'text/plain';
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]3966 } elsif (! $filename) {
3967 return 'application/octet-stream';
3968 } elsif ($filename =~ m/\.png$/i) {
3969 return 'image/png';
3970 } elsif ($filename =~ m/\.gif$/i) {
3971 return 'image/gif';
3972 } elsif ($filename =~ m/\.jpe?g$/i) {
3973 return 'image/jpeg';
3974 } else {
3975 return 'application/octet-stream';
3976 }
3977}
3978
Jakub Narebski7f718e82008-06-03 16:47:10 +0200[diff] [blame]3979sub blob_contenttype {
3980 my ($fd, $file_name, $type) = @_;
3981
3982 $type ||= blob_mimetype($fd, $file_name);
3983 if ($type eq 'text/plain' && defined $default_text_plain_charset) {
3984 $type .= "; charset=$default_text_plain_charset";
3985 }
3986
3987 return $type;
3988}
3989
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]3990# guess file syntax for syntax highlighting; return undef if no highlighting
3991# the name of syntax can (in the future) depend on syntax highlighter used
3992sub guess_file_syntax {
Ian Kellingc151aa32016-09-24 15:32:57 -0700[diff] [blame]3993 my ($highlight, $file_name) = @_;
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]3994 return undef unless ($highlight && defined $file_name);
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]3995 my $basename = basename($file_name, '.in');
3996 return $highlight_basename{$basename}
3997 if exists $highlight_basename{$basename};
3998
3999 $basename =~ /\.([^.]*)$/;
4000 my $ext = $1 or return undef;
4001 return $highlight_ext{$ext}
4002 if exists $highlight_ext{$ext};
4003
4004 return undef;
4005}
4006
4007# run highlighter and return FD of its output,
4008# or return original FD if no highlighting
4009sub run_highlighter {
4010 my ($fd, $highlight, $syntax) = @_;
Ian Kelling779a2062016-09-24 15:32:58 -0700[diff] [blame]4011 return $fd unless ($highlight);
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]4012
Sylvain Rabot3ca73532010-12-30 22:20:29 +0100[diff] [blame]4013 close $fd;
Ian Kelling779a2062016-09-24 15:32:58 -0700[diff] [blame]4014 my $syntax_arg = (defined $syntax) ? "--syntax $syntax" : "--force";
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]4015 open $fd, quote_command(git_cmd(), "cat-file", "blob", $hash)." | ".
Shin Kojima029f3722016-05-03 22:00:51 +0900[diff] [blame]4016 quote_command($^X, '-CO', '-MEncode=decode,FB_DEFAULT', '-pse',
4017 '$_ = decode($fe, $_, FB_DEFAULT) if !utf8::decode($_);',
4018 '--', "-fe=$fallback_encoding")." | ".
Christopher Wilson7ce896b2010-09-21 00:25:19 -0700[diff] [blame]4019 quote_command($highlight_bin).
Ian Kelling779a2062016-09-24 15:32:58 -0700[diff] [blame]4020 " --replace-tabs=8 --fragment $syntax_arg |"
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]4021 or die_error(500, "Couldn't open file or run syntax highlighter");
4022 return $fd;
4023}
4024
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4025## ======================================================================
4026## functions printing HTML: header, footer, error page
4027
Jakub Narebskiefb2d0c2010-04-24 16:01:10 +0200[diff] [blame]4028sub get_page_title {
4029 my $title = to_utf8($site_name);
4030
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]4031 unless (defined $project) {
4032 if (defined $project_filter) {
Jakub Narebskif4212082012-02-12 16:21:30 +0100[diff] [blame]4033 $title .= " - projects in '" . esc_path($project_filter) . "'";
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]4034 }
4035 return $title;
4036 }
Jakub Narebskiefb2d0c2010-04-24 16:01:10 +0200[diff] [blame]4037 $title .= " - " . to_utf8($project);
4038
4039 return $title unless (defined $action);
4040 $title .= "/$action"; # $action is US-ASCII (7bit ASCII)
4041
4042 return $title unless (defined $file_name);
4043 $title .= " - " . esc_path($file_name);
4044 if ($action eq "tree" && $file_name !~ m|/$|) {
4045 $title .= "/";
4046 }
4047
4048 return $title;
4049}
4050
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4051sub get_content_type_html {
4052 # require explicit support from the UA if we are to send the page as
4053 # 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
4054 # we have to do this because MSIE sometimes globs '*/*', pretending to
4055 # support xhtml+xml but choking when it gets what it asked for.
4056 if (defined $cgi->http('HTTP_ACCEPT') &&
4057 $cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\+xml(,|;|\s|$)/ &&
4058 $cgi->Accept('application/xhtml+xml') != 0) {
4059 return 'application/xhtml+xml';
4060 } else {
4061 return 'text/html';
4062 }
4063}
4064
Jakub Narebski05bb5a22010-12-18 21:02:13 +0100[diff] [blame]4065sub print_feed_meta {
4066 if (defined $project) {
4067 my %href_params = get_feed_info();
4068 if (!exists $href_params{'-title'}) {
4069 $href_params{'-title'} = 'log';
4070 }
4071
Ævar Arnfjörð Bjarmason0f54b7d2011-02-19 15:27:41 +0000[diff] [blame]4072 foreach my $format (qw(RSS Atom)) {
Jakub Narebski05bb5a22010-12-18 21:02:13 +0100[diff] [blame]4073 my $type = lc($format);
4074 my %link_attr = (
4075 '-rel' => 'alternate',
4076 '-title' => esc_attr("$project - $href_params{'-title'} - $format feed"),
4077 '-type' => "application/$type+xml"
4078 );
4079
Sebastian Pippingcc999a32012-04-04 14:25:44 +0200[diff] [blame]4080 $href_params{'extra_options'} = undef;
Jakub Narebski05bb5a22010-12-18 21:02:13 +0100[diff] [blame]4081 $href_params{'action'} = $type;
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]4082 $link_attr{'-href'} = esc_attr(href(%href_params));
Jakub Narebski05bb5a22010-12-18 21:02:13 +0100[diff] [blame]4083 print "<link ".
4084 "rel=\"$link_attr{'-rel'}\" ".
4085 "title=\"$link_attr{'-title'}\" ".
4086 "href=\"$link_attr{'-href'}\" ".
4087 "type=\"$link_attr{'-type'}\" ".
4088 "/>\n";
4089
4090 $href_params{'extra_options'} = '--no-merges';
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]4091 $link_attr{'-href'} = esc_attr(href(%href_params));
Jakub Narebski05bb5a22010-12-18 21:02:13 +0100[diff] [blame]4092 $link_attr{'-title'} .= ' (no merges)';
4093 print "<link ".
4094 "rel=\"$link_attr{'-rel'}\" ".
4095 "title=\"$link_attr{'-title'}\" ".
4096 "href=\"$link_attr{'-href'}\" ".
4097 "type=\"$link_attr{'-type'}\" ".
4098 "/>\n";
4099 }
4100
4101 } else {
4102 printf('<link rel="alternate" title="%s projects list" '.
4103 'href="%s" type="text/plain; charset=utf-8" />'."\n",
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]4104 esc_attr($site_name),
4105 esc_attr(href(project=>undef, action=>"project_index")));
Jakub Narebski05bb5a22010-12-18 21:02:13 +0100[diff] [blame]4106 printf('<link rel="alternate" title="%s projects feeds" '.
4107 'href="%s" type="text/x-opml" />'."\n",
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]4108 esc_attr($site_name),
4109 esc_attr(href(project=>undef, action=>"opml")));
Jakub Narebski05bb5a22010-12-18 21:02:13 +0100[diff] [blame]4110 }
4111}
4112
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4113sub print_header_links {
4114 my $status = shift;
4115
4116 # print out each stylesheet that exist, providing backwards capability
4117 # for those people who defined $stylesheet in a config file
4118 if (defined $stylesheet) {
4119 print '<link rel="stylesheet" type="text/css" href="'.esc_url($stylesheet).'"/>'."\n";
4120 } else {
4121 foreach my $stylesheet (@stylesheets) {
4122 next unless $stylesheet;
4123 print '<link rel="stylesheet" type="text/css" href="'.esc_url($stylesheet).'"/>'."\n";
4124 }
4125 }
4126 print_feed_meta()
4127 if ($status eq '200 OK');
4128 if (defined $favicon) {
4129 print qq(<link rel="shortcut icon" href=").esc_url($favicon).qq(" type="image/png" />\n);
4130 }
4131}
4132
Bernhard R. Link40efa222012-01-30 21:09:43 +0100[diff] [blame]4133sub print_nav_breadcrumbs_path {
4134 my $dirprefix = undef;
4135 while (my $part = shift) {
4136 $dirprefix .= "/" if defined $dirprefix;
4137 $dirprefix .= $part;
4138 print $cgi->a({-href => href(project => undef,
4139 project_filter => $dirprefix,
4140 action => "project_list")},
4141 esc_html($part)) . " / ";
4142 }
4143}
4144
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4145sub print_nav_breadcrumbs {
4146 my %opts = @_;
4147
Tony Finchad9c2e22013-07-04 18:02:12 +0100[diff] [blame]4148 for my $crumb (@extra_breadcrumbs, [ $home_link_str => $home_link ]) {
4149 print $cgi->a({-href => esc_url($crumb->[1])}, $crumb->[0]) . " / ";
4150 }
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4151 if (defined $project) {
Bernhard R. Link4426ba22012-01-30 21:10:23 +0100[diff] [blame]4152 my @dirname = split '/', $project;
4153 my $projectbasename = pop @dirname;
4154 print_nav_breadcrumbs_path(@dirname);
4155 print $cgi->a({-href => href(action=>"summary")}, esc_html($projectbasename));
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4156 if (defined $action) {
4157 my $action_print = $action ;
4158 if (defined $opts{-action_extra}) {
4159 $action_print = $cgi->a({-href => href(action=>$action)},
4160 $action);
4161 }
4162 print " / $action_print";
4163 }
4164 if (defined $opts{-action_extra}) {
4165 print " / $opts{-action_extra}";
4166 }
4167 print "\n";
Bernhard R. Link40efa222012-01-30 21:09:43 +0100[diff] [blame]4168 } elsif (defined $project_filter) {
4169 print_nav_breadcrumbs_path(split '/', $project_filter);
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4170 }
4171}
4172
4173sub print_search_form {
4174 if (!defined $searchtext) {
4175 $searchtext = "";
4176 }
4177 my $search_hash;
4178 if (defined $hash_base) {
4179 $search_hash = $hash_base;
4180 } elsif (defined $hash) {
4181 $search_hash = $hash;
4182 } else {
4183 $search_hash = "HEAD";
4184 }
4185 my $action = $my_uri;
4186 my $use_pathinfo = gitweb_check_feature('pathinfo');
4187 if ($use_pathinfo) {
4188 $action .= "/".esc_url($project);
4189 }
Roland Mas4750f4b2014-10-16 08:54:47 +0200[diff] [blame]4190 print $cgi->start_form(-method => "get", -action => $action) .
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4191 "<div class=\"search\">\n" .
4192 (!$use_pathinfo &&
4193 $cgi->input({-name=>"p", -value=>$project, -type=>"hidden"}) . "\n") .
4194 $cgi->input({-name=>"a", -value=>"search", -type=>"hidden"}) . "\n" .
4195 $cgi->input({-name=>"h", -value=>$search_hash, -type=>"hidden"}) . "\n" .
4196 $cgi->popup_menu(-name => 'st', -default => 'commit',
4197 -values => ['commit', 'grep', 'author', 'committer', 'pickaxe']) .
Tony Finchaf52bd52013-08-20 17:59:54 +0100[diff] [blame]4198 " " . $cgi->a({-href => href(action=>"search_help"),
4199 -title => "search help" }, "?") . " search:\n",
Jakub Narebski84d9e2d2012-02-03 13:44:54 +0100[diff] [blame]4200 $cgi->textfield(-name => "s", -value => $searchtext, -override => 1) . "\n" .
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4201 "<span title=\"Extended regular expression\">" .
4202 $cgi->checkbox(-name => 'sr', -value => 1, -label => 're',
4203 -checked => $search_use_regexp) .
4204 "</span>" .
4205 "</div>" .
4206 $cgi->end_form() . "\n";
4207}
4208
Kay Sievers12a88f22005-08-07 20:02:47 +0200[diff] [blame]4209sub git_header_html {
Kay Sieversa59d4af2005-08-07 20:15:44 +0200[diff] [blame]4210 my $status = shift || "200 OK";
Kay Sievers11044292005-10-19 03:18:45 +0200[diff] [blame]4211 my $expires = shift;
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]4212 my %opts = @_;
Kay Sieversa59d4af2005-08-07 20:15:44 +0200[diff] [blame]4213
Jakub Narebskiefb2d0c2010-04-24 16:01:10 +0200[diff] [blame]4214 my $title = get_page_title();
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4215 my $content_type = get_content_type_html();
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]4216 print $cgi->header(-type=>$content_type, -charset => 'utf-8',
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]4217 -status=> $status, -expires => $expires)
Jakub Narebskiad709ea2010-06-13 00:35:59 +0200[diff] [blame]4218 unless ($opts{'-no_http_header'});
Jakub Narebski45c9a752006-12-27 23:59:51 +0100[diff] [blame]4219 my $mod_perl_version = $ENV{'MOD_PERL'} ? " $ENV{'MOD_PERL'}" : '';
Kay Sieversa59d4af2005-08-07 20:15:44 +0200[diff] [blame]4220 print <<EOF;
Kay Sievers6191f8e2005-08-07 20:19:56 +0200[diff] [blame]4221<?xml version="1.0" encoding="utf-8"?>
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]4222<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
Kay Sievers034df392005-08-07 20:20:07 +0200[diff] [blame]4223<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
Jakub Narebskid4baf9e2006-08-17 11:21:28 +0200[diff] [blame]4224<!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
Jakub Narebskiae20de52006-06-21 09:48:03 +0200[diff] [blame]4225<!-- git core binaries version $git_version -->
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]4226<head>
Alp Tokerf6801d62006-07-11 11:19:34 +0100[diff] [blame]4227<meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
Jakub Narebski45c9a752006-12-27 23:59:51 +0100[diff] [blame]4228<meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
Kay Sieversc994d622005-08-07 20:27:18 +0200[diff] [blame]4229<meta name="robots" content="index, nofollow"/>
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]4230<title>$title</title>
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]4231EOF
Giuseppe Bilotta41a4d162009-01-31 02:31:52 +0100[diff] [blame]4232 # the stylesheet, favicon etc urls won't work correctly with path_info
4233 # unless we set the appropriate base URL
Giuseppe Bilottac3254ae2009-01-31 02:31:50 +0100[diff] [blame]4234 if ($ENV{'PATH_INFO'}) {
Giuseppe Bilotta81d3fe92009-02-15 10:18:36 +0100[diff] [blame]4235 print "<base href=\"".esc_url($base_url)."\" />\n";
Giuseppe Bilottac3254ae2009-01-31 02:31:50 +0100[diff] [blame]4236 }
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4237 print_header_links($status);
Lénaïc Huardc1355b72011-10-21 09:09:29 +0200[diff] [blame]4238
4239 if (defined $site_html_head_string) {
4240 print to_utf8($site_html_head_string);
4241 }
4242
Matthias Lederhoferdd04c422006-08-06 13:25:41 +0200[diff] [blame]4243 print "</head>\n" .
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]4244 "<body>\n";
4245
John 'Warthog9' Hawley24d4afc2010-01-30 23:30:41 +0100[diff] [blame]4246 if (defined $site_header && -f $site_header) {
Jakub Narebski2dcb5e12008-12-01 19:01:42 +0100[diff] [blame]4247 insert_file($site_header);
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]4248 }
4249
Jonathan Nieder68220522010-09-03 19:45:09 -0500[diff] [blame]4250 print "<div class=\"page_header\">\n";
4251 if (defined $logo) {
4252 print $cgi->a({-href => esc_url($logo_url),
4253 -title => $logo_label},
4254 $cgi->img({-src => esc_url($logo),
4255 -width => 72, -height => 27,
4256 -alt => "git",
4257 -class => "logo"}));
4258 }
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4259 print_nav_breadcrumbs(%opts);
Petr Baudisd77b5672007-05-17 04:24:19 +0200[diff] [blame]4260 print "</div>\n";
4261
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]4262 my $have_search = gitweb_check_feature('search');
Jakub Narebskif70dda22008-06-02 11:54:41 +0200[diff] [blame]4263 if (defined $project && $have_search) {
Jakub Narebski6ee90332011-06-22 13:50:46 +0200[diff] [blame]4264 print_search_form();
Kay Sievers4c02e3c2005-08-07 19:52:52 +0200[diff] [blame]4265 }
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]4266}
4267
Kay Sievers12a88f22005-08-07 20:02:47 +0200[diff] [blame]4268sub git_footer_html {
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]4269 my $feed_class = 'rss_logo';
4270
Kay Sievers6191f8e2005-08-07 20:19:56 +0200[diff] [blame]4271 print "<div class=\"page_footer\">\n";
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]4272 if (defined $project) {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]4273 my $descr = git_get_project_description($project);
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]4274 if (defined $descr) {
Kay Sievers40c13812005-11-19 17:41:29 +0100[diff] [blame]4275 print "<div class=\"page_footer_text\">" . esc_html($descr) . "</div>\n";
Kay Sievers6191f8e2005-08-07 20:19:56 +0200[diff] [blame]4276 }
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]4277
4278 my %href_params = get_feed_info();
4279 if (!%href_params) {
4280 $feed_class .= ' generic';
4281 }
4282 $href_params{'-title'} ||= 'log';
4283
Ævar Arnfjörð Bjarmason0f54b7d2011-02-19 15:27:41 +0000[diff] [blame]4284 foreach my $format (qw(RSS Atom)) {
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]4285 $href_params{'action'} = lc($format);
4286 print $cgi->a({-href => href(%href_params),
4287 -title => "$href_params{'-title'} $format feed",
4288 -class => $feed_class}, $format)."\n";
4289 }
4290
Kay Sieversc994d622005-08-07 20:27:18 +0200[diff] [blame]4291 } else {
Bernhard R. Link56efd9d2012-01-30 21:09:00 +0100[diff] [blame]4292 print $cgi->a({-href => href(project=>undef, action=>"opml",
4293 project_filter => $project_filter),
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]4294 -class => $feed_class}, "OPML") . " ";
Bernhard R. Link56efd9d2012-01-30 21:09:00 +0100[diff] [blame]4295 print $cgi->a({-href => href(project=>undef, action=>"project_index",
4296 project_filter => $project_filter),
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]4297 -class => $feed_class}, "TXT") . "\n";
Kay Sieversff7669a2005-08-07 20:13:02 +0200[diff] [blame]4298 }
Jakub Narebski35621982008-04-20 22:09:48 +0200[diff] [blame]4299 print "</div>\n"; # class="page_footer"
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]4300
Jakub Narebskiaa7dd052009-09-01 13:39:16 +0200[diff] [blame]4301 if (defined $t0 && gitweb_check_feature('timed')) {
4302 print "<div id=\"generating_info\">\n";
4303 print 'This page took '.
4304 '<span id="generating_time" class="time_span">'.
Jakub Narebski3962f1d72010-11-09 19:27:54 +0100[diff] [blame]4305 tv_interval($t0, [ gettimeofday() ]).
Jakub Narebskiaa7dd052009-09-01 13:39:16 +0200[diff] [blame]4306 ' seconds </span>'.
4307 ' and '.
4308 '<span id="generating_cmd">'.
4309 $number_of_git_cmds.
4310 '</span> git commands '.
4311 " to generate.\n";
4312 print "</div>\n"; # class="page_footer"
4313 }
4314
John 'Warthog9' Hawley24d4afc2010-01-30 23:30:41 +0100[diff] [blame]4315 if (defined $site_footer && -f $site_footer) {
Jakub Narebski2dcb5e12008-12-01 19:01:42 +0100[diff] [blame]4316 insert_file($site_footer);
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]4317 }
4318
Junio C Hamanoabf411e2010-12-15 11:32:57 -0800[diff] [blame]4319 print qq!<script type="text/javascript" src="!.esc_url($javascript).qq!"></script>\n!;
John 'Warthog9' Hawleyb62a1a92010-01-30 23:30:39 +0100[diff] [blame]4320 if (defined $action &&
4321 $action eq 'blame_incremental') {
Jakub Narebskic4ccf612009-09-01 13:39:19 +0200[diff] [blame]4322 print qq!<script type="text/javascript">\n!.
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]4323 qq!startBlame("!. esc_attr(href(action=>"blame_data", -replay=>1)) .qq!",\n!.
4324 qq! "!. esc_attr(href()) .qq!");\n!.
Jakub Narebskic4ccf612009-09-01 13:39:19 +0200[diff] [blame]4325 qq!</script>\n!;
John 'Warthog9' Hawley291e52b2011-04-28 21:04:09 +0200[diff] [blame]4326 } else {
Jakub Narebski2e987f92011-04-28 21:04:11 +0200[diff] [blame]4327 my ($jstimezone, $tz_cookie, $datetime_class) =
4328 gitweb_get_feature('javascript-timezone');
4329
Jakub Narebskic4ccf612009-09-01 13:39:19 +0200[diff] [blame]4330 print qq!<script type="text/javascript">\n!.
Jakub Narebski2e987f92011-04-28 21:04:11 +0200[diff] [blame]4331 qq!window.onload = function () {\n!;
4332 if (gitweb_check_feature('javascript-actions')) {
4333 print qq! fixLinks();\n!;
4334 }
4335 if ($jstimezone && $tz_cookie && $datetime_class) {
4336 print qq! var tz_cookie = { name: '$tz_cookie', expires: 14, path: '/' };\n!. # in days
4337 qq! onloadTZSetup('$jstimezone', tz_cookie, '$datetime_class');\n!;
4338 }
4339 print qq!};\n!.
Jakub Narebskic4ccf612009-09-01 13:39:19 +0200[diff] [blame]4340 qq!</script>\n!;
4341 }
4342
Alan Chandlerb2d34762006-10-03 13:49:03 +0100[diff] [blame]4343 print "</body>\n" .
Kay Sievers9cd3d982005-08-07 20:17:42 +0200[diff] [blame]4344 "</html>";
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]4345}
4346
Jakub Narebski453541f2010-02-07 21:51:18 +0100[diff] [blame]4347# die_error(<http_status_code>, <error_message>[, <detailed_html_description>])
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]4348# Example: die_error(404, 'Hash not found')
4349# By convention, use the following status codes (as defined in RFC 2616):
4350# 400: Invalid or missing CGI parameters, or
4351# requested object exists but has wrong type.
4352# 403: Requested feature (like "pickaxe" or "snapshot") not enabled on
4353# this server or project.
4354# 404: Requested object/revision/project doesn't exist.
4355# 500: The server isn't configured properly, or
4356# an internal error occurred (e.g. failed assertions caused by bugs), or
4357# an unknown error occurred (e.g. the git binary died unexpectedly).
John 'Warthog9' Hawleyb62a1a92010-01-30 23:30:39 +0100[diff] [blame]4358# 503: The server is currently unavailable (because it is overloaded,
4359# or down for maintenance). Generally, this is a temporary state.
Kay Sievers061cc7c2005-08-07 20:15:57 +0200[diff] [blame]4360sub die_error {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]4361 my $status = shift || 500;
Jakub Narebski1df48762010-02-07 21:52:25 +0100[diff] [blame]4362 my $error = esc_html(shift) || "Internal Server Error";
John 'Warthog9' Hawleyaa140132010-01-30 23:30:44 +0100[diff] [blame]4363 my $extra = shift;
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]4364 my %opts = @_;
Kay Sievers664f4cc2005-08-07 20:17:19 +0200[diff] [blame]4365
John 'Warthog9' Hawleyb62a1a92010-01-30 23:30:39 +0100[diff] [blame]4366 my %http_responses = (
4367 400 => '400 Bad Request',
4368 403 => '403 Forbidden',
4369 404 => '404 Not Found',
4370 500 => '500 Internal Server Error',
4371 503 => '503 Service Unavailable',
4372 );
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]4373 git_header_html($http_responses{$status}, undef, %opts);
Jakub Narebski59b9f612006-08-22 23:42:53 +0200[diff] [blame]4374 print <<EOF;
4375<div class="page_body">
4376<br /><br />
4377$status - $error
4378<br />
Jakub Narebski59b9f612006-08-22 23:42:53 +0200[diff] [blame]4379EOF
John 'Warthog9' Hawleyaa140132010-01-30 23:30:44 +0100[diff] [blame]4380 if (defined $extra) {
4381 print "<hr />\n" .
4382 "$extra\n";
4383 }
4384 print "</div>\n";
4385
Kay Sieversa59d4af2005-08-07 20:15:44 +0200[diff] [blame]4386 git_footer_html();
Jakub Narebski7a597452010-04-24 16:00:04 +0200[diff] [blame]4387 goto DONE_GITWEB
4388 unless ($opts{'-error_handler'});
Kay Sieversa59d4af2005-08-07 20:15:44 +0200[diff] [blame]4389}
4390
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4391## ----------------------------------------------------------------------
4392## functions printing or outputting HTML: navigation
4393
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]4394sub git_print_page_nav {
Jakub Narebskib18f9bf2006-07-30 14:59:57 +0200[diff] [blame]4395 my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
4396 $extra = '' if !defined $extra; # pager or formats
4397
4398 my @navs = qw(summary shortlog log commit commitdiff tree);
4399 if ($suppress) {
4400 @navs = grep { $_ ne $suppress } @navs;
4401 }
4402
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]4403 my %arg = map { $_ => {action=>$_} } @navs;
Jakub Narebskib18f9bf2006-07-30 14:59:57 +0200[diff] [blame]4404 if (defined $head) {
4405 for (qw(commit commitdiff)) {
Jakub Narebski3be8e722007-04-01 22:22:21 +0200[diff] [blame]4406 $arg{$_}{'hash'} = $head;
Jakub Narebskib18f9bf2006-07-30 14:59:57 +0200[diff] [blame]4407 }
4408 if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
4409 for (qw(shortlog log)) {
Jakub Narebski3be8e722007-04-01 22:22:21 +0200[diff] [blame]4410 $arg{$_}{'hash'} = $head;
Jakub Narebskib18f9bf2006-07-30 14:59:57 +0200[diff] [blame]4411 }
4412 }
4413 }
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]4414
Jakub Narebski3be8e722007-04-01 22:22:21 +0200[diff] [blame]4415 $arg{'tree'}{'hash'} = $treehead if defined $treehead;
4416 $arg{'tree'}{'hash_base'} = $treebase if defined $treebase;
Jakub Narebskib18f9bf2006-07-30 14:59:57 +0200[diff] [blame]4417
Junio C Hamanoa7c5a282008-11-29 13:02:08 -0800[diff] [blame]4418 my @actions = gitweb_get_feature('actions');
Jakub Narebski2b11e052008-10-12 00:02:32 +0200[diff] [blame]4419 my %repl = (
4420 '%' => '%',
4421 'n' => $project, # project name
4422 'f' => $git_dir, # project path within filesystem
4423 'h' => $treehead || '', # current hash ('h' parameter)
4424 'b' => $treebase || '', # hash base ('hb' parameter)
4425 );
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]4426 while (@actions) {
Jakub Narebski2b11e052008-10-12 00:02:32 +0200[diff] [blame]4427 my ($label, $link, $pos) = splice(@actions,0,3);
4428 # insert
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]4429 @navs = map { $_ eq $pos ? ($_, $label) : $_ } @navs;
4430 # munch munch
Jakub Narebski2b11e052008-10-12 00:02:32 +0200[diff] [blame]4431 $link =~ s/%([%nfhb])/$repl{$1}/g;
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]4432 $arg{$label}{'_href'} = $link;
4433 }
4434
Jakub Narebskib18f9bf2006-07-30 14:59:57 +0200[diff] [blame]4435 print "<div class=\"page_nav\">\n" .
4436 (join " | ",
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]4437 map { $_ eq $current ?
Petr Baudisd627f682008-10-02 16:36:52 +0200[diff] [blame]4438 $_ : $cgi->a({-href => ($arg{$_}{_href} ? $arg{$_}{_href} : href(%{$arg{$_}}))}, "$_")
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]4439 } @navs);
Jakub Narebski898a8932006-07-30 16:14:43 +0200[diff] [blame]4440 print "<br/>\n$extra<br/>\n" .
Jakub Narebskib18f9bf2006-07-30 14:59:57 +0200[diff] [blame]4441 "</div>\n";
4442}
4443
Ville Skyttä64127572017-06-25 13:20:41 +0300[diff] [blame]4444# returns a submenu for the navigation of the refs views (tags, heads,
Giuseppe Bilotta11e7bec2010-11-11 13:26:12 +0100[diff] [blame]4445# remotes) with the current view disabled and the remotes view only
4446# available if the feature is enabled
4447sub format_ref_views {
4448 my ($current) = @_;
4449 my @ref_views = qw{tags heads};
4450 push @ref_views, 'remotes' if gitweb_check_feature('remote_heads');
4451 return join " | ", map {
4452 $_ eq $current ? $_ :
4453 $cgi->a({-href => href(action=>$_)}, $_)
4454 } @ref_views
4455}
4456
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]4457sub format_paging_nav {
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]4458 my ($action, $page, $has_next_link) = @_;
Jakub Narebski43ffc062006-07-30 17:49:00 +0200[diff] [blame]4459 my $paging_nav;
4460
4461
Jakub Narebski43ffc062006-07-30 17:49:00 +0200[diff] [blame]4462 if ($page > 0) {
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]4463 $paging_nav .=
4464 $cgi->a({-href => href(-replay=>1, page=>undef)}, "first") .
4465 " &sdot; " .
Jakub Narebski7afd77b2007-11-01 13:06:28 +0100[diff] [blame]4466 $cgi->a({-href => href(-replay=>1, page=>$page-1),
Jakub Narebski26298b52006-08-10 12:38:47 +0200[diff] [blame]4467 -accesskey => "p", -title => "Alt-p"}, "prev");
Jakub Narebski43ffc062006-07-30 17:49:00 +0200[diff] [blame]4468 } else {
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]4469 $paging_nav .= "first &sdot; prev";
Jakub Narebski43ffc062006-07-30 17:49:00 +0200[diff] [blame]4470 }
4471
Lea Wiemann1f684dc2008-05-28 01:25:42 +0200[diff] [blame]4472 if ($has_next_link) {
Jakub Narebski43ffc062006-07-30 17:49:00 +0200[diff] [blame]4473 $paging_nav .= " &sdot; " .
Jakub Narebski7afd77b2007-11-01 13:06:28 +0100[diff] [blame]4474 $cgi->a({-href => href(-replay=>1, page=>$page+1),
Jakub Narebski26298b52006-08-10 12:38:47 +0200[diff] [blame]4475 -accesskey => "n", -title => "Alt-n"}, "next");
Jakub Narebski43ffc062006-07-30 17:49:00 +0200[diff] [blame]4476 } else {
4477 $paging_nav .= " &sdot; next";
4478 }
4479
4480 return $paging_nav;
4481}
4482
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4483## ......................................................................
4484## functions printing or outputting HTML: div
Kay Sievers42f7eb92005-08-07 20:21:46 +0200[diff] [blame]4485
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]4486sub git_print_header_div {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4487 my ($action, $title, $hash, $hash_base) = @_;
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]4488 my %args = ();
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4489
Jakub Narebski3be8e722007-04-01 22:22:21 +0200[diff] [blame]4490 $args{'action'} = $action;
4491 $args{'hash'} = $hash if $hash;
4492 $args{'hash_base'} = $hash_base if $hash_base;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4493
4494 print "<div class=\"header\">\n" .
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]4495 $cgi->a({-href => href(%args), -class => "title"},
4496 $title ? $title : $action) .
4497 "\n</div>\n";
Kay Sievers42f7eb92005-08-07 20:21:46 +0200[diff] [blame]4498}
4499
Giuseppe Bilotta0e656992010-11-11 13:26:15 +0100[diff] [blame]4500sub format_repo_url {
4501 my ($name, $url) = @_;
4502 return "<tr class=\"metadata_url\"><td>$name</td><td>$url</td></tr>\n";
4503}
4504
Giuseppe Bilottab891d522010-11-11 13:26:16 +0100[diff] [blame]4505# Group output by placing it in a DIV element and adding a header.
4506# Options for start_div() can be provided by passing a hash reference as the
4507# first parameter to the function.
4508# Options to git_print_header_div() can be provided by passing an array
4509# reference. This must follow the options to start_div if they are present.
4510# The content can be a scalar, which is output as-is, a scalar reference, which
4511# is output after html escaping, an IO handle passed either as *handle or
4512# *handle{IO}, or a function reference. In the latter case all following
4513# parameters will be taken as argument to the content function call.
4514sub git_print_section {
4515 my ($div_args, $header_args, $content);
4516 my $arg = shift;
4517 if (ref($arg) eq 'HASH') {
4518 $div_args = $arg;
4519 $arg = shift;
4520 }
4521 if (ref($arg) eq 'ARRAY') {
4522 $header_args = $arg;
4523 $arg = shift;
4524 }
4525 $content = $arg;
4526
4527 print $cgi->start_div($div_args);
4528 git_print_header_div(@$header_args);
4529
4530 if (ref($content) eq 'CODE') {
4531 $content->(@_);
4532 } elsif (ref($content) eq 'SCALAR') {
4533 print esc_html($$content);
4534 } elsif (ref($content) eq 'GLOB' or ref($content) eq 'IO::Handle') {
4535 print <$content>;
4536 } elsif (!ref($content) && defined($content)) {
4537 print $content;
4538 }
4539
4540 print $cgi->end_div;
4541}
4542
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4543sub format_timestamp_html {
Jakub Narebskice71b072011-04-28 21:04:08 +0200[diff] [blame]4544 my $date = shift;
Jakub Narebski2e987f92011-04-28 21:04:11 +0200[diff] [blame]4545 my $strtime = $date->{'rfc2822'};
John 'Warthog9' Hawley0cf207f2010-01-30 23:30:42 +0100[diff] [blame]4546
Jakub Narebski2e987f92011-04-28 21:04:11 +0200[diff] [blame]4547 my (undef, undef, $datetime_class) =
4548 gitweb_get_feature('javascript-timezone');
4549 if ($datetime_class) {
4550 $strtime = qq!<span class="$datetime_class">$strtime</span>!;
Jakub Narebskia44465c2006-08-28 23:17:31 +0200[diff] [blame]4551 }
John 'Warthog9' Hawley0cf207f2010-01-30 23:30:42 +0100[diff] [blame]4552
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4553 my $localtime_format = '(%02d:%02d %s)';
4554 if ($date->{'hour_local'} < 6) {
4555 $localtime_format = '(<span class="atnight">%02d:%02d</span> %s)';
Jakub Narebskia44465c2006-08-28 23:17:31 +0200[diff] [blame]4556 }
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4557 $strtime .= ' ' .
4558 sprintf($localtime_format,
4559 $date->{'hour_local'}, $date->{'minute_local'}, $date->{'tz_local'});
John 'Warthog9' Hawley0cf207f2010-01-30 23:30:42 +0100[diff] [blame]4560
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4561 return $strtime;
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]4562}
4563
4564# Outputs the author name and date in long form
4565sub git_print_authorship {
4566 my $co = shift;
4567 my %opts = @_;
4568 my $tag = $opts{-tag} || 'div';
Stephen Boyde133d652009-10-15 21:14:59 -0700[diff] [blame]4569 my $author = $co->{'author_name'};
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]4570
4571 my %ad = parse_date($co->{'author_epoch'}, $co->{'author_tz'});
4572 print "<$tag class=\"author_date\">" .
Stephen Boyde133d652009-10-15 21:14:59 -0700[diff] [blame]4573 format_search_author($author, "author", esc_html($author)) .
Jakub Narebskice71b072011-04-28 21:04:08 +0200[diff] [blame]4574 " [".format_timestamp_html(\%ad)."]".
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4575 git_get_avatar($co->{'author_email'}, -pad_before => 1) .
4576 "</$tag>\n";
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]4577}
4578
4579# Outputs table rows containing the full author or committer information,
Ralf Wildenhues22e5e582010-08-22 13:12:12 +0200[diff] [blame]4580# in the format expected for 'commit' view (& similar).
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]4581# Parameters are a commit hash reference, followed by the list of people
Ralf Wildenhues22e5e582010-08-22 13:12:12 +0200[diff] [blame]4582# to output information for. If the list is empty it defaults to both
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]4583# author and committer.
4584sub git_print_authorship_rows {
4585 my $co = shift;
4586 # too bad we can't use @people = @_ || ('author', 'committer')
4587 my @people = @_;
4588 @people = ('author', 'committer') unless @people;
4589 foreach my $who (@people) {
4590 my %wd = parse_date($co->{"${who}_epoch"}, $co->{"${who}_tz"});
Stephen Boyde133d652009-10-15 21:14:59 -0700[diff] [blame]4591 print "<tr><td>$who</td><td>" .
4592 format_search_author($co->{"${who}_name"}, $who,
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4593 esc_html($co->{"${who}_name"})) . " " .
Stephen Boyde133d652009-10-15 21:14:59 -0700[diff] [blame]4594 format_search_author($co->{"${who}_email"}, $who,
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4595 esc_html("<" . $co->{"${who}_email"} . ">")) .
Stephen Boyde133d652009-10-15 21:14:59 -0700[diff] [blame]4596 "</td><td rowspan=\"2\">" .
Giuseppe Bilottae9fdd742009-06-30 00:00:51 +0200[diff] [blame]4597 git_get_avatar($co->{"${who}_email"}, -size => 'double') .
4598 "</td></tr>\n" .
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]4599 "<tr>" .
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4600 "<td></td><td>" .
Jakub Narebskice71b072011-04-28 21:04:08 +0200[diff] [blame]4601 format_timestamp_html(\%wd) .
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]4602 "</td>" .
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]4603 "</tr>\n";
4604 }
Jakub Narebski6fd92a22006-08-28 14:48:12 +0200[diff] [blame]4605}
4606
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4607sub git_print_page_path {
4608 my $name = shift;
4609 my $type = shift;
Luben Tuikov59fb1c92006-08-17 10:39:29 -0700[diff] [blame]4610 my $hb = shift;
Junio C Hamanodf2c37a2006-01-09 13:13:39 +0100[diff] [blame]4611
Jakub Narebski4df118e2006-10-21 17:53:55 +0200[diff] [blame]4612
4613 print "<div class=\"page_path\">";
4614 print $cgi->a({-href => href(action=>"tree", hash_base=>$hb),
Martin Koegler00f429a2007-06-03 17:42:44 +0200[diff] [blame]4615 -title => 'tree root'}, to_utf8("[$project]"));
Jakub Narebski4df118e2006-10-21 17:53:55 +0200[diff] [blame]4616 print " / ";
4617 if (defined $name) {
Jakub Narebski762c7202006-09-04 18:17:58 +0200[diff] [blame]4618 my @dirname = split '/', $name;
4619 my $basename = pop @dirname;
4620 my $fullname = '';
4621
Jakub Narebski762c7202006-09-04 18:17:58 +0200[diff] [blame]4622 foreach my $dir (@dirname) {
Petr Baudis16fdb482006-09-21 02:05:50 +0200[diff] [blame]4623 $fullname .= ($fullname ? '/' : '') . $dir;
Jakub Narebski762c7202006-09-04 18:17:58 +0200[diff] [blame]4624 print $cgi->a({-href => href(action=>"tree", file_name=>$fullname,
4625 hash_base=>$hb),
Jakub Narebskiedc04e92007-03-07 02:21:25 +0100[diff] [blame]4626 -title => $fullname}, esc_path($dir));
Petr Baudis26d0a972006-09-23 01:00:12 +0200[diff] [blame]4627 print " / ";
Jakub Narebski762c7202006-09-04 18:17:58 +0200[diff] [blame]4628 }
4629 if (defined $type && $type eq 'blob') {
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]4630 print $cgi->a({-href => href(action=>"blob_plain", file_name=>$file_name,
Jakub Narebski762c7202006-09-04 18:17:58 +0200[diff] [blame]4631 hash_base=>$hb),
Jakub Narebskiedc04e92007-03-07 02:21:25 +0100[diff] [blame]4632 -title => $name}, esc_path($basename));
Jakub Narebski762c7202006-09-04 18:17:58 +0200[diff] [blame]4633 } elsif (defined $type && $type eq 'tree') {
4634 print $cgi->a({-href => href(action=>"tree", file_name=>$file_name,
4635 hash_base=>$hb),
Jakub Narebskiedc04e92007-03-07 02:21:25 +0100[diff] [blame]4636 -title => $name}, esc_path($basename));
Jakub Narebski4df118e2006-10-21 17:53:55 +0200[diff] [blame]4637 print " / ";
Luben Tuikov59fb1c92006-08-17 10:39:29 -0700[diff] [blame]4638 } else {
Jakub Narebski403d0902006-11-08 11:48:56 +0100[diff] [blame]4639 print esc_path($basename);
Luben Tuikov59fb1c92006-08-17 10:39:29 -0700[diff] [blame]4640 }
Kay Sievers8ed23e12005-08-07 20:05:44 +0200[diff] [blame]4641 }
Jakub Narebski4df118e2006-10-21 17:53:55 +0200[diff] [blame]4642 print "<br/></div>\n";
Kay Sievers4c02e3c2005-08-07 19:52:52 +0200[diff] [blame]4643}
4644
Jakub Narebski74fd8722009-05-07 19:11:29 +0200[diff] [blame]4645sub git_print_log {
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4646 my $log = shift;
Jakub Narebskib7f92532006-08-28 14:48:10 +0200[diff] [blame]4647 my %opts = @_;
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4648
Jakub Narebskib7f92532006-08-28 14:48:10 +0200[diff] [blame]4649 if ($opts{'-remove_title'}) {
4650 # remove title, i.e. first line of log
4651 shift @$log;
4652 }
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4653 # remove leading empty lines
4654 while (defined $log->[0] && $log->[0] eq "") {
4655 shift @$log;
4656 }
4657
4658 # print log
Namhyung Kim5a45c0c2012-07-04 11:47:24 +0900[diff] [blame]4659 my $skip_blank_line = 0;
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4660 foreach my $line (@$log) {
Emma Brooks4d9378b2020-04-25 02:17:23 +0000[diff] [blame]4661 if ($line =~ m/^\s*([A-Z][-A-Za-z]*-([Bb]y|[Tt]o)|C[Cc]|(Clos|Fix)es): /) {
Jakub Narebskib7f92532006-08-28 14:48:10 +0200[diff] [blame]4662 if (! $opts{'-remove_signoff'}) {
4663 print "<span class=\"signoff\">" . esc_html($line) . "</span><br/>\n";
Namhyung Kim5a45c0c2012-07-04 11:47:24 +0900[diff] [blame]4664 $skip_blank_line = 1;
Jakub Narebskib7f92532006-08-28 14:48:10 +0200[diff] [blame]4665 }
Namhyung Kim5a45c0c2012-07-04 11:47:24 +0900[diff] [blame]4666 next;
Jakub Narebskib7f92532006-08-28 14:48:10 +0200[diff] [blame]4667 }
4668
Namhyung Kim66c857e2012-07-04 11:47:26 +0900[diff] [blame]4669 if ($line =~ m,\s*([a-z]*link): (https?://\S+),i) {
4670 if (! $opts{'-remove_signoff'}) {
4671 print "<span class=\"signoff\">" . esc_html($1) . ": " .
4672 "<a href=\"" . esc_html($2) . "\">" . esc_html($2) . "</a>" .
4673 "</span><br/>\n";
4674 $skip_blank_line = 1;
4675 }
4676 next;
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4677 }
4678
4679 # print only one empty line
4680 # do not print empty line after signoff
4681 if ($line eq "") {
Namhyung Kim5a45c0c2012-07-04 11:47:24 +0900[diff] [blame]4682 next if ($skip_blank_line);
4683 $skip_blank_line = 1;
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4684 } else {
Namhyung Kim5a45c0c2012-07-04 11:47:24 +0900[diff] [blame]4685 $skip_blank_line = 0;
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4686 }
Jakub Narebskib7f92532006-08-28 14:48:10 +0200[diff] [blame]4687
4688 print format_log_line_html($line) . "<br/>\n";
4689 }
4690
4691 if ($opts{'-final_empty_line'}) {
4692 # end with single empty line
Namhyung Kim5a45c0c2012-07-04 11:47:24 +0900[diff] [blame]4693 print "<br/>\n" unless $skip_blank_line;
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]4694 }
4695}
4696
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4697# return link target (what link points to)
4698sub git_get_link_target {
4699 my $hash = shift;
4700 my $link_target;
4701
4702 # read link
4703 open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
4704 or return;
4705 {
Jakub Narebski34122b52009-05-11 03:29:40 +0200[diff] [blame]4706 local $/ = undef;
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4707 $link_target = <$fd>;
4708 }
4709 close $fd
4710 or return;
4711
4712 return $link_target;
4713}
4714
Jakub Narebski3bf9d572006-12-10 13:25:48 +0100[diff] [blame]4715# given link target, and the directory (basedir) the link is in,
4716# return target of link relative to top directory (top tree);
4717# return undef if it is not possible (including absolute links).
4718sub normalize_link_target {
Jakub Narebski15c54fe2009-05-11 19:45:11 +0200[diff] [blame]4719 my ($link_target, $basedir) = @_;
Jakub Narebski3bf9d572006-12-10 13:25:48 +0100[diff] [blame]4720
4721 # absolute symlinks (beginning with '/') cannot be normalized
4722 return if (substr($link_target, 0, 1) eq '/');
4723
4724 # normalize link target to path from top (root) tree (dir)
4725 my $path;
4726 if ($basedir) {
4727 $path = $basedir . '/' . $link_target;
4728 } else {
4729 # we are in top (root) tree (dir)
4730 $path = $link_target;
4731 }
4732
4733 # remove //, /./, and /../
4734 my @path_parts;
4735 foreach my $part (split('/', $path)) {
4736 # discard '.' and ''
4737 next if (!$part || $part eq '.');
4738 # handle '..'
4739 if ($part eq '..') {
4740 if (@path_parts) {
4741 pop @path_parts;
4742 } else {
4743 # link leads outside repository (outside top dir)
4744 return;
4745 }
4746 } else {
4747 push @path_parts, $part;
4748 }
4749 }
4750 $path = join('/', @path_parts);
4751
4752 return $path;
4753}
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4754
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4755# print tree entry (row of git_tree), but without encompassing <tr> element
4756sub git_print_tree_entry {
4757 my ($t, $basedir, $hash_base, $have_blame) = @_;
4758
4759 my %base_key = ();
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4760 $base_key{'hash_base'} = $hash_base if defined $hash_base;
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4761
Luben Tuikov4de741b2006-09-25 22:38:16 -0700[diff] [blame]4762 # The format of a table row is: mode list link. Where mode is
4763 # the mode of the entry, list is the name of the entry, an href,
4764 # and link is the action links of the entry.
4765
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4766 print "<td class=\"mode\">" . mode_str($t->{'mode'}) . "</td>\n";
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]4767 if (exists $t->{'size'}) {
4768 print "<td class=\"size\">$t->{'size'}</td>\n";
4769 }
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4770 if ($t->{'type'} eq "blob") {
4771 print "<td class=\"list\">" .
Luben Tuikov4de741b2006-09-25 22:38:16 -0700[diff] [blame]4772 $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
Jakub Narebskie7fb0222006-10-21 17:52:19 +0200[diff] [blame]4773 file_name=>"$basedir$t->{'name'}", %base_key),
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4774 -class => "list"}, esc_path($t->{'name'}));
4775 if (S_ISLNK(oct $t->{'mode'})) {
4776 my $link_target = git_get_link_target($t->{'hash'});
4777 if ($link_target) {
Jakub Narebski15c54fe2009-05-11 19:45:11 +0200[diff] [blame]4778 my $norm_target = normalize_link_target($link_target, $basedir);
Jakub Narebski3bf9d572006-12-10 13:25:48 +0100[diff] [blame]4779 if (defined $norm_target) {
4780 print " -> " .
4781 $cgi->a({-href => href(action=>"object", hash_base=>$hash_base,
4782 file_name=>$norm_target),
4783 -title => $norm_target}, esc_path($link_target));
4784 } else {
4785 print " -> " . esc_path($link_target);
4786 }
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4787 }
4788 }
4789 print "</td>\n";
Luben Tuikov4de741b2006-09-25 22:38:16 -0700[diff] [blame]4790 print "<td class=\"link\">";
Petr Baudis4777b012006-10-24 05:36:10 +0200[diff] [blame]4791 print $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4792 file_name=>"$basedir$t->{'name'}", %base_key)},
4793 "blob");
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4794 if ($have_blame) {
Petr Baudis4777b012006-10-24 05:36:10 +0200[diff] [blame]4795 print " | " .
4796 $cgi->a({-href => href(action=>"blame", hash=>$t->{'hash'},
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4797 file_name=>"$basedir$t->{'name'}", %base_key)},
4798 "blame");
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4799 }
4800 if (defined $hash_base) {
Petr Baudis4777b012006-10-24 05:36:10 +0200[diff] [blame]4801 print " | " .
4802 $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4803 hash=>$t->{'hash'}, file_name=>"$basedir$t->{'name'}")},
4804 "history");
4805 }
4806 print " | " .
Luben Tuikov6f7ea5f2006-09-29 09:57:43 -0700[diff] [blame]4807 $cgi->a({-href => href(action=>"blob_plain", hash_base=>$hash_base,
Jakub Narebskie7fb0222006-10-21 17:52:19 +0200[diff] [blame]4808 file_name=>"$basedir$t->{'name'}")},
4809 "raw");
Luben Tuikov4de741b2006-09-25 22:38:16 -0700[diff] [blame]4810 print "</td>\n";
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4811
4812 } elsif ($t->{'type'} eq "tree") {
Luben Tuikov0fa105e2006-09-26 12:45:37 -0700[diff] [blame]4813 print "<td class=\"list\">";
4814 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]4815 file_name=>"$basedir$t->{'name'}",
4816 %base_key)},
Jakub Narebski403d0902006-11-08 11:48:56 +0100[diff] [blame]4817 esc_path($t->{'name'}));
Luben Tuikov0fa105e2006-09-26 12:45:37 -0700[diff] [blame]4818 print "</td>\n";
4819 print "<td class=\"link\">";
Petr Baudis4777b012006-10-24 05:36:10 +0200[diff] [blame]4820 print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]4821 file_name=>"$basedir$t->{'name'}",
4822 %base_key)},
Jakub Narebskie33fba42006-12-10 13:25:46 +0100[diff] [blame]4823 "tree");
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4824 if (defined $hash_base) {
Petr Baudis4777b012006-10-24 05:36:10 +0200[diff] [blame]4825 print " | " .
4826 $cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4827 file_name=>"$basedir$t->{'name'}")},
4828 "history");
4829 }
4830 print "</td>\n";
Jakub Narebski01ac1e32007-07-28 16:27:31 +0200[diff] [blame]4831 } else {
4832 # unknown object: we can only present history for it
4833 # (this includes 'commit' object, i.e. submodule support)
4834 print "<td class=\"list\">" .
4835 esc_path($t->{'name'}) .
4836 "</td>\n";
4837 print "<td class=\"link\">";
4838 if (defined $hash_base) {
4839 print $cgi->a({-href => href(action=>"history",
4840 hash_base=>$hash_base,
4841 file_name=>"$basedir$t->{'name'}")},
4842 "history");
4843 }
4844 print "</td>\n";
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]4845 }
4846}
4847
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]4848## ......................................................................
4849## functions printing large fragments of HTML
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]4850
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]4851# get pre-image filenames for merge (combined) diff
Jakub Narebskie72c0ea2007-05-07 01:10:05 +0200[diff] [blame]4852sub fill_from_file_info {
4853 my ($diff, @parents) = @_;
4854
4855 $diff->{'from_file'} = [ ];
4856 $diff->{'from_file'}[$diff->{'nparents'} - 1] = undef;
4857 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
4858 if ($diff->{'status'}[$i] eq 'R' ||
4859 $diff->{'status'}[$i] eq 'C') {
4860 $diff->{'from_file'}[$i] =
4861 git_get_path_by_hash($parents[$i], $diff->{'from_id'}[$i]);
4862 }
4863 }
4864
4865 return $diff;
4866}
4867
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]4868# is current raw difftree line of file deletion
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]4869sub is_deleted {
4870 my $diffinfo = shift;
4871
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]4872 return $diffinfo->{'to_id'} eq ('0' x 40) || $diffinfo->{'to_id'} eq ('0' x 64);
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]4873}
Jakub Narebskie72c0ea2007-05-07 01:10:05 +0200[diff] [blame]4874
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]4875# does patch correspond to [previous] difftree raw line
4876# $diffinfo - hashref of parsed raw diff format
4877# $patchinfo - hashref of parsed patch diff format
4878# (the same keys as in $diffinfo)
4879sub is_patch_split {
4880 my ($diffinfo, $patchinfo) = @_;
4881
4882 return defined $diffinfo && defined $patchinfo
Jakub Narebski9d301452007-11-01 12:38:08 +0100[diff] [blame]4883 && $diffinfo->{'to_file'} eq $patchinfo->{'to_file'};
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]4884}
4885
4886
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]4887sub git_difftree_body {
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4888 my ($difftree, $hash, @parents) = @_;
4889 my ($parent) = $parents[0];
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]4890 my $have_blame = gitweb_check_feature('blame');
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]4891 print "<div class=\"list_head\">\n";
4892 if ($#{$difftree} > 10) {
4893 print(($#{$difftree} + 1) . " files changed:\n");
4894 }
4895 print "</div>\n";
4896
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4897 print "<table class=\"" .
4898 (@parents > 1 ? "combined " : "") .
4899 "diff_tree\">\n";
Jakub Narebski47598d72007-06-08 13:24:56 +0200[diff] [blame]4900
4901 # header only for combined diff in 'commitdiff' view
Jakub Narebski3ef408a2007-09-08 21:54:28 +0200[diff] [blame]4902 my $has_header = @$difftree && @parents > 1 && $action eq 'commitdiff';
Jakub Narebski47598d72007-06-08 13:24:56 +0200[diff] [blame]4903 if ($has_header) {
4904 # table header
4905 print "<thead><tr>\n" .
4906 "<th></th><th></th>\n"; # filename, patchN link
4907 for (my $i = 0; $i < @parents; $i++) {
4908 my $par = $parents[$i];
4909 print "<th>" .
4910 $cgi->a({-href => href(action=>"commitdiff",
4911 hash=>$hash, hash_parent=>$par),
4912 -title => 'commitdiff to parent number ' .
4913 ($i+1) . ': ' . substr($par,0,7)},
4914 $i+1) .
4915 "&nbsp;</th>\n";
4916 }
4917 print "</tr></thead>\n<tbody>\n";
4918 }
4919
Luben Tuikov6dd36ac2006-09-28 16:47:50 -0700[diff] [blame]4920 my $alternate = 1;
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]4921 my $patchno = 0;
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]4922 foreach my $line (@{$difftree}) {
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]4923 my $diff = parsed_difftree_line($line);
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]4924
4925 if ($alternate) {
4926 print "<tr class=\"dark\">\n";
4927 } else {
4928 print "<tr class=\"light\">\n";
4929 }
4930 $alternate ^= 1;
4931
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4932 if (exists $diff->{'nparents'}) { # combined diff
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4933
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4934 fill_from_file_info($diff, @parents)
4935 unless exists $diff->{'from_file'};
Jakub Narebskie72c0ea2007-05-07 01:10:05 +0200[diff] [blame]4936
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]4937 if (!is_deleted($diff)) {
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4938 # file exists in the result (child) commit
4939 print "<td>" .
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4940 $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
4941 file_name=>$diff->{'to_file'},
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4942 hash_base=>$hash),
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4943 -class => "list"}, esc_path($diff->{'to_file'})) .
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4944 "</td>\n";
4945 } else {
4946 print "<td>" .
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4947 esc_path($diff->{'to_file'}) .
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4948 "</td>\n";
4949 }
4950
4951 if ($action eq 'commitdiff') {
4952 # link to patch
4953 $patchno++;
4954 print "<td class=\"link\">" .
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]4955 $cgi->a({-href => href(-anchor=>"patch$patchno")},
4956 "patch") .
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4957 " | " .
4958 "</td>\n";
4959 }
4960
4961 my $has_history = 0;
4962 my $not_deleted = 0;
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4963 for (my $i = 0; $i < $diff->{'nparents'}; $i++) {
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4964 my $hash_parent = $parents[$i];
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4965 my $from_hash = $diff->{'from_id'}[$i];
4966 my $from_path = $diff->{'from_file'}[$i];
4967 my $status = $diff->{'status'}[$i];
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4968
4969 $has_history ||= ($status ne 'A');
4970 $not_deleted ||= ($status ne 'D');
4971
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4972 if ($status eq 'A') {
4973 print "<td class=\"link\" align=\"right\"> | </td>\n";
4974 } elsif ($status eq 'D') {
4975 print "<td class=\"link\">" .
4976 $cgi->a({-href => href(action=>"blob",
4977 hash_base=>$hash,
4978 hash=>$from_hash,
4979 file_name=>$from_path)},
4980 "blob" . ($i+1)) .
4981 " | </td>\n";
4982 } else {
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4983 if ($diff->{'to_id'} eq $from_hash) {
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4984 print "<td class=\"link nochange\">";
4985 } else {
4986 print "<td class=\"link\">";
4987 }
4988 print $cgi->a({-href => href(action=>"blobdiff",
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4989 hash=>$diff->{'to_id'},
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4990 hash_parent=>$from_hash,
4991 hash_base=>$hash,
4992 hash_parent_base=>$hash_parent,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]4993 file_name=>$diff->{'to_file'},
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]4994 file_parent=>$from_path)},
4995 "diff" . ($i+1)) .
4996 " | </td>\n";
4997 }
4998 }
4999
5000 print "<td class=\"link\">";
5001 if ($not_deleted) {
5002 print $cgi->a({-href => href(action=>"blob",
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5003 hash=>$diff->{'to_id'},
5004 file_name=>$diff->{'to_file'},
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]5005 hash_base=>$hash)},
5006 "blob");
5007 print " | " if ($has_history);
5008 }
5009 if ($has_history) {
5010 print $cgi->a({-href => href(action=>"history",
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5011 file_name=>$diff->{'to_file'},
Jakub Narebskied224de2007-05-07 01:10:04 +0200[diff] [blame]5012 hash_base=>$hash)},
5013 "history");
5014 }
5015 print "</td>\n";
5016
5017 print "</tr>\n";
5018 next; # instead of 'else' clause, to avoid extra indent
5019 }
5020 # else ordinary diff
5021
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5022 my ($to_mode_oct, $to_mode_str, $to_file_type);
5023 my ($from_mode_oct, $from_mode_str, $from_file_type);
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5024 if ($diff->{'to_mode'} ne ('0' x 6)) {
5025 $to_mode_oct = oct $diff->{'to_mode'};
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5026 if (S_ISREG($to_mode_oct)) { # only for regular file
5027 $to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5028 }
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5029 $to_file_type = file_type($diff->{'to_mode'});
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5030 }
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5031 if ($diff->{'from_mode'} ne ('0' x 6)) {
5032 $from_mode_oct = oct $diff->{'from_mode'};
Ævar Arnfjörð Bjarmason98885c22011-02-19 15:27:42 +0000[diff] [blame]5033 if (S_ISREG($from_mode_oct)) { # only for regular file
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5034 $from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
5035 }
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5036 $from_file_type = file_type($diff->{'from_mode'});
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5037 }
5038
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5039 if ($diff->{'status'} eq "A") { # created
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5040 my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
5041 $mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
5042 $mode_chng .= "]</span>";
Luben Tuikov499faed2006-09-27 17:23:25 -0700[diff] [blame]5043 print "<td>";
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5044 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
5045 hash_base=>$hash, file_name=>$diff->{'file'}),
5046 -class => "list"}, esc_path($diff->{'file'}));
Luben Tuikov499faed2006-09-27 17:23:25 -0700[diff] [blame]5047 print "</td>\n";
5048 print "<td>$mode_chng</td>\n";
5049 print "<td class=\"link\">";
Jakub Narebski72dbafa2006-09-04 18:19:58 +0200[diff] [blame]5050 if ($action eq 'commitdiff') {
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]5051 # link to patch
5052 $patchno++;
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]5053 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
5054 "patch") .
5055 " | ";
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]5056 }
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5057 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
5058 hash_base=>$hash, file_name=>$diff->{'file'})},
Jakub Narebski3faa5412007-01-08 02:10:42 +0100[diff] [blame]5059 "blob");
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]5060 print "</td>\n";
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5061
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5062 } elsif ($diff->{'status'} eq "D") { # deleted
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5063 my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
Luben Tuikov499faed2006-09-27 17:23:25 -0700[diff] [blame]5064 print "<td>";
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5065 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
5066 hash_base=>$parent, file_name=>$diff->{'file'}),
5067 -class => "list"}, esc_path($diff->{'file'}));
Luben Tuikov499faed2006-09-27 17:23:25 -0700[diff] [blame]5068 print "</td>\n";
5069 print "<td>$mode_chng</td>\n";
5070 print "<td class=\"link\">";
Jakub Narebski72dbafa2006-09-04 18:19:58 +0200[diff] [blame]5071 if ($action eq 'commitdiff') {
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]5072 # link to patch
5073 $patchno++;
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]5074 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
5075 "patch") .
5076 " | ";
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]5077 }
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5078 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'from_id'},
5079 hash_base=>$parent, file_name=>$diff->{'file'})},
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5080 "blob") . " | ";
Junio C Hamano2b2a8c72006-11-08 12:22:04 -0800[diff] [blame]5081 if ($have_blame) {
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5082 print $cgi->a({-href => href(action=>"blame", hash_base=>$parent,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5083 file_name=>$diff->{'file'})},
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5084 "blame") . " | ";
Junio C Hamano2b2a8c72006-11-08 12:22:04 -0800[diff] [blame]5085 }
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]5086 print $cgi->a({-href => href(action=>"history", hash_base=>$parent,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5087 file_name=>$diff->{'file'})},
Jakub Narebskie7fb0222006-10-21 17:52:19 +0200[diff] [blame]5088 "history");
Luben Tuikov499faed2006-09-27 17:23:25 -0700[diff] [blame]5089 print "</td>\n";
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5090
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5091 } elsif ($diff->{'status'} eq "M" || $diff->{'status'} eq "T") { # modified, or type changed
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5092 my $mode_chnge = "";
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5093 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5094 $mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
Jakub Narebski6e72cf42007-01-03 20:47:24 +0100[diff] [blame]5095 if ($from_file_type ne $to_file_type) {
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5096 $mode_chnge .= " from $from_file_type to $to_file_type";
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5097 }
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5098 if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
5099 if ($from_mode_str && $to_mode_str) {
5100 $mode_chnge .= " mode: $from_mode_str->$to_mode_str";
5101 } elsif ($to_mode_str) {
5102 $mode_chnge .= " mode: $to_mode_str";
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5103 }
5104 }
5105 $mode_chnge .= "]</span>\n";
5106 }
5107 print "<td>";
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5108 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
5109 hash_base=>$hash, file_name=>$diff->{'file'}),
5110 -class => "list"}, esc_path($diff->{'file'}));
Luben Tuikov499faed2006-09-27 17:23:25 -0700[diff] [blame]5111 print "</td>\n";
5112 print "<td>$mode_chnge</td>\n";
5113 print "<td class=\"link\">";
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5114 if ($action eq 'commitdiff') {
5115 # link to patch
5116 $patchno++;
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]5117 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
5118 "patch") .
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5119 " | ";
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5120 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5121 # "commit" view and modified file (not onlu mode changed)
5122 print $cgi->a({-href => href(action=>"blobdiff",
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5123 hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5124 hash_base=>$hash, hash_parent_base=>$parent,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5125 file_name=>$diff->{'file'})},
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5126 "diff") .
5127 " | ";
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5128 }
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5129 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
5130 hash_base=>$hash, file_name=>$diff->{'file'})},
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5131 "blob") . " | ";
Junio C Hamano2b2a8c72006-11-08 12:22:04 -0800[diff] [blame]5132 if ($have_blame) {
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5133 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5134 file_name=>$diff->{'file'})},
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5135 "blame") . " | ";
Junio C Hamano2b2a8c72006-11-08 12:22:04 -0800[diff] [blame]5136 }
Luben Tuikoveb51ec92006-09-27 17:24:49 -0700[diff] [blame]5137 print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5138 file_name=>$diff->{'file'})},
Jakub Narebskie7fb0222006-10-21 17:52:19 +0200[diff] [blame]5139 "history");
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5140 print "</td>\n";
5141
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5142 } elsif ($diff->{'status'} eq "R" || $diff->{'status'} eq "C") { # renamed or copied
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5143 my %status_name = ('R' => 'moved', 'C' => 'copied');
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5144 my $nstatus = $status_name{$diff->{'status'}};
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5145 my $mode_chng = "";
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5146 if ($diff->{'from_mode'} != $diff->{'to_mode'}) {
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5147 # mode also for directories, so we cannot use $to_mode_str
5148 $mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5149 }
5150 print "<td>" .
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5151 $cgi->a({-href => href(action=>"blob", hash_base=>$hash,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5152 hash=>$diff->{'to_id'}, file_name=>$diff->{'to_file'}),
5153 -class => "list"}, esc_path($diff->{'to_file'})) . "</td>\n" .
Jakub Narebskie8e41a92006-08-21 23:08:52 +0200[diff] [blame]5154 "<td><span class=\"file_status $nstatus\">[$nstatus from " .
5155 $cgi->a({-href => href(action=>"blob", hash_base=>$parent,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5156 hash=>$diff->{'from_id'}, file_name=>$diff->{'from_file'}),
5157 -class => "list"}, esc_path($diff->{'from_file'})) .
5158 " with " . (int $diff->{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
Luben Tuikov499faed2006-09-27 17:23:25 -0700[diff] [blame]5159 "<td class=\"link\">";
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5160 if ($action eq 'commitdiff') {
5161 # link to patch
5162 $patchno++;
Kevin Cernekee5e96a842011-03-18 17:00:16 +0100[diff] [blame]5163 print $cgi->a({-href => href(-anchor=>"patch$patchno")},
5164 "patch") .
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5165 " | ";
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5166 } elsif ($diff->{'to_id'} ne $diff->{'from_id'}) {
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5167 # "commit" view and modified file (not only pure rename or copy)
5168 print $cgi->a({-href => href(action=>"blobdiff",
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5169 hash=>$diff->{'to_id'}, hash_parent=>$diff->{'from_id'},
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5170 hash_base=>$hash, hash_parent_base=>$parent,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5171 file_name=>$diff->{'to_file'}, file_parent=>$diff->{'from_file'})},
Jakub Narebski241cc592006-10-31 17:36:27 +0100[diff] [blame]5172 "diff") .
5173 " | ";
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5174 }
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5175 print $cgi->a({-href => href(action=>"blob", hash=>$diff->{'to_id'},
5176 hash_base=>$parent, file_name=>$diff->{'to_file'})},
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5177 "blob") . " | ";
Junio C Hamano2b2a8c72006-11-08 12:22:04 -0800[diff] [blame]5178 if ($have_blame) {
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5179 print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5180 file_name=>$diff->{'to_file'})},
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5181 "blame") . " | ";
Junio C Hamano2b2a8c72006-11-08 12:22:04 -0800[diff] [blame]5182 }
Jakub Narebski897d1d22006-11-19 22:51:39 +0100[diff] [blame]5183 print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]5184 file_name=>$diff->{'to_file'})},
Jakub Narebskie7fb0222006-10-21 17:52:19 +0200[diff] [blame]5185 "history");
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5186 print "</td>\n";
5187
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5188 } # we should not encounter Unmerged (U) or Unknown (X) status
5189 print "</tr>\n";
5190 }
Jakub Narebski47598d72007-06-08 13:24:56 +0200[diff] [blame]5191 print "</tbody>" if $has_header;
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]5192 print "</table>\n";
5193}
5194
Michał Kiedrowiczd21102c2012-04-11 23:18:40 +0200[diff] [blame]5195# Print context lines and then rem/add lines in a side-by-side manner.
5196sub print_sidebyside_diff_lines {
5197 my ($ctx, $rem, $add) = @_;
5198
5199 # print context block before add/rem block
5200 if (@$ctx) {
5201 print join '',
5202 '<div class="chunk_block ctx">',
5203 '<div class="old">',
5204 @$ctx,
5205 '</div>',
5206 '<div class="new">',
5207 @$ctx,
5208 '</div>',
5209 '</div>';
5210 }
5211
5212 if (!@$add) {
5213 # pure removal
5214 print join '',
5215 '<div class="chunk_block rem">',
5216 '<div class="old">',
5217 @$rem,
5218 '</div>',
5219 '</div>';
5220 } elsif (!@$rem) {
5221 # pure addition
5222 print join '',
5223 '<div class="chunk_block add">',
5224 '<div class="new">',
5225 @$add,
5226 '</div>',
5227 '</div>';
5228 } else {
5229 print join '',
5230 '<div class="chunk_block chg">',
5231 '<div class="old">',
5232 @$rem,
5233 '</div>',
5234 '<div class="new">',
5235 @$add,
5236 '</div>',
5237 '</div>';
5238 }
5239}
5240
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5241# Print context lines and then rem/add lines in inline manner.
5242sub print_inline_diff_lines {
5243 my ($ctx, $rem, $add) = @_;
5244
5245 print @$ctx, @$rem, @$add;
5246}
5247
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5248# Format removed and added line, mark changed part and HTML-format them.
5249# Implementation is based on contrib/diff-highlight
5250sub format_rem_add_lines_pair {
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5251 my ($rem, $add, $num_parents) = @_;
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5252
5253 # We need to untabify lines before split()'ing them;
5254 # otherwise offsets would be invalid.
5255 chomp $rem;
5256 chomp $add;
5257 $rem = untabify($rem);
5258 $add = untabify($add);
5259
5260 my @rem = split(//, $rem);
5261 my @add = split(//, $add);
5262 my ($esc_rem, $esc_add);
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5263 # Ignore leading +/- characters for each parent.
5264 my ($prefix_len, $suffix_len) = ($num_parents, 0);
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5265 my ($prefix_has_nonspace, $suffix_has_nonspace);
5266
5267 my $shorter = (@rem < @add) ? @rem : @add;
5268 while ($prefix_len < $shorter) {
5269 last if ($rem[$prefix_len] ne $add[$prefix_len]);
5270
5271 $prefix_has_nonspace = 1 if ($rem[$prefix_len] !~ /\s/);
5272 $prefix_len++;
5273 }
5274
5275 while ($prefix_len + $suffix_len < $shorter) {
5276 last if ($rem[-1 - $suffix_len] ne $add[-1 - $suffix_len]);
5277
5278 $suffix_has_nonspace = 1 if ($rem[-1 - $suffix_len] !~ /\s/);
5279 $suffix_len++;
5280 }
5281
5282 # Mark lines that are different from each other, but have some common
5283 # part that isn't whitespace. If lines are completely different, don't
5284 # mark them because that would make output unreadable, especially if
5285 # diff consists of multiple lines.
5286 if ($prefix_has_nonspace || $suffix_has_nonspace) {
5287 $esc_rem = esc_html_hl_regions($rem, 'marked',
5288 [$prefix_len, @rem - $suffix_len], -nbsp=>1);
5289 $esc_add = esc_html_hl_regions($add, 'marked',
5290 [$prefix_len, @add - $suffix_len], -nbsp=>1);
5291 } else {
5292 $esc_rem = esc_html($rem, -nbsp=>1);
5293 $esc_add = esc_html($add, -nbsp=>1);
5294 }
5295
5296 return format_diff_line(\$esc_rem, 'rem'),
5297 format_diff_line(\$esc_add, 'add');
5298}
5299
5300# HTML-format diff context, removed and added lines.
5301sub format_ctx_rem_add_lines {
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5302 my ($ctx, $rem, $add, $num_parents) = @_;
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5303 my (@new_ctx, @new_rem, @new_add);
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5304 my $can_highlight = 0;
5305 my $is_combined = ($num_parents > 1);
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5306
5307 # Highlight if every removed line has a corresponding added line.
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5308 if (@$add > 0 && @$add == @$rem) {
5309 $can_highlight = 1;
5310
5311 # Highlight lines in combined diff only if the chunk contains
5312 # diff between the same version, e.g.
5313 #
5314 # - a
5315 # - b
5316 # + c
5317 # + d
5318 #
Denis Ovsienko4e2c4c02020-01-04 18:39:26 +0100[diff] [blame]5319 # Otherwise the highlighting would be confusing.
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5320 if ($is_combined) {
5321 for (my $i = 0; $i < @$add; $i++) {
5322 my $prefix_rem = substr($rem->[$i], 0, $num_parents);
5323 my $prefix_add = substr($add->[$i], 0, $num_parents);
5324
5325 $prefix_rem =~ s/-/+/g;
5326
5327 if ($prefix_rem ne $prefix_add) {
5328 $can_highlight = 0;
5329 last;
5330 }
5331 }
5332 }
5333 }
5334
5335 if ($can_highlight) {
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5336 for (my $i = 0; $i < @$add; $i++) {
5337 my ($line_rem, $line_add) = format_rem_add_lines_pair(
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5338 $rem->[$i], $add->[$i], $num_parents);
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5339 push @new_rem, $line_rem;
5340 push @new_add, $line_add;
5341 }
5342 } else {
5343 @new_rem = map { format_diff_line($_, 'rem') } @$rem;
5344 @new_add = map { format_diff_line($_, 'add') } @$add;
5345 }
5346
5347 @new_ctx = map { format_diff_line($_, 'ctx') } @$ctx;
5348
5349 return (\@new_ctx, \@new_rem, \@new_add);
5350}
5351
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5352# Print context lines and then rem/add lines.
5353sub print_diff_lines {
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5354 my ($ctx, $rem, $add, $diff_style, $num_parents) = @_;
5355 my $is_combined = $num_parents > 1;
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5356
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5357 ($ctx, $rem, $add) = format_ctx_rem_add_lines($ctx, $rem, $add,
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5358 $num_parents);
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5359
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5360 if ($diff_style eq 'sidebyside' && !$is_combined) {
5361 print_sidebyside_diff_lines($ctx, $rem, $add);
5362 } else {
5363 # default 'inline' style and unknown styles
5364 print_inline_diff_lines($ctx, $rem, $add);
5365 }
5366}
5367
5368sub print_diff_chunk {
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5369 my ($diff_style, $num_parents, $from, $to, @chunk) = @_;
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5370 my (@ctx, @rem, @add);
5371
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5372 # The class of the previous line.
5373 my $prev_class = '';
5374
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5375 return unless @chunk;
5376
5377 # incomplete last line might be among removed or added lines,
5378 # or both, or among context lines: find which
5379 for (my $i = 1; $i < @chunk; $i++) {
5380 if ($chunk[$i][0] eq 'incomplete') {
5381 $chunk[$i][0] = $chunk[$i-1][0];
5382 }
5383 }
5384
5385 # guardian
5386 push @chunk, ["", ""];
5387
5388 foreach my $line_info (@chunk) {
5389 my ($class, $line) = @$line_info;
5390
5391 # print chunk headers
5392 if ($class && $class eq 'chunk_header') {
Michał Kiedrowicz5fb6ddf2012-04-11 23:18:43 +0200[diff] [blame]5393 print format_diff_line($line, $class, $from, $to);
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5394 next;
5395 }
5396
Michał Kiedrowiczd21102c2012-04-11 23:18:40 +0200[diff] [blame]5397 ## print from accumulator when have some add/rem lines or end
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5398 # of chunk (flush context lines), or when have add and rem
5399 # lines and new block is reached (otherwise add/rem lines could
5400 # be reordered)
5401 if (!$class || ((@rem || @add) && $class eq 'ctx') ||
5402 (@rem && @add && $class ne $prev_class)) {
5403 print_diff_lines(\@ctx, \@rem, \@add,
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5404 $diff_style, $num_parents);
Michał Kiedrowiczd21102c2012-04-11 23:18:40 +0200[diff] [blame]5405 @ctx = @rem = @add = ();
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5406 }
5407
5408 ## adding lines to accumulator
5409 # guardian value
5410 last unless $line;
5411 # rem, add or change
5412 if ($class eq 'rem') {
5413 push @rem, $line;
5414 } elsif ($class eq 'add') {
5415 push @add, $line;
5416 }
5417 # context line
5418 if ($class eq 'ctx') {
5419 push @ctx, $line;
5420 }
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5421
5422 $prev_class = $class;
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5423 }
5424}
5425
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5426sub git_patchset_body {
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5427 my ($fd, $diff_style, $difftree, $hash, @hash_parents) = @_;
Jakub Narebskie72c0ea2007-05-07 01:10:05 +0200[diff] [blame]5428 my ($hash_parent) = $hash_parents[0];
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5429
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5430 my $is_combined = (@hash_parents > 1);
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5431 my $patch_idx = 0;
Martin Koegler4280cde2007-04-22 22:49:25 -0700[diff] [blame]5432 my $patch_number = 0;
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5433 my $patch_line;
Jakub Narebskife875852006-08-25 20:59:39 +0200[diff] [blame]5434 my $diffinfo;
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5435 my $to_name;
Jakub Narebski744d0ac2006-11-08 17:59:41 +0100[diff] [blame]5436 my (%from, %to);
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5437 my @chunk; # for side-by-side diff
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5438
5439 print "<div class=\"patchset\">\n";
5440
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5441 # skip to first patch
5442 while ($patch_line = <$fd>) {
Jakub Narebski157e43b2006-08-24 19:34:36 +0200[diff] [blame]5443 chomp $patch_line;
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5444
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5445 last if ($patch_line =~ m/^diff /);
5446 }
5447
5448 PATCH:
5449 while ($patch_line) {
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5450
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5451 # parse "git diff" header line
5452 if ($patch_line =~ m/^diff --git (\"(?:[^\\\"]*(?:\\.[^\\\"]*)*)\"|[^ "]*) (.*)$/) {
5453 # $1 is from_name, which we do not use
5454 $to_name = unquote($2);
5455 $to_name =~ s!^b/!!;
5456 } elsif ($patch_line =~ m/^diff --(cc|combined) ("?.*"?)$/) {
5457 # $1 is 'cc' or 'combined', which we do not use
5458 $to_name = unquote($2);
5459 } else {
5460 $to_name = undef;
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5461 }
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5462
5463 # check if current patch belong to current raw line
5464 # and parse raw git-diff line if needed
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5465 if (is_patch_split($diffinfo, { 'to_file' => $to_name })) {
Jakub Narebski22065372007-05-12 12:42:32 +0200[diff] [blame]5466 # this is continuation of a split patch
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5467 print "<div class=\"patch cont\">\n";
5468 } else {
5469 # advance raw git-diff output if needed
5470 $patch_idx++ if defined $diffinfo;
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5471
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5472 # read and prepare patch information
5473 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
5474
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]5475 # compact combined diff output can have some patches skipped
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5476 # find which patch (using pathname of result) we are at now;
5477 if ($is_combined) {
5478 while ($to_name ne $diffinfo->{'to_file'}) {
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]5479 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5480 format_diff_cc_simplified($diffinfo, @hash_parents) .
5481 "</div>\n"; # class="patch"
5482
5483 $patch_idx++;
5484 $patch_number++;
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5485
5486 last if $patch_idx > $#$difftree;
5487 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]5488 }
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5489 }
Jakub Narebski711fa742007-09-08 21:49:11 +0200[diff] [blame]5490
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]5491 # modifies %from, %to hashes
5492 parse_from_to_diffinfo($diffinfo, \%from, \%to, @hash_parents);
Jakub Narebski5f855052007-05-17 22:54:28 +0200[diff] [blame]5493
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5494 # this is first patch for raw difftree line with $patch_idx index
5495 # we index @$difftree array from 0, but number patches from 1
5496 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
Jakub Narebski744d0ac2006-11-08 17:59:41 +0100[diff] [blame]5497 }
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5498
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5499 # git diff header
5500 #assert($patch_line =~ m/^diff /) if DEBUG;
5501 #assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
5502 $patch_number++;
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5503 # print "git diff" header
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]5504 print format_git_diff_header_line($patch_line, $diffinfo,
5505 \%from, \%to);
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5506
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5507 # print extended diff header
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5508 print "<div class=\"diff extended_header\">\n";
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5509 EXTENDED_HEADER:
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5510 while ($patch_line = <$fd>) {
5511 chomp $patch_line;
5512
5513 last EXTENDED_HEADER if ($patch_line =~ m/^--- |^diff /);
5514
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]5515 print format_extended_diff_header_line($patch_line, $diffinfo,
5516 \%from, \%to);
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5517 }
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5518 print "</div>\n"; # class="diff extended_header"
Jakub Narebskie4e4f822006-08-25 21:04:13 +0200[diff] [blame]5519
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5520 # from-file/to-file diff header
Jakub Narebski0bdb28c2007-01-10 00:07:43 +0100[diff] [blame]5521 if (! $patch_line) {
5522 print "</div>\n"; # class="patch"
5523 last PATCH;
5524 }
Jakub Narebski66399ef2007-01-07 02:52:25 +0100[diff] [blame]5525 next PATCH if ($patch_line =~ m/^diff /);
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5526 #assert($patch_line =~ m/^---/) if DEBUG;
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5527
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5528 my $last_patch_line = $patch_line;
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5529 $patch_line = <$fd>;
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5530 chomp $patch_line;
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]5531 #assert($patch_line =~ m/^\+\+\+/) if DEBUG;
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5532
Jakub Narebski90921742007-06-08 13:27:42 +0200[diff] [blame]5533 print format_diff_from_to_header($last_patch_line, $patch_line,
Jakub Narebski91af4ce2007-06-08 13:32:44 +0200[diff] [blame]5534 $diffinfo, \%from, \%to,
5535 @hash_parents);
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5536
5537 # the patch itself
5538 LINE:
5539 while ($patch_line = <$fd>) {
5540 chomp $patch_line;
5541
5542 next PATCH if ($patch_line =~ m/^diff /);
5543
Michał Kiedrowiczf4a81022012-04-11 23:18:42 +0200[diff] [blame]5544 my $class = diff_line_class($patch_line, \%from, \%to);
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5545
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5546 if ($class eq 'chunk_header') {
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5547 print_diff_chunk($diff_style, scalar @hash_parents, \%from, \%to, @chunk);
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5548 @chunk = ();
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5549 }
Michał Kiedrowicz44185f92012-04-11 23:18:41 +0200[diff] [blame]5550
Michał Kiedrowiczf4a81022012-04-11 23:18:42 +0200[diff] [blame]5551 push @chunk, [ $class, $patch_line ];
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5552 }
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5553
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5554 } continue {
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5555 if (@chunk) {
Michał Kiedrowicz51ef7a62012-04-11 23:18:44 +0200[diff] [blame]5556 print_diff_chunk($diff_style, scalar @hash_parents, \%from, \%to, @chunk);
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]5557 @chunk = ();
5558 }
Jakub Narebski6d55f052006-11-18 23:35:39 +0100[diff] [blame]5559 print "</div>\n"; # class="patch"
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5560 }
Jakub Narebskid26c4262007-05-17 00:05:55 +0200[diff] [blame]5561
Ralf Wildenhues22e5e582010-08-22 13:12:12 +0200[diff] [blame]5562 # for compact combined (--cc) format, with chunk and patch simplification
5563 # the patchset might be empty, but there might be unprocessed raw lines
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5564 for (++$patch_idx if $patch_number > 0;
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]5565 $patch_idx < @$difftree;
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5566 ++$patch_idx) {
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]5567 # read and prepare patch information
Jakub Narebski0cec6db2007-10-30 01:35:05 +0100[diff] [blame]5568 $diffinfo = parsed_difftree_line($difftree->[$patch_idx]);
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]5569
5570 # generate anchor for "patch" links in difftree / whatchanged part
5571 print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n" .
5572 format_diff_cc_simplified($diffinfo, @hash_parents) .
5573 "</div>\n"; # class="patch"
5574
5575 $patch_number++;
5576 }
5577
Jakub Narebskid26c4262007-05-17 00:05:55 +0200[diff] [blame]5578 if ($patch_number == 0) {
5579 if (@hash_parents > 1) {
5580 print "<div class=\"diff nodifferences\">Trivial merge</div>\n";
5581 } else {
5582 print "<div class=\"diff nodifferences\">No differences found</div>\n";
5583 }
5584 }
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]5585
5586 print "</div>\n"; # class="patchset"
5587}
5588
5589# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5590
Jakub Narebskia1e1b2d2012-01-31 01:20:54 +0100[diff] [blame]5591sub git_project_search_form {
Jakub Narebskib22939a2012-03-02 23:50:01 +0100[diff] [blame]5592 my ($searchtext, $search_use_regexp) = @_;
Jakub Narebskia1e1b2d2012-01-31 01:20:54 +0100[diff] [blame]5593
Jakub Narebskiabc0c9d2012-01-31 01:20:55 +0100[diff] [blame]5594 my $limit = '';
5595 if ($project_filter) {
5596 $limit = " in '$project_filter/'";
5597 }
5598
Jakub Narebskia1e1b2d2012-01-31 01:20:54 +0100[diff] [blame]5599 print "<div class=\"projsearch\">\n";
Roland Mas4750f4b2014-10-16 08:54:47 +0200[diff] [blame]5600 print $cgi->start_form(-method => 'get', -action => $my_uri) .
Jakub Narebskiabc0c9d2012-01-31 01:20:55 +0100[diff] [blame]5601 $cgi->hidden(-name => 'a', -value => 'project_list') . "\n";
5602 print $cgi->hidden(-name => 'pf', -value => $project_filter). "\n"
5603 if (defined $project_filter);
5604 print $cgi->textfield(-name => 's', -value => $searchtext,
5605 -title => "Search project by name and description$limit",
Jakub Narebskia1e1b2d2012-01-31 01:20:54 +0100[diff] [blame]5606 -size => 60) . "\n" .
5607 "<span title=\"Extended regular expression\">" .
5608 $cgi->checkbox(-name => 'sr', -value => 1, -label => 're',
5609 -checked => $search_use_regexp) .
5610 "</span>\n" .
5611 $cgi->submit(-name => 'btnS', -value => 'Search') .
5612 $cgi->end_form() . "\n" .
Jakub Narebskiabc0c9d2012-01-31 01:20:55 +0100[diff] [blame]5613 $cgi->a({-href => href(project => undef, searchtext => undef,
5614 project_filter => $project_filter)},
5615 esc_html("List all projects$limit")) . "<br />\n";
Jakub Narebskia1e1b2d2012-01-31 01:20:54 +0100[diff] [blame]5616 print "</div>\n";
5617}
5618
Jakub Narebski14b289b2012-02-23 16:54:46 +0100[diff] [blame]5619# entry for given @keys needs filling if at least one of keys in list
5620# is not present in %$project_info
5621sub project_info_needs_filling {
5622 my ($project_info, @keys) = @_;
5623
5624 # return List::MoreUtils::any { !exists $project_info->{$_} } @keys;
5625 foreach my $key (@keys) {
5626 if (!exists $project_info->{$key}) {
5627 return 1;
5628 }
5629 }
5630 return;
5631}
5632
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5633# fills project list info (age, description, owner, category, forks, etc.)
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]5634# for each project in the list, removing invalid projects from
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5635# returned list, or fill only specified info.
5636#
5637# Invalid projects are removed from the returned list if and only if you
5638# ask 'age' or 'age_string' to be filled, because they are the only fields
5639# that run unconditionally git command that requires repository, and
5640# therefore do always check if project repository is invalid.
5641#
5642# USAGE:
5643# * fill_project_list_info(\@project_list, 'descr_long', 'ctags')
5644# ensures that 'descr_long' and 'ctags' fields are filled
5645# * @project_list = fill_project_list_info(\@project_list)
5646# ensures that all fields are filled (and invalid projects removed)
5647#
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5648# NOTE: modifies $projlist, but does not remove entries from it
5649sub fill_project_list_info {
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5650 my ($projlist, @wanted_keys) = @_;
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5651 my @projects;
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5652 my $filter_set = sub { return @_; };
5653 if (@wanted_keys) {
5654 my %wanted_keys = map { $_ => 1 } @wanted_keys;
5655 $filter_set = sub { return grep { $wanted_keys{$_} } @_; };
5656 }
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5657
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]5658 my $show_ctags = gitweb_check_feature('ctags');
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5659 PROJECT:
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5660 foreach my $pr (@$projlist) {
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5661 if (project_info_needs_filling($pr, $filter_set->('age', 'age_string'))) {
Jakub Narebski14b289b2012-02-23 16:54:46 +0100[diff] [blame]5662 my (@activity) = git_get_last_activity($pr->{'path'});
5663 unless (@activity) {
5664 next PROJECT;
5665 }
5666 ($pr->{'age'}, $pr->{'age_string'}) = @activity;
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5667 }
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5668 if (project_info_needs_filling($pr, $filter_set->('descr', 'descr_long'))) {
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5669 my $descr = git_get_project_description($pr->{'path'}) || "";
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5670 $descr = to_utf8($descr);
5671 $pr->{'descr_long'} = $descr;
Michael Hendricks55feb122007-07-04 18:36:48 -0600[diff] [blame]5672 $pr->{'descr'} = chop_str($descr, $projects_list_description_width, 5);
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5673 }
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5674 if (project_info_needs_filling($pr, $filter_set->('owner'))) {
Miklos Vajna76e4f5d2007-07-04 00:11:23 +0200[diff] [blame]5675 $pr->{'owner'} = git_get_project_owner("$pr->{'path'}") || "";
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5676 }
Jakub Narebski14b289b2012-02-23 16:54:46 +0100[diff] [blame]5677 if ($show_ctags &&
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5678 project_info_needs_filling($pr, $filter_set->('ctags'))) {
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5679 $pr->{'ctags'} = git_get_project_ctags($pr->{'path'});
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5680 }
Jakub Narebski14b289b2012-02-23 16:54:46 +0100[diff] [blame]5681 if ($projects_list_group_categories &&
Jakub Narebski2e3291a2012-02-23 16:54:47 +0100[diff] [blame]5682 project_info_needs_filling($pr, $filter_set->('category'))) {
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]5683 my $cat = git_get_project_category($pr->{'path'}) ||
5684 $project_list_default_category;
5685 $pr->{'category'} = to_utf8($cat);
5686 }
5687
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5688 push @projects, $pr;
5689 }
5690
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5691 return @projects;
5692}
5693
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5694sub sort_projects_list {
5695 my ($projlist, $order) = @_;
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5696
Matthew Daley28dae182012-12-11 23:56:07 +1300[diff] [blame]5697 sub order_str {
5698 my $key = shift;
5699 return sub { $a->{$key} cmp $b->{$key} };
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5700 }
5701
Matthew Daley28dae182012-12-11 23:56:07 +1300[diff] [blame]5702 sub order_num_then_undef {
5703 my $key = shift;
5704 return sub {
5705 defined $a->{$key} ?
5706 (defined $b->{$key} ? $a->{$key} <=> $b->{$key} : -1) :
5707 (defined $b->{$key} ? 1 : 0)
5708 };
5709 }
5710
5711 my %orderings = (
5712 project => order_str('path'),
5713 descr => order_str('descr_long'),
5714 owner => order_str('owner'),
5715 age => order_num_then_undef('age'),
5716 );
5717
5718 my $ordering = $orderings{$order};
5719 return defined $ordering ? sort $ordering @$projlist : @$projlist;
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5720}
5721
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]5722# returns a hash of categories, containing the list of project
5723# belonging to each category
5724sub build_projlist_by_category {
5725 my ($projlist, $from, $to) = @_;
5726 my %categories;
5727
5728 $from = 0 unless defined $from;
5729 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5730
5731 for (my $i = $from; $i <= $to; $i++) {
5732 my $pr = $projlist->[$i];
5733 push @{$categories{ $pr->{'category'} }}, $pr;
5734 }
5735
5736 return wantarray ? %categories : \%categories;
5737}
5738
Petr Baudis6b28da62008-09-25 18:48:37 +0200[diff] [blame]5739# print 'sort by' <th> element, generating 'sort by $name' replay link
5740# if that order is not selected
Jakub Narebski7da0f3a2008-06-10 19:21:44 +0200[diff] [blame]5741sub print_sort_th {
John 'Warthog9' Hawley1ee4b4e2010-01-30 23:30:43 +0100[diff] [blame]5742 print format_sort_th(@_);
5743}
5744
5745sub format_sort_th {
Petr Baudis6b28da62008-09-25 18:48:37 +0200[diff] [blame]5746 my ($name, $order, $header) = @_;
John 'Warthog9' Hawley1ee4b4e2010-01-30 23:30:43 +0100[diff] [blame]5747 my $sort_th = "";
Jakub Narebski7da0f3a2008-06-10 19:21:44 +0200[diff] [blame]5748 $header ||= ucfirst($name);
5749
5750 if ($order eq $name) {
John 'Warthog9' Hawley1ee4b4e2010-01-30 23:30:43 +0100[diff] [blame]5751 $sort_th .= "<th>$header</th>\n";
Jakub Narebski7da0f3a2008-06-10 19:21:44 +0200[diff] [blame]5752 } else {
John 'Warthog9' Hawley1ee4b4e2010-01-30 23:30:43 +0100[diff] [blame]5753 $sort_th .= "<th>" .
5754 $cgi->a({-href => href(-replay=>1, order=>$name),
5755 -class => "header"}, $header) .
5756 "</th>\n";
Jakub Narebski7da0f3a2008-06-10 19:21:44 +0200[diff] [blame]5757 }
John 'Warthog9' Hawley1ee4b4e2010-01-30 23:30:43 +0100[diff] [blame]5758
5759 return $sort_th;
Jakub Narebski7da0f3a2008-06-10 19:21:44 +0200[diff] [blame]5760}
5761
Sebastien Cevey0fa920c2011-04-29 19:51:59 +0200[diff] [blame]5762sub git_project_list_rows {
5763 my ($projlist, $from, $to, $check_forks) = @_;
5764
5765 $from = 0 unless defined $from;
5766 $to = $#$projlist if (!defined $to || $#$projlist < $to);
5767
5768 my $alternate = 1;
5769 for (my $i = $from; $i <= $to; $i++) {
5770 my $pr = $projlist->[$i];
5771
5772 if ($alternate) {
5773 print "<tr class=\"dark\">\n";
5774 } else {
5775 print "<tr class=\"light\">\n";
5776 }
5777 $alternate ^= 1;
5778
5779 if ($check_forks) {
5780 print "<td>";
5781 if ($pr->{'forks'}) {
5782 my $nforks = scalar @{$pr->{'forks'}};
5783 if ($nforks > 0) {
5784 print $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks"),
5785 -title => "$nforks forks"}, "+");
5786 } else {
5787 print $cgi->span({-title => "$nforks forks"}, "+");
5788 }
5789 }
5790 print "</td>\n";
5791 }
5792 print "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
Jakub Narebski07a40062012-02-27 02:55:20 +0100[diff] [blame]5793 -class => "list"},
5794 esc_html_match_hl($pr->{'path'}, $search_regexp)) .
5795 "</td>\n" .
Sebastien Cevey0fa920c2011-04-29 19:51:59 +0200[diff] [blame]5796 "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
Jakub Narebski5fb3cf22012-02-27 02:55:21 +0100[diff] [blame]5797 -class => "list",
Jakub Narebskie607b792012-02-27 02:55:22 +0100[diff] [blame]5798 -title => $pr->{'descr_long'}},
Jakub Narebski5fb3cf22012-02-27 02:55:21 +0100[diff] [blame]5799 $search_regexp
Jakub Narebskie607b792012-02-27 02:55:22 +0100[diff] [blame]5800 ? esc_html_match_hl_chopped($pr->{'descr_long'},
5801 $pr->{'descr'}, $search_regexp)
Jakub Narebski5fb3cf22012-02-27 02:55:21 +0100[diff] [blame]5802 : esc_html($pr->{'descr'})) .
Kacper Kornet0ebe7822012-04-26 18:45:44 +0200[diff] [blame]5803 "</td>\n";
5804 unless ($omit_owner) {
5805 print "<td><i>" . chop_and_escape_str($pr->{'owner'}, 15) . "</i></td>\n";
5806 }
Kacper Kornet5710be42012-04-24 19:39:15 +0200[diff] [blame]5807 unless ($omit_age_column) {
5808 print "<td class=\"". age_class($pr->{'age'}) . "\">" .
5809 (defined $pr->{'age_string'} ? $pr->{'age_string'} : "No commits") . "</td>\n";
5810 }
5811 print"<td class=\"link\">" .
Sebastien Cevey0fa920c2011-04-29 19:51:59 +0200[diff] [blame]5812 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary")}, "summary") . " | " .
5813 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"shortlog")}, "shortlog") . " | " .
5814 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"log")}, "log") . " | " .
5815 $cgi->a({-href => href(project=>$pr->{'path'}, action=>"tree")}, "tree") .
5816 ($pr->{'forks'} ? " | " . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "forks") : '') .
5817 "</td>\n" .
5818 "</tr>\n";
5819 }
5820}
5821
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5822sub git_project_list_body {
Petr Baudis42326112008-10-02 17:17:01 +0200[diff] [blame]5823 # actually uses global variable $project
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5824 my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5825 my @projects = @$projlist;
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5826
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]5827 my $check_forks = gitweb_check_feature('forks');
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5828 my $show_ctags = gitweb_check_feature('ctags');
Jakub Narebski84d9e2d2012-02-03 13:44:54 +0100[diff] [blame]5829 my $tagfilter = $show_ctags ? $input_params{'ctag'} : undef;
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5830 $check_forks = undef
Jakub Narebskie65ceb62012-03-02 23:34:24 +0100[diff] [blame]5831 if ($tagfilter || $search_regexp);
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5832
5833 # filtering out forks before filling info allows to do less work
5834 @projects = filter_forks_from_projects_list(\@projects)
5835 if ($check_forks);
Jakub Narebski07b257f2012-02-23 16:54:48 +0100[diff] [blame]5836 # search_projects_list pre-fills required info
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5837 @projects = search_projects_list(\@projects,
Jakub Narebskie65ceb62012-03-02 23:34:24 +0100[diff] [blame]5838 'search_regexp' => $search_regexp,
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5839 'tagfilter' => $tagfilter)
Jakub Narebskie65ceb62012-03-02 23:34:24 +0100[diff] [blame]5840 if ($tagfilter || $search_regexp);
Jakub Narebski07b257f2012-02-23 16:54:48 +0100[diff] [blame]5841 # fill the rest
Kacper Kornet0ebe7822012-04-26 18:45:44 +0200[diff] [blame]5842 my @all_fields = ('descr', 'descr_long', 'ctags', 'category');
5843 push @all_fields, ('age', 'age_string') unless($omit_age_column);
5844 push @all_fields, 'owner' unless($omit_owner);
Kacper Kornet5710be42012-04-24 19:39:15 +0200[diff] [blame]5845 @projects = fill_project_list_info(\@projects, @all_fields);
Jakub Narebski69913412008-06-10 19:21:01 +0200[diff] [blame]5846
Frank Lichtenheldb06dcf82007-04-06 23:58:24 +0200[diff] [blame]5847 $order ||= $default_projects_order;
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5848 $from = 0 unless defined $from;
5849 $to = $#projects if (!defined $to || $#projects < $to);
5850
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5851 # short circuit
5852 if ($from > $to) {
5853 print "<center>\n".
5854 "<b>No such projects found</b><br />\n".
5855 "Click ".$cgi->a({-href=>href(project=>undef)},"here")." to view all projects<br />\n".
5856 "</center>\n<br />\n";
5857 return;
Petr Baudis6b28da62008-09-25 18:48:37 +0200[diff] [blame]5858 }
5859
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5860 @projects = sort_projects_list(\@projects, $order);
5861
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]5862 if ($show_ctags) {
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]5863 my $ctags = git_gather_all_ctags(\@projects);
5864 my $cloud = git_populate_project_tagcloud($ctags);
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]5865 print git_show_project_tagcloud($cloud, 64);
5866 }
5867
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5868 print "<table class=\"project_list\">\n";
5869 unless ($no_header) {
5870 print "<tr>\n";
5871 if ($check_forks) {
5872 print "<th></th>\n";
5873 }
Petr Baudis6b28da62008-09-25 18:48:37 +0200[diff] [blame]5874 print_sort_th('project', $order, 'Project');
5875 print_sort_th('descr', $order, 'Description');
Kacper Kornet0ebe7822012-04-26 18:45:44 +0200[diff] [blame]5876 print_sort_th('owner', $order, 'Owner') unless $omit_owner;
Kacper Kornet5710be42012-04-24 19:39:15 +0200[diff] [blame]5877 print_sort_th('age', $order, 'Last Change') unless $omit_age_column;
Jakub Narebski7da0f3a2008-06-10 19:21:44 +0200[diff] [blame]5878 print "<th></th>\n" . # for links
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5879 "</tr>\n";
5880 }
Petr Baudis42326112008-10-02 17:17:01 +0200[diff] [blame]5881
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]5882 if ($projects_list_group_categories) {
5883 # only display categories with projects in the $from-$to window
5884 @projects = sort {$a->{'category'} cmp $b->{'category'}} @projects[$from..$to];
5885 my %categories = build_projlist_by_category(\@projects, $from, $to);
5886 foreach my $cat (sort keys %categories) {
5887 unless ($cat eq "") {
5888 print "<tr>\n";
5889 if ($check_forks) {
5890 print "<td></td>\n";
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5891 }
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]5892 print "<td class=\"category\" colspan=\"5\">".esc_html($cat)."</td>\n";
5893 print "</tr>\n";
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5894 }
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]5895
5896 git_project_list_rows($categories{$cat}, undef, undef, $check_forks);
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5897 }
Sebastien Ceveyd940c902011-04-29 19:52:01 +0200[diff] [blame]5898 } else {
5899 git_project_list_rows(\@projects, $from, $to, $check_forks);
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5900 }
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]5901
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]5902 if (defined $extra) {
5903 print "<tr>\n";
5904 if ($check_forks) {
5905 print "<td></td>\n";
5906 }
5907 print "<td colspan=\"5\">$extra</td>\n" .
5908 "</tr>\n";
5909 }
5910 print "</table>\n";
5911}
5912
Jakub Narebski42671ca2009-11-13 02:02:12 +0100[diff] [blame]5913sub git_log_body {
5914 # uses global variable $project
5915 my ($commitlist, $from, $to, $refs, $extra) = @_;
5916
5917 $from = 0 unless defined $from;
5918 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
5919
5920 for (my $i = 0; $i <= $to; $i++) {
5921 my %co = %{$commitlist->[$i]};
5922 next if !%co;
5923 my $commit = $co{'id'};
5924 my $ref = format_ref_marker($refs, $commit);
Jakub Narebski42671ca2009-11-13 02:02:12 +0100[diff] [blame]5925 git_print_header_div('commit',
5926 "<span class=\"age\">$co{'age_string'}</span>" .
5927 esc_html($co{'title'}) . $ref,
5928 $commit);
5929 print "<div class=\"title_text\">\n" .
5930 "<div class=\"log_link\">\n" .
5931 $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") .
5932 " | " .
5933 $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") .
5934 " | " .
5935 $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree") .
5936 "<br/>\n" .
5937 "</div>\n";
5938 git_print_authorship(\%co, -tag => 'span');
5939 print "<br/>\n</div>\n";
5940
5941 print "<div class=\"log_body\">\n";
5942 git_print_log($co{'comment'}, -final_empty_line=> 1);
5943 print "</div>\n";
5944 }
5945 if ($extra) {
5946 print "<div class=\"page_nav\">\n";
5947 print "$extra\n";
5948 print "</div>\n";
5949 }
5950}
5951
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]5952sub git_shortlog_body {
5953 # uses global variable $project
Robert Fitzsimons190d7fd2006-12-24 14:31:44 +0000[diff] [blame]5954 my ($commitlist, $from, $to, $refs, $extra) = @_;
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]5955
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]5956 $from = 0 unless defined $from;
Robert Fitzsimons190d7fd2006-12-24 14:31:44 +0000[diff] [blame]5957 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]5958
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]5959 print "<table class=\"shortlog\">\n";
Luben Tuikov6dd36ac2006-09-28 16:47:50 -0700[diff] [blame]5960 my $alternate = 1;
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]5961 for (my $i = $from; $i <= $to; $i++) {
Robert Fitzsimons190d7fd2006-12-24 14:31:44 +0000[diff] [blame]5962 my %co = %{$commitlist->[$i]};
5963 my $commit = $co{'id'};
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]5964 my $ref = format_ref_marker($refs, $commit);
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]5965 if ($alternate) {
5966 print "<tr class=\"dark\">\n";
5967 } else {
5968 print "<tr class=\"light\">\n";
5969 }
5970 $alternate ^= 1;
5971 # git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
5972 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]5973 format_author_html('td', \%co, 10) . "<td>";
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]5974 print format_subject_html($co{'title'}, $co{'title_short'},
5975 href(action=>"commit", hash=>$commit), $ref);
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]5976 print "</td>\n" .
5977 "<td class=\"link\">" .
Petr Baudis4777b012006-10-24 05:36:10 +0200[diff] [blame]5978 $cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") . " | " .
Petr Baudis35749ae2006-09-22 03:19:44 +0200[diff] [blame]5979 $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") . " | " .
Petr Baudis55ff35c2006-10-06 15:57:52 +0200[diff] [blame]5980 $cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree");
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]5981 my $snapshot_links = format_snapshot_links($commit);
5982 if (defined $snapshot_links) {
5983 print " | " . $snapshot_links;
Petr Baudis55ff35c2006-10-06 15:57:52 +0200[diff] [blame]5984 }
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]5985 print "</td>\n" .
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]5986 "</tr>\n";
5987 }
5988 if (defined $extra) {
5989 print "<tr>\n" .
5990 "<td colspan=\"4\">$extra</td>\n" .
5991 "</tr>\n";
5992 }
5993 print "</table>\n";
5994}
5995
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]5996sub git_history_body {
5997 # Warning: assumes constant type (blob or tree) during history
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]5998 my ($commitlist, $from, $to, $refs, $extra,
5999 $file_name, $file_hash, $ftype) = @_;
Jakub Narebski8be68352006-09-11 00:36:04 +0200[diff] [blame]6000
6001 $from = 0 unless defined $from;
Robert Fitzsimonsa8b983b2006-12-24 14:31:48 +0000[diff] [blame]6002 $to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6003
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]6004 print "<table class=\"history\">\n";
Luben Tuikov6dd36ac2006-09-28 16:47:50 -0700[diff] [blame]6005 my $alternate = 1;
Jakub Narebski8be68352006-09-11 00:36:04 +0200[diff] [blame]6006 for (my $i = $from; $i <= $to; $i++) {
Robert Fitzsimonsa8b983b2006-12-24 14:31:48 +0000[diff] [blame]6007 my %co = %{$commitlist->[$i]};
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6008 if (!%co) {
6009 next;
6010 }
Robert Fitzsimonsa8b983b2006-12-24 14:31:48 +0000[diff] [blame]6011 my $commit = $co{'id'};
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6012
6013 my $ref = format_ref_marker($refs, $commit);
6014
6015 if ($alternate) {
6016 print "<tr class=\"dark\">\n";
6017 } else {
6018 print "<tr class=\"light\">\n";
6019 }
6020 $alternate ^= 1;
6021 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]6022 # shortlog: format_author_html('td', \%co, 10)
6023 format_author_html('td', \%co, 15, 3) . "<td>";
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6024 # originally git_history used chop_str($co{'title'}, 50)
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]6025 print format_subject_html($co{'title'}, $co{'title_short'},
6026 href(action=>"commit", hash=>$commit), $ref);
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6027 print "</td>\n" .
6028 "<td class=\"link\">" .
Luben Tuikov6d81c5a2006-09-28 17:21:07 -0700[diff] [blame]6029 $cgi->a({-href => href(action=>$ftype, hash_base=>$commit, file_name=>$file_name)}, $ftype) . " | " .
6030 $cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff");
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6031
6032 if ($ftype eq 'blob') {
Job Snijders96628972017-08-22 22:07:29 +0200[diff] [blame]6033 print " | " .
6034 $cgi->a({-href => href(action=>"blob_plain", hash_base=>$commit, file_name=>$file_name)}, "raw");
6035
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]6036 my $blob_current = $file_hash;
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6037 my $blob_parent = git_get_hash_by_path($commit, $file_name);
6038 if (defined $blob_current && defined $blob_parent &&
6039 $blob_current ne $blob_parent) {
6040 print " | " .
Jakub Narebski420e92f2006-08-24 23:53:54 +0200[diff] [blame]6041 $cgi->a({-href => href(action=>"blobdiff",
6042 hash=>$blob_current, hash_parent=>$blob_parent,
6043 hash_base=>$hash_base, hash_parent_base=>$commit,
6044 file_name=>$file_name)},
Jakub Narebski581860e2006-08-14 02:09:08 +0200[diff] [blame]6045 "diff to current");
6046 }
6047 }
6048 print "</td>\n" .
6049 "</tr>\n";
6050 }
6051 if (defined $extra) {
6052 print "<tr>\n" .
6053 "<td colspan=\"4\">$extra</td>\n" .
6054 "</tr>\n";
6055 }
6056 print "</table>\n";
6057}
6058
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6059sub git_tags_body {
6060 # uses global variable $project
6061 my ($taglist, $from, $to, $extra) = @_;
6062 $from = 0 unless defined $from;
6063 $to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
6064
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]6065 print "<table class=\"tags\">\n";
Luben Tuikov6dd36ac2006-09-28 16:47:50 -0700[diff] [blame]6066 my $alternate = 1;
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6067 for (my $i = $from; $i <= $to; $i++) {
6068 my $entry = $taglist->[$i];
6069 my %tag = %$entry;
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]6070 my $comment = $tag{'subject'};
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6071 my $comment_short;
6072 if (defined $comment) {
6073 $comment_short = chop_str($comment, 30, 5);
6074 }
6075 if ($alternate) {
6076 print "<tr class=\"dark\">\n";
6077 } else {
6078 print "<tr class=\"light\">\n";
6079 }
6080 $alternate ^= 1;
Jakub Narebski27dd1a82007-01-03 22:54:29 +0100[diff] [blame]6081 if (defined $tag{'age'}) {
6082 print "<td><i>$tag{'age'}</i></td>\n";
6083 } else {
6084 print "<td></td>\n";
6085 }
6086 print "<td>" .
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]6087 $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'}),
Jakub Narebski63e42202006-08-22 12:38:59 +0200[diff] [blame]6088 -class => "list name"}, esc_html($tag{'name'})) .
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6089 "</td>\n" .
6090 "<td>";
6091 if (defined $comment) {
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]6092 print format_subject_html($comment, $comment_short,
6093 href(action=>"tag", hash=>$tag{'id'}));
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6094 }
6095 print "</td>\n" .
6096 "<td class=\"selflink\">";
6097 if ($tag{'type'} eq "tag") {
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]6098 print $cgi->a({-href => href(action=>"tag", hash=>$tag{'id'})}, "tag");
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6099 } else {
6100 print "&nbsp;";
6101 }
6102 print "</td>\n" .
6103 "<td class=\"link\">" . " | " .
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]6104 $cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'})}, $tag{'reftype'});
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6105 if ($tag{'reftype'} eq "commit") {
Jakub Narebskibf901f82007-12-15 15:40:28 +0100[diff] [blame]6106 print " | " . $cgi->a({-href => href(action=>"shortlog", hash=>$tag{'fullname'})}, "shortlog") .
6107 " | " . $cgi->a({-href => href(action=>"log", hash=>$tag{'fullname'})}, "log");
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6108 } elsif ($tag{'reftype'} eq "blob") {
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]6109 print " | " . $cgi->a({-href => href(action=>"blob_plain", hash=>$tag{'refid'})}, "raw");
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6110 }
6111 print "</td>\n" .
6112 "</tr>";
6113 }
6114 if (defined $extra) {
6115 print "<tr>\n" .
6116 "<td colspan=\"5\">$extra</td>\n" .
6117 "</tr>\n";
6118 }
6119 print "</table>\n";
6120}
6121
6122sub git_heads_body {
6123 # uses global variable $project
Jakub Narebskifd49e562012-02-15 16:36:41 +0100[diff] [blame]6124 my ($headlist, $head_at, $from, $to, $extra) = @_;
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6125 $from = 0 unless defined $from;
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]6126 $to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6127
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]6128 print "<table class=\"heads\">\n";
Luben Tuikov6dd36ac2006-09-28 16:47:50 -0700[diff] [blame]6129 my $alternate = 1;
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6130 for (my $i = $from; $i <= $to; $i++) {
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]6131 my $entry = $headlist->[$i];
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]6132 my %ref = %$entry;
Jakub Narebskifd49e562012-02-15 16:36:41 +0100[diff] [blame]6133 my $curr = defined $head_at && $ref{'id'} eq $head_at;
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6134 if ($alternate) {
6135 print "<tr class=\"dark\">\n";
6136 } else {
6137 print "<tr class=\"light\">\n";
6138 }
6139 $alternate ^= 1;
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]6140 print "<td><i>$ref{'age'}</i></td>\n" .
6141 ($curr ? "<td class=\"current_head\">" : "<td>") .
Jakub Narebskibf901f82007-12-15 15:40:28 +0100[diff] [blame]6142 $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'}),
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]6143 -class => "list name"},esc_html($ref{'name'})) .
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6144 "</td>\n" .
6145 "<td class=\"link\">" .
Jakub Narebskibf901f82007-12-15 15:40:28 +0100[diff] [blame]6146 $cgi->a({-href => href(action=>"shortlog", hash=>$ref{'fullname'})}, "shortlog") . " | " .
6147 $cgi->a({-href => href(action=>"log", hash=>$ref{'fullname'})}, "log") . " | " .
Giuseppe Bilotta9e70e152010-11-11 13:26:08 +0100[diff] [blame]6148 $cgi->a({-href => href(action=>"tree", hash=>$ref{'fullname'}, hash_base=>$ref{'fullname'})}, "tree") .
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6149 "</td>\n" .
6150 "</tr>";
6151 }
6152 if (defined $extra) {
6153 print "<tr>\n" .
6154 "<td colspan=\"3\">$extra</td>\n" .
6155 "</tr>\n";
6156 }
6157 print "</table>\n";
6158}
6159
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]6160# Display a single remote block
6161sub git_remote_block {
6162 my ($remote, $rdata, $limit, $head) = @_;
6163
6164 my $heads = $rdata->{'heads'};
6165 my $fetch = $rdata->{'fetch'};
6166 my $push = $rdata->{'push'};
6167
6168 my $urls_table = "<table class=\"projects_list\">\n" ;
6169
6170 if (defined $fetch) {
6171 if ($fetch eq $push) {
6172 $urls_table .= format_repo_url("URL", $fetch);
6173 } else {
6174 $urls_table .= format_repo_url("Fetch URL", $fetch);
6175 $urls_table .= format_repo_url("Push URL", $push) if defined $push;
6176 }
6177 } elsif (defined $push) {
6178 $urls_table .= format_repo_url("Push URL", $push);
6179 } else {
6180 $urls_table .= format_repo_url("", "No remote URL");
6181 }
6182
6183 $urls_table .= "</table>\n";
6184
6185 my $dots;
6186 if (defined $limit && $limit < @$heads) {
6187 $dots = $cgi->a({-href => href(action=>"remotes", hash=>$remote)}, "...");
6188 }
6189
6190 print $urls_table;
6191 git_heads_body($heads, $head, 0, $limit, $dots);
6192}
6193
6194# Display a list of remote names with the respective fetch and push URLs
6195sub git_remotes_list {
6196 my ($remotedata, $limit) = @_;
6197 print "<table class=\"heads\">\n";
6198 my $alternate = 1;
6199 my @remotes = sort keys %$remotedata;
6200
6201 my $limited = $limit && $limit < @remotes;
6202
6203 $#remotes = $limit - 1 if $limited;
6204
6205 while (my $remote = shift @remotes) {
6206 my $rdata = $remotedata->{$remote};
6207 my $fetch = $rdata->{'fetch'};
6208 my $push = $rdata->{'push'};
6209 if ($alternate) {
6210 print "<tr class=\"dark\">\n";
6211 } else {
6212 print "<tr class=\"light\">\n";
6213 }
6214 $alternate ^= 1;
6215 print "<td>" .
6216 $cgi->a({-href=> href(action=>'remotes', hash=>$remote),
6217 -class=> "list name"},esc_html($remote)) .
6218 "</td>";
6219 print "<td class=\"link\">" .
6220 (defined $fetch ? $cgi->a({-href=> $fetch}, "fetch") : "fetch") .
6221 " | " .
6222 (defined $push ? $cgi->a({-href=> $push}, "push") : "push") .
6223 "</td>";
6224
6225 print "</tr>\n";
6226 }
6227
6228 if ($limited) {
6229 print "<tr>\n" .
6230 "<td colspan=\"3\">" .
6231 $cgi->a({-href => href(action=>"remotes")}, "...") .
6232 "</td>\n" . "</tr>\n";
6233 }
6234
6235 print "</table>";
6236}
6237
6238# Display remote heads grouped by remote, unless there are too many
6239# remotes, in which case we only display the remote names
6240sub git_remotes_body {
6241 my ($remotedata, $limit, $head) = @_;
6242 if ($limit and $limit < keys %$remotedata) {
6243 git_remotes_list($remotedata, $limit);
6244 } else {
6245 fill_remote_heads($remotedata);
6246 while (my ($remote, $rdata) = each %$remotedata) {
6247 git_print_section({-class=>"remote", -id=>$remote},
6248 ["remotes", $remote, $remote], sub {
6249 git_remote_block($remote, $rdata, $limit, $head);
6250 });
6251 }
6252 }
6253}
6254
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6255sub git_search_message {
6256 my %co = @_;
6257
6258 my $greptype;
6259 if ($searchtype eq 'commit') {
6260 $greptype = "--grep=";
6261 } elsif ($searchtype eq 'author') {
6262 $greptype = "--author=";
6263 } elsif ($searchtype eq 'committer') {
6264 $greptype = "--committer=";
6265 }
6266 $greptype .= $searchtext;
6267 my @commitlist = parse_commits($hash, 101, (100 * $page), undef,
6268 $greptype, '--regexp-ignore-case',
6269 $search_use_regexp ? '--extended-regexp' : '--fixed-strings');
6270
6271 my $paging_nav = '';
6272 if ($page > 0) {
6273 $paging_nav .=
Jakub Narebski882541b2011-06-22 17:28:54 +0200[diff] [blame]6274 $cgi->a({-href => href(-replay=>1, page=>undef)},
6275 "first") .
6276 " &sdot; " .
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6277 $cgi->a({-href => href(-replay=>1, page=>$page-1),
6278 -accesskey => "p", -title => "Alt-p"}, "prev");
6279 } else {
Jakub Narebski882541b2011-06-22 17:28:54 +0200[diff] [blame]6280 $paging_nav .= "first &sdot; prev";
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6281 }
6282 my $next_link = '';
6283 if ($#commitlist >= 100) {
6284 $next_link =
6285 $cgi->a({-href => href(-replay=>1, page=>$page+1),
6286 -accesskey => "n", -title => "Alt-n"}, "next");
6287 $paging_nav .= " &sdot; $next_link";
6288 } else {
6289 $paging_nav .= " &sdot; next";
6290 }
6291
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]6292 git_header_html();
6293
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6294 git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
6295 git_print_header_div('commit', esc_html($co{'title'}), $hash);
6296 if ($page == 0 && !@commitlist) {
6297 print "<p>No match.</p>\n";
6298 } else {
6299 git_search_grep_body(\@commitlist, 0, 99, $next_link);
6300 }
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]6301
6302 git_footer_html();
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6303}
6304
6305sub git_search_changes {
6306 my %co = @_;
6307
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]6308 local $/ = "\n";
6309 open my $fd, '-|', git_cmd(), '--no-pager', 'log', @diff_opts,
6310 '--pretty=format:%H', '--no-abbrev', '--raw', "-S$searchtext",
6311 ($search_use_regexp ? '--pickaxe-regex' : ())
6312 or die_error(500, "Open git-log failed");
6313
6314 git_header_html();
6315
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6316 git_print_page_nav('','', $hash,$co{'tree'},$hash);
6317 git_print_header_div('commit', esc_html($co{'title'}), $hash);
6318
6319 print "<table class=\"pickaxe search\">\n";
6320 my $alternate = 1;
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6321 undef %co;
6322 my @files;
6323 while (my $line = <$fd>) {
6324 chomp $line;
6325 next unless $line;
6326
6327 my %set = parse_difftree_raw_line($line);
6328 if (defined $set{'commit'}) {
6329 # finish previous commit
6330 if (%co) {
6331 print "</td>\n" .
6332 "<td class=\"link\">" .
Jakub Narebski882541b2011-06-22 17:28:54 +0200[diff] [blame]6333 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})},
6334 "commit") .
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6335 " | " .
Jakub Narebski882541b2011-06-22 17:28:54 +0200[diff] [blame]6336 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'},
6337 hash_base=>$co{'id'})},
6338 "tree") .
6339 "</td>\n" .
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6340 "</tr>\n";
6341 }
6342
6343 if ($alternate) {
6344 print "<tr class=\"dark\">\n";
6345 } else {
6346 print "<tr class=\"light\">\n";
6347 }
6348 $alternate ^= 1;
6349 %co = parse_commit($set{'commit'});
6350 my $author = chop_and_escape_str($co{'author_name'}, 15, 5);
6351 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
6352 "<td><i>$author</i></td>\n" .
6353 "<td>" .
6354 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
6355 -class => "list subject"},
6356 chop_and_escape_str($co{'title'}, 50) . "<br/>");
6357 } elsif (defined $set{'to_id'}) {
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]6358 next if is_deleted(\%set);
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6359
6360 print $cgi->a({-href => href(action=>"blob", hash_base=>$co{'id'},
6361 hash=>$set{'to_id'}, file_name=>$set{'to_file'}),
6362 -class => "list"},
6363 "<span class=\"match\">" . esc_path($set{'file'}) . "</span>") .
6364 "<br/>\n";
6365 }
6366 }
6367 close $fd;
6368
6369 # finish last commit (warning: repetition!)
6370 if (%co) {
6371 print "</td>\n" .
6372 "<td class=\"link\">" .
Jakub Narebski882541b2011-06-22 17:28:54 +0200[diff] [blame]6373 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})},
6374 "commit") .
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6375 " | " .
Jakub Narebski882541b2011-06-22 17:28:54 +0200[diff] [blame]6376 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'},
6377 hash_base=>$co{'id'})},
6378 "tree") .
6379 "</td>\n" .
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6380 "</tr>\n";
6381 }
6382
6383 print "</table>\n";
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]6384
6385 git_footer_html();
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6386}
6387
6388sub git_search_files {
6389 my %co = @_;
6390
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]6391 local $/ = "\n";
Jakub Narebski8e09fd12012-01-05 21:32:56 +0100[diff] [blame]6392 open my $fd, "-|", git_cmd(), 'grep', '-n', '-z',
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]6393 $search_use_regexp ? ('-E', '-i') : '-F',
6394 $searchtext, $co{'tree'}
6395 or die_error(500, "Open git-grep failed");
6396
6397 git_header_html();
6398
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6399 git_print_page_nav('','', $hash,$co{'tree'},$hash);
6400 git_print_header_div('commit', esc_html($co{'title'}), $hash);
6401
6402 print "<table class=\"grep_search\">\n";
6403 my $alternate = 1;
6404 my $matches = 0;
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6405 my $lastfile = '';
Jakub Narebskifc8fcd22012-02-15 17:37:06 +0100[diff] [blame]6406 my $file_href;
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6407 while (my $line = <$fd>) {
6408 chomp $line;
Jakub Narebskifc8fcd22012-02-15 17:37:06 +0100[diff] [blame]6409 my ($file, $lno, $ltext, $binary);
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6410 last if ($matches++ > 1000);
6411 if ($line =~ /^Binary file (.+) matches$/) {
6412 $file = $1;
6413 $binary = 1;
6414 } else {
Jakub Narebski8e09fd12012-01-05 21:32:56 +0100[diff] [blame]6415 ($file, $lno, $ltext) = split(/\0/, $line, 3);
6416 $file =~ s/^$co{'tree'}://;
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6417 }
6418 if ($file ne $lastfile) {
6419 $lastfile and print "</td></tr>\n";
6420 if ($alternate++) {
6421 print "<tr class=\"dark\">\n";
6422 } else {
6423 print "<tr class=\"light\">\n";
6424 }
Jakub Narebskiff7f2182012-01-05 21:26:48 +0100[diff] [blame]6425 $file_href = href(action=>"blob", hash_base=>$co{'id'},
6426 file_name=>$file);
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6427 print "<td class=\"list\">".
Jakub Narebskiff7f2182012-01-05 21:26:48 +0100[diff] [blame]6428 $cgi->a({-href => $file_href, -class => "list"}, esc_path($file));
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6429 print "</td><td>\n";
6430 $lastfile = $file;
6431 }
6432 if ($binary) {
6433 print "<div class=\"binary\">Binary file</div>\n";
6434 } else {
6435 $ltext = untabify($ltext);
6436 if ($ltext =~ m/^(.*)($search_regexp)(.*)$/i) {
6437 $ltext = esc_html($1, -nbsp=>1);
6438 $ltext .= '<span class="match">';
6439 $ltext .= esc_html($2, -nbsp=>1);
6440 $ltext .= '</span>';
6441 $ltext .= esc_html($3, -nbsp=>1);
6442 } else {
6443 $ltext = esc_html($ltext, -nbsp=>1);
6444 }
6445 print "<div class=\"pre\">" .
Jakub Narebskiff7f2182012-01-05 21:26:48 +0100[diff] [blame]6446 $cgi->a({-href => $file_href.'#l'.$lno,
6447 -class => "linenr"}, sprintf('%4i', $lno)) .
6448 ' ' . $ltext . "</div>\n";
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6449 }
6450 }
6451 if ($lastfile) {
6452 print "</td></tr>\n";
6453 if ($matches > 1000) {
6454 print "<div class=\"diff nodifferences\">Too many matches, listing trimmed</div>\n";
6455 }
6456 } else {
6457 print "<div class=\"diff nodifferences\">No matches found</div>\n";
6458 }
6459 close $fd;
6460
6461 print "</table>\n";
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]6462
6463 git_footer_html();
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]6464}
6465
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6466sub git_search_grep_body {
Robert Fitzsimons5ad66082006-12-24 14:31:46 +0000[diff] [blame]6467 my ($commitlist, $from, $to, $extra) = @_;
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6468 $from = 0 unless defined $from;
Robert Fitzsimons5ad66082006-12-24 14:31:46 +0000[diff] [blame]6469 $to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6470
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]6471 print "<table class=\"commit_search\">\n";
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6472 my $alternate = 1;
6473 for (my $i = $from; $i <= $to; $i++) {
Robert Fitzsimons5ad66082006-12-24 14:31:46 +0000[diff] [blame]6474 my %co = %{$commitlist->[$i]};
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6475 if (!%co) {
6476 next;
6477 }
Robert Fitzsimons5ad66082006-12-24 14:31:46 +0000[diff] [blame]6478 my $commit = $co{'id'};
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6479 if ($alternate) {
6480 print "<tr class=\"dark\">\n";
6481 } else {
6482 print "<tr class=\"light\">\n";
6483 }
6484 $alternate ^= 1;
6485 print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]6486 format_author_html('td', \%co, 15, 5) .
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6487 "<td>" .
Junio C Hamanobe8b9062008-02-22 17:33:47 +0100[diff] [blame]6488 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
6489 -class => "list subject"},
6490 chop_and_escape_str($co{'title'}, 50) . "<br/>");
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6491 my $comment = $co{'comment'};
6492 foreach my $line (@$comment) {
Jakub Narebski6dfbb302008-03-02 16:57:14 +0100[diff] [blame]6493 if ($line =~ m/^(.*?)($search_regexp)(.*)$/i) {
Junio C Hamanobe8b9062008-02-22 17:33:47 +0100[diff] [blame]6494 my ($lead, $match, $trail) = ($1, $2, $3);
Jakub Narebskib8d97d02008-02-25 21:07:57 +0100[diff] [blame]6495 $match = chop_str($match, 70, 5, 'center');
6496 my $contextlen = int((80 - length($match))/2);
6497 $contextlen = 30 if ($contextlen > 30);
6498 $lead = chop_str($lead, $contextlen, 10, 'left');
6499 $trail = chop_str($trail, $contextlen, 10, 'right');
Junio C Hamanobe8b9062008-02-22 17:33:47 +0100[diff] [blame]6500
6501 $lead = esc_html($lead);
6502 $match = esc_html($match);
6503 $trail = esc_html($trail);
6504
6505 print "$lead<span class=\"match\">$match</span>$trail<br />";
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6506 }
6507 }
6508 print "</td>\n" .
6509 "<td class=\"link\">" .
6510 $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
6511 " | " .
Denis Chengf1fe8f52007-11-26 20:42:06 +0800[diff] [blame]6512 $cgi->a({-href => href(action=>"commitdiff", hash=>$co{'id'})}, "commitdiff") .
6513 " | " .
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]6514 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
6515 print "</td>\n" .
6516 "</tr>\n";
6517 }
6518 if (defined $extra) {
6519 print "<tr>\n" .
6520 "<td colspan=\"3\">$extra</td>\n" .
6521 "</tr>\n";
6522 }
6523 print "</table>\n";
6524}
6525
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6526## ======================================================================
6527## ======================================================================
6528## actions
6529
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6530sub git_project_list {
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]6531 my $order = $input_params{'order'};
Frank Lichtenheldb06dcf82007-04-06 23:58:24 +0200[diff] [blame]6532 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6533 die_error(400, "Unknown order parameter");
Jakub Narebski6326b602006-08-01 02:59:12 +0200[diff] [blame]6534 }
6535
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]6536 my @list = git_get_projects_list($project_filter, $strict_export);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6537 if (!@list) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6538 die_error(404, "No projects found");
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6539 }
Jakub Narebski6326b602006-08-01 02:59:12 +0200[diff] [blame]6540
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6541 git_header_html();
John 'Warthog9' Hawley24d4afc2010-01-30 23:30:41 +0100[diff] [blame]6542 if (defined $home_text && -f $home_text) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6543 print "<div class=\"index_include\">\n";
Jakub Narebski2dcb5e12008-12-01 19:01:42 +0100[diff] [blame]6544 insert_file($home_text);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6545 print "</div>\n";
6546 }
Jakub Narebskia1e1b2d2012-01-31 01:20:54 +0100[diff] [blame]6547
6548 git_project_search_form($searchtext, $search_use_regexp);
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6549 git_project_list_body(\@list, $order);
6550 git_footer_html();
6551}
6552
6553sub git_forks {
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]6554 my $order = $input_params{'order'};
Frank Lichtenheldb06dcf82007-04-06 23:58:24 +0200[diff] [blame]6555 if (defined $order && $order !~ m/none|project|descr|owner|age/) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6556 die_error(400, "Unknown order parameter");
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6557 }
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6558
Bernhard R. Link4c7cd172012-01-30 21:05:47 +0100[diff] [blame]6559 my $filter = $project;
6560 $filter =~ s/\.git$//;
6561 my @list = git_get_projects_list($filter);
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6562 if (!@list) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6563 die_error(404, "No forks found");
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6564 }
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6565
6566 git_header_html();
6567 git_print_page_nav('','');
6568 git_print_header_div('summary', "$project forks");
6569 git_project_list_body(\@list, $order);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]6570 git_footer_html();
6571}
6572
Jakub Narebskifc2b2be2006-09-15 04:56:03 +0200[diff] [blame]6573sub git_project_index {
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]6574 my @projects = git_get_projects_list($project_filter, $strict_export);
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]6575 if (!@projects) {
6576 die_error(404, "No projects found");
6577 }
Jakub Narebskifc2b2be2006-09-15 04:56:03 +0200[diff] [blame]6578
6579 print $cgi->header(
6580 -type => 'text/plain',
6581 -charset => 'utf-8',
Jakub Narebskiab41dfb2006-09-26 01:59:43 +0200[diff] [blame]6582 -content_disposition => 'inline; filename="index.aux"');
Jakub Narebskifc2b2be2006-09-15 04:56:03 +0200[diff] [blame]6583
6584 foreach my $pr (@projects) {
6585 if (!exists $pr->{'owner'}) {
Miklos Vajna76e4f5d2007-07-04 00:11:23 +0200[diff] [blame]6586 $pr->{'owner'} = git_get_project_owner("$pr->{'path'}");
Jakub Narebskifc2b2be2006-09-15 04:56:03 +0200[diff] [blame]6587 }
6588
6589 my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
6590 # quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
6591 $path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
6592 $owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
6593 $path =~ s/ /\+/g;
6594 $owner =~ s/ /\+/g;
6595
6596 print "$path $owner\n";
6597 }
6598}
6599
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6600sub git_summary {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6601 my $descr = git_get_project_description($project) || "none";
Robert Fitzsimonsa979d122006-12-22 19:38:15 +0000[diff] [blame]6602 my %co = parse_commit("HEAD");
Jakub Narebski785cdea2007-05-13 12:39:22 +0200[diff] [blame]6603 my %cd = %co ? parse_date($co{'committer_epoch'}, $co{'committer_tz'}) : ();
Robert Fitzsimonsa979d122006-12-22 19:38:15 +0000[diff] [blame]6604 my $head = $co{'id'};
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]6605 my $remote_heads = gitweb_check_feature('remote_heads');
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6606
Jakub Narebski1e0cf032006-08-14 02:10:06 +0200[diff] [blame]6607 my $owner = git_get_project_owner($project);
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6608
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]6609 my $refs = git_get_references();
Robert Fitzsimons313ce8c2006-12-19 12:08:54 +0000[diff] [blame]6610 # These get_*_list functions return one more to allow us to see if
6611 # there are more ...
6612 my @taglist = git_get_tags_list(16);
6613 my @headlist = git_get_heads_list(16);
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]6614 my %remotedata = $remote_heads ? git_get_remotes_list() : ();
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6615 my @forklist;
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]6616 my $check_forks = gitweb_check_feature('forks');
Junio C Hamano5dd5ed02006-11-07 22:00:45 -0800[diff] [blame]6617
6618 if ($check_forks) {
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]6619 # find forks of a project
Bernhard R. Link4c7cd172012-01-30 21:05:47 +0100[diff] [blame]6620 my $filter = $project;
6621 $filter =~ s/\.git$//;
6622 @forklist = git_get_projects_list($filter);
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]6623 # filter out forks of forks
6624 @forklist = filter_forks_from_projects_list(\@forklist)
6625 if (@forklist);
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6626 }
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]6627
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6628 git_header_html();
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6629 git_print_page_nav('summary','', $head);
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6630
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]6631 print "<div class=\"title\">&nbsp;</div>\n";
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]6632 print "<table class=\"projects_list\">\n" .
Kacper Kornet0ebe7822012-04-26 18:45:44 +0200[diff] [blame]6633 "<tr id=\"metadata_desc\"><td>description</td><td>" . esc_html($descr) . "</td></tr>\n";
Tony Finch860ccc62013-08-20 17:59:44 +0100[diff] [blame]6634 if ($owner and not $omit_owner) {
Kacper Kornet0ebe7822012-04-26 18:45:44 +0200[diff] [blame]6635 print "<tr id=\"metadata_owner\"><td>owner</td><td>" . esc_html($owner) . "</td></tr>\n";
6636 }
Jakub Narebski785cdea2007-05-13 12:39:22 +0200[diff] [blame]6637 if (defined $cd{'rfc2822'}) {
Jakub Narebski256b7b42011-04-28 21:04:07 +0200[diff] [blame]6638 print "<tr id=\"metadata_lchange\"><td>last change</td>" .
6639 "<td>".format_timestamp_html(\%cd)."</td></tr>\n";
Jakub Narebski785cdea2007-05-13 12:39:22 +0200[diff] [blame]6640 }
6641
Jakub Narebskie79ca7c2006-08-16 14:50:34 +0200[diff] [blame]6642 # use per project git URL list in $projectroot/$project/cloneurl
6643 # or make project git URL from git base URL and project name
Jakub Narebski19a87212006-08-15 23:03:17 +0200[diff] [blame]6644 my $url_tag = "URL";
Jakub Narebskie79ca7c2006-08-16 14:50:34 +0200[diff] [blame]6645 my @url_list = git_get_project_url_list($project);
6646 @url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
6647 foreach my $git_url (@url_list) {
6648 next unless $git_url;
Giuseppe Bilotta0e656992010-11-11 13:26:15 +0100[diff] [blame]6649 print format_repo_url($url_tag, $git_url);
Jakub Narebski19a87212006-08-15 23:03:17 +0200[diff] [blame]6650 $url_tag = "";
6651 }
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]6652
6653 # Tag cloud
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]6654 my $show_ctags = gitweb_check_feature('ctags');
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]6655 if ($show_ctags) {
6656 my $ctags = git_get_project_ctags($project);
Jakub Narebski0368c492011-04-29 19:51:57 +0200[diff] [blame]6657 if (%$ctags) {
6658 # without ability to add tags, don't show if there are none
6659 my $cloud = git_populate_project_tagcloud($ctags);
6660 print "<tr id=\"metadata_ctags\">" .
6661 "<td>content tags</td>" .
6662 "<td>".git_show_project_tagcloud($cloud, 48)."</td>" .
6663 "</tr>\n";
6664 }
Petr Baudisaed93de2008-10-02 17:13:02 +0200[diff] [blame]6665 }
6666
Jakub Narebski19a87212006-08-15 23:03:17 +0200[diff] [blame]6667 print "</table>\n";
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6668
Matt McCutchen7e1100e2009-02-07 19:00:09 -0500[diff] [blame]6669 # If XSS prevention is on, we don't include README.html.
6670 # TODO: Allow a readme in some safe format.
6671 if (!$prevent_xss && -s "$projectroot/$project/README.html") {
Jakub Narebski2dcb5e12008-12-01 19:01:42 +0100[diff] [blame]6672 print "<div class=\"title\">readme</div>\n" .
6673 "<div class=\"readme\">\n";
6674 insert_file("$projectroot/$project/README.html");
6675 print "\n</div>\n"; # class="readme"
Petr Baudis447ef092006-10-24 05:23:46 +0200[diff] [blame]6676 }
6677
Robert Fitzsimons313ce8c2006-12-19 12:08:54 +0000[diff] [blame]6678 # we need to request one more than 16 (0..15) to check if
6679 # those 16 are all
Jakub Narebski785cdea2007-05-13 12:39:22 +0200[diff] [blame]6680 my @commitlist = $head ? parse_commits($head, 17) : ();
6681 if (@commitlist) {
6682 git_print_header_div('shortlog');
6683 git_shortlog_body(\@commitlist, 0, 15, $refs,
6684 $#commitlist <= 15 ? undef :
6685 $cgi->a({-href => href(action=>"shortlog")}, "..."));
6686 }
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6687
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]6688 if (@taglist) {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6689 git_print_header_div('tags');
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]6690 git_tags_body(\@taglist, 0, 15,
Robert Fitzsimons313ce8c2006-12-19 12:08:54 +0000[diff] [blame]6691 $#taglist <= 15 ? undef :
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]6692 $cgi->a({-href => href(action=>"tags")}, "..."));
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6693 }
Kay Sievers0db37972005-08-07 20:24:35 +0200[diff] [blame]6694
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]6695 if (@headlist) {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6696 git_print_header_div('heads');
Jakub Narebski120ddde2006-09-19 14:33:22 +0200[diff] [blame]6697 git_heads_body(\@headlist, $head, 0, 15,
Robert Fitzsimons313ce8c2006-12-19 12:08:54 +0000[diff] [blame]6698 $#headlist <= 15 ? undef :
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]6699 $cgi->a({-href => href(action=>"heads")}, "..."));
Kay Sievers0db37972005-08-07 20:24:35 +0200[diff] [blame]6700 }
Jakub Narebski9f5dcb82006-07-31 11:22:13 +0200[diff] [blame]6701
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]6702 if (%remotedata) {
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]6703 git_print_header_div('remotes');
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]6704 git_remotes_body(\%remotedata, 15, $head);
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]6705 }
6706
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6707 if (@forklist) {
6708 git_print_header_div('forks');
Mike Ralphsonf04f27e2008-09-25 18:48:48 +0200[diff] [blame]6709 git_project_list_body(\@forklist, 'age', 0, 15,
Robert Fitzsimonsaaca9672006-12-22 19:38:12 +0000[diff] [blame]6710 $#forklist <= 15 ? undef :
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6711 $cgi->a({-href => href(action=>"forks")}, "..."),
Mike Ralphsonf04f27e2008-09-25 18:48:48 +0200[diff] [blame]6712 'no_header');
Petr Baudise30496d2006-10-24 05:33:17 +0200[diff] [blame]6713 }
6714
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6715 git_footer_html();
6716}
6717
Kay Sieversd8a20ba2005-08-07 20:28:53 +0200[diff] [blame]6718sub git_tag {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6719 my %tag = parse_tag($hash);
Jakub Narebski198a2a82007-05-12 21:16:34 +0200[diff] [blame]6720
6721 if (! %tag) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6722 die_error(404, "Unknown tag object");
Jakub Narebski198a2a82007-05-12 21:16:34 +0200[diff] [blame]6723 }
6724
Anders Kaseorgd8a94802010-08-27 13:38:16 -0400[diff] [blame]6725 my $head = git_get_head_hash($project);
6726 git_header_html();
6727 git_print_page_nav('','', $head,undef,$head);
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6728 git_print_header_div('commit', esc_html($tag{'name'}), $hash);
Kay Sieversd8a20ba2005-08-07 20:28:53 +0200[diff] [blame]6729 print "<div class=\"title_text\">\n" .
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]6730 "<table class=\"object_header\">\n" .
Kay Sieverse4669df2005-08-08 00:02:39 +0200[diff] [blame]6731 "<tr>\n" .
6732 "<td>object</td>\n" .
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]6733 "<td>" . $cgi->a({-class => "list", -href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
6734 $tag{'object'}) . "</td>\n" .
6735 "<td class=\"link\">" . $cgi->a({-href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
6736 $tag{'type'}) . "</td>\n" .
Kay Sieverse4669df2005-08-08 00:02:39 +0200[diff] [blame]6737 "</tr>\n";
Kay Sieversd8a20ba2005-08-07 20:28:53 +0200[diff] [blame]6738 if (defined($tag{'author'})) {
Giuseppe Bilottaba924732009-06-30 00:00:50 +0200[diff] [blame]6739 git_print_authorship_rows(\%tag, 'author');
Kay Sieversd8a20ba2005-08-07 20:28:53 +0200[diff] [blame]6740 }
6741 print "</table>\n\n" .
6742 "</div>\n";
6743 print "<div class=\"page_body\">";
6744 my $comment = $tag{'comment'};
6745 foreach my $line (@$comment) {
Junio C Hamano70022432006-11-24 14:04:01 -0800[diff] [blame]6746 chomp $line;
Jakub Narebski793c4002006-11-24 22:25:50 +0100[diff] [blame]6747 print esc_html($line, -nbsp=>1) . "<br/>\n";
Kay Sieversd8a20ba2005-08-07 20:28:53 +0200[diff] [blame]6748 }
6749 print "</div>\n";
6750 git_footer_html();
6751}
6752
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6753sub git_blame_common {
6754 my $format = shift || 'porcelain';
Jakub Narebski84d9e2d2012-02-03 13:44:54 +0100[diff] [blame]6755 if ($format eq 'porcelain' && $input_params{'javascript'}) {
Jakub Narebskic4ccf612009-09-01 13:39:19 +0200[diff] [blame]6756 $format = 'incremental';
6757 $action = 'blame_incremental'; # for page title etc
6758 }
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6759
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6760 # permissions
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]6761 gitweb_check_feature('blame')
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6762 or die_error(403, "Blame view not allowed");
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6763
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6764 # error checking
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6765 die_error(400, "No file name given") unless $file_name;
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6766 $hash_base ||= git_get_head_hash($project);
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6767 die_error(404, "Couldn't find base commit") unless $hash_base;
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6768 my %co = parse_commit($hash_base)
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6769 or die_error(404, "Commit not found");
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6770 my $ftype = "blob";
Luben Tuikov1f2857e2006-07-23 13:34:55 -0700[diff] [blame]6771 if (!defined $hash) {
6772 $hash = git_get_hash_by_path($hash_base, $file_name, "blob")
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]6773 or die_error(404, "Error looking up file");
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6774 } else {
6775 $ftype = git_get_type($hash);
6776 if ($ftype !~ "blob") {
6777 die_error(400, "Object is not a blob");
6778 }
Luben Tuikov1f2857e2006-07-23 13:34:55 -0700[diff] [blame]6779 }
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6780
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6781 my $fd;
6782 if ($format eq 'incremental') {
6783 # get file contents (as base)
6784 open $fd, "-|", git_cmd(), 'cat-file', 'blob', $hash
6785 or die_error(500, "Open git-cat-file failed");
6786 } elsif ($format eq 'data') {
6787 # run git-blame --incremental
6788 open $fd, "-|", git_cmd(), "blame", "--incremental",
6789 $hash_base, "--", $file_name
6790 or die_error(500, "Open git-blame --incremental failed");
6791 } else {
6792 # run git-blame --porcelain
6793 open $fd, "-|", git_cmd(), "blame", '-p',
6794 $hash_base, '--', $file_name
6795 or die_error(500, "Open git-blame --porcelain failed");
6796 }
Ævar Arnfjörð Bjarmasonfd870042013-08-30 08:37:01 +0000[diff] [blame]6797 binmode $fd, ':utf8';
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6798
6799 # incremental blame data returns early
6800 if ($format eq 'data') {
6801 print $cgi->header(
6802 -type=>"text/plain", -charset => "utf-8",
6803 -status=> "200 OK");
6804 local $| = 1; # output autoflush
Jürgen Kreileder57cf4ad2011-12-17 10:22:23 +0100[diff] [blame]6805 while (my $line = <$fd>) {
6806 print to_utf8($line);
6807 }
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6808 close $fd
6809 or print "ERROR $!\n";
6810
6811 print 'END';
6812 if (defined $t0 && gitweb_check_feature('timed')) {
6813 print ' '.
Jakub Narebski3962f1d72010-11-09 19:27:54 +0100[diff] [blame]6814 tv_interval($t0, [ gettimeofday() ]).
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6815 ' '.$number_of_git_cmds;
6816 }
6817 print "\n";
6818
6819 return;
6820 }
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6821
6822 # page header
Luben Tuikov1f2857e2006-07-23 13:34:55 -0700[diff] [blame]6823 git_header_html();
Jakub Narebski0d83ddc2006-07-30 15:01:07 +0200[diff] [blame]6824 my $formats_nav =
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]6825 $cgi->a({-href => href(action=>"blob", -replay=>1)},
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]6826 "blob") .
Jakub Narebski87e573f2009-12-01 17:54:26 +0100[diff] [blame]6827 " | ";
6828 if ($format eq 'incremental') {
6829 $formats_nav .=
6830 $cgi->a({-href => href(action=>"blame", javascript=>0, -replay=>1)},
6831 "blame") . " (non-incremental)";
6832 } else {
6833 $formats_nav .=
6834 $cgi->a({-href => href(action=>"blame_incremental", -replay=>1)},
6835 "blame") . " (incremental)";
6836 }
6837 $formats_nav .=
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]6838 " | " .
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]6839 $cgi->a({-href => href(action=>"history", -replay=>1)},
6840 "history") .
Petr Baudiscae18622006-09-22 03:19:41 +0200[diff] [blame]6841 " | " .
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6842 $cgi->a({-href => href(action=>$action, file_name=>$file_name)},
Petr Baudisf35274d2006-09-22 03:19:53 +0200[diff] [blame]6843 "HEAD");
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6844 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
6845 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
Luben Tuikov59fb1c92006-08-17 10:39:29 -0700[diff] [blame]6846 git_print_page_path($file_name, $ftype, $hash_base);
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6847
6848 # page body
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6849 if ($format eq 'incremental') {
6850 print "<noscript>\n<div class=\"error\"><center><b>\n".
6851 "This page requires JavaScript to run.\n Use ".
Jakub Narebskic4ccf612009-09-01 13:39:19 +0200[diff] [blame]6852 $cgi->a({-href => href(action=>'blame',javascript=>0,-replay=>1)},
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6853 'this page').
6854 " instead.\n".
6855 "</b></center></div>\n</noscript>\n";
6856
6857 print qq!<div id="progress_bar" style="width: 100%; background-color: yellow"></div>\n!;
6858 }
6859
6860 print qq!<div class="page_body">\n!;
6861 print qq!<div id="progress_info">... / ...</div>\n!
6862 if ($format eq 'incremental');
6863 print qq!<table id="blame_table" class="blame" width="100%">\n!.
6864 #qq!<col width="5.5em" /><col width="2.5em" /><col width="*" />\n!.
6865 qq!<thead>\n!.
6866 qq!<tr><th>Commit</th><th>Line</th><th>Data</th></tr>\n!.
6867 qq!</thead>\n!.
6868 qq!<tbody>\n!;
6869
Jakub Narebskiaef37682009-07-25 00:44:06 +0200[diff] [blame]6870 my @rev_color = qw(light dark);
Luben Tuikovcc1bf972006-07-23 13:37:53 -0700[diff] [blame]6871 my $num_colors = scalar(@rev_color);
6872 my $current_color = 0;
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6873
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6874 if ($format eq 'incremental') {
6875 my $color_class = $rev_color[$current_color];
6876
6877 #contents of a file
6878 my $linenr = 0;
6879 LINE:
6880 while (my $line = <$fd>) {
6881 chomp $line;
6882 $linenr++;
6883
6884 print qq!<tr id="l$linenr" class="$color_class">!.
6885 qq!<td class="sha1"><a href=""> </a></td>!.
6886 qq!<td class="linenr">!.
6887 qq!<a class="linenr" href="">$linenr</a></td>!;
6888 print qq!<td class="pre">! . esc_html($line) . "</td>\n";
6889 print qq!</tr>\n!;
Junio C Hamanoeeef88c2006-10-05 13:55:58 -0700[diff] [blame]6890 }
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6891
6892 } else { # porcelain, i.e. ordinary blame
6893 my %metainfo = (); # saves information about commits
6894
6895 # blame data
6896 LINE:
6897 while (my $line = <$fd>) {
6898 chomp $line;
6899 # the header: <SHA-1> <src lineno> <dst lineno> [<lines in group>]
6900 # no <lines in group> for subsequent lines in group of lines
6901 my ($full_rev, $orig_lineno, $lineno, $group_size) =
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]6902 ($line =~ /^($oid_regex) (\d+) (\d+)(?: (\d+))?$/);
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6903 if (!exists $metainfo{$full_rev}) {
6904 $metainfo{$full_rev} = { 'nprevious' => 0 };
Junio C Hamanoeeef88c2006-10-05 13:55:58 -0700[diff] [blame]6905 }
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6906 my $meta = $metainfo{$full_rev};
6907 my $data;
6908 while ($data = <$fd>) {
6909 chomp $data;
6910 last if ($data =~ s/^\t//); # contents of line
6911 if ($data =~ /^(\S+)(?: (.*))?$/) {
6912 $meta->{$1} = $2 unless exists $meta->{$1};
6913 }
6914 if ($data =~ /^previous /) {
6915 $meta->{'nprevious'}++;
Jakub Narebskia36817b2009-07-25 00:44:05 +0200[diff] [blame]6916 }
6917 }
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6918 my $short_rev = substr($full_rev, 0, 8);
6919 my $author = $meta->{'author'};
6920 my %date =
6921 parse_date($meta->{'author-time'}, $meta->{'author-tz'});
6922 my $date = $date{'iso-tz'};
6923 if ($group_size) {
6924 $current_color = ($current_color + 1) % $num_colors;
6925 }
6926 my $tr_class = $rev_color[$current_color];
6927 $tr_class .= ' boundary' if (exists $meta->{'boundary'});
6928 $tr_class .= ' no-previous' if ($meta->{'nprevious'} == 0);
6929 $tr_class .= ' multiple-previous' if ($meta->{'nprevious'} > 1);
6930 print "<tr id=\"l$lineno\" class=\"$tr_class\">\n";
6931 if ($group_size) {
6932 print "<td class=\"sha1\"";
6933 print " title=\"". esc_html($author) . ", $date\"";
6934 print " rowspan=\"$group_size\"" if ($group_size > 1);
6935 print ">";
6936 print $cgi->a({-href => href(action=>"commit",
6937 hash=>$full_rev,
6938 file_name=>$file_name)},
6939 esc_html($short_rev));
6940 if ($group_size >= 2) {
6941 my @author_initials = ($author =~ /\b([[:upper:]])\B/g);
6942 if (@author_initials) {
6943 print "<br />" .
6944 esc_html(join('', @author_initials));
6945 # or join('.', ...)
6946 }
6947 }
6948 print "</td>\n";
6949 }
6950 # 'previous' <sha1 of parent commit> <filename at commit>
6951 if (exists $meta->{'previous'} &&
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]6952 $meta->{'previous'} =~ /^($oid_regex) (.*)$/) {
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6953 $meta->{'parent'} = $1;
6954 $meta->{'file_parent'} = unquote($2);
6955 }
6956 my $linenr_commit =
6957 exists($meta->{'parent'}) ?
6958 $meta->{'parent'} : $full_rev;
6959 my $linenr_filename =
6960 exists($meta->{'file_parent'}) ?
6961 $meta->{'file_parent'} : unquote($meta->{'filename'});
6962 my $blamed = href(action => 'blame',
6963 file_name => $linenr_filename,
6964 hash_base => $linenr_commit);
6965 print "<td class=\"linenr\">";
6966 print $cgi->a({ -href => "$blamed#l$orig_lineno",
6967 -class => "linenr" },
6968 esc_html($lineno));
6969 print "</td>";
6970 print "<td class=\"pre\">" . esc_html($data) . "</td>\n";
6971 print "</tr>\n";
6972 } # end while
6973
Luben Tuikov1f2857e2006-07-23 13:34:55 -0700[diff] [blame]6974 }
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6975
6976 # footer
6977 print "</tbody>\n".
6978 "</table>\n"; # class="blame"
6979 print "</div>\n"; # class="blame_body"
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]6980 close $fd
6981 or print "Reading blob failed\n";
Jakub Narebskid2ce10d2008-12-09 23:48:51 +0100[diff] [blame]6982
Luben Tuikov1f2857e2006-07-23 13:34:55 -0700[diff] [blame]6983 git_footer_html();
6984}
6985
Jakub Narebski4af819d2009-09-01 13:39:17 +0200[diff] [blame]6986sub git_blame {
6987 git_blame_common();
6988}
6989
6990sub git_blame_incremental {
6991 git_blame_common('incremental');
6992}
6993
6994sub git_blame_data {
6995 git_blame_common('data');
6996}
6997
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]6998sub git_tags {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]6999 my $head = git_get_head_hash($project);
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]7000 git_header_html();
Giuseppe Bilotta11e7bec2010-11-11 13:26:12 +0100[diff] [blame]7001 git_print_page_nav('','', $head,undef,$head,format_ref_views('tags'));
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7002 git_print_header_div('summary', $project);
Jakub Narebski27fb8c42006-07-30 20:32:01 +0200[diff] [blame]7003
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]7004 my @tagslist = git_get_tags_list();
7005 if (@tagslist) {
7006 git_tags_body(\@tagslist);
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]7007 }
Kay Sieversede5e102005-08-07 20:23:12 +0200[diff] [blame]7008 git_footer_html();
7009}
7010
Kay Sieversd8f1c5c2005-10-04 01:12:47 +0200[diff] [blame]7011sub git_heads {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7012 my $head = git_get_head_hash($project);
Kay Sievers0db37972005-08-07 20:24:35 +0200[diff] [blame]7013 git_header_html();
Giuseppe Bilotta11e7bec2010-11-11 13:26:12 +0100[diff] [blame]7014 git_print_page_nav('','', $head,undef,$head,format_ref_views('heads'));
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7015 git_print_header_div('summary', $project);
Jakub Narebski27fb8c42006-07-30 20:32:01 +0200[diff] [blame]7016
Jakub Narebskicd146402006-11-02 20:23:11 +0100[diff] [blame]7017 my @headslist = git_get_heads_list();
7018 if (@headslist) {
7019 git_heads_body(\@headslist, $head);
Kay Sievers0db37972005-08-07 20:24:35 +0200[diff] [blame]7020 }
Kay Sievers0db37972005-08-07 20:24:35 +0200[diff] [blame]7021 git_footer_html();
7022}
7023
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]7024# used both for single remote view and for list of all the remotes
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]7025sub git_remotes {
7026 gitweb_check_feature('remote_heads')
7027 or die_error(403, "Remote heads view is disabled");
7028
7029 my $head = git_get_head_hash($project);
Giuseppe Bilottabb607762010-11-11 13:26:14 +0100[diff] [blame]7030 my $remote = $input_params{'hash'};
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]7031
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]7032 my $remotedata = git_get_remotes_list($remote);
7033 die_error(500, "Unable to get remote information") unless defined $remotedata;
Giuseppe Bilottabb607762010-11-11 13:26:14 +0100[diff] [blame]7034
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]7035 unless (%$remotedata) {
7036 die_error(404, defined $remote ?
7037 "Remote $remote not found" :
7038 "No remotes found");
Giuseppe Bilottabb607762010-11-11 13:26:14 +0100[diff] [blame]7039 }
7040
7041 git_header_html(undef, undef, -action_extra => $remote);
7042 git_print_page_nav('', '', $head, undef, $head,
7043 format_ref_views($remote ? '' : 'remotes'));
7044
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]7045 fill_remote_heads($remotedata);
Giuseppe Bilottabb607762010-11-11 13:26:14 +0100[diff] [blame]7046 if (defined $remote) {
7047 git_print_header_div('remotes', "$remote remote for $project");
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]7048 git_remote_block($remote, $remotedata->{$remote}, undef, $head);
Giuseppe Bilottabb607762010-11-11 13:26:14 +0100[diff] [blame]7049 } else {
7050 git_print_header_div('summary', "$project remotes");
Giuseppe Bilotta9d0d42f2010-11-11 13:26:17 +0100[diff] [blame]7051 git_remotes_body($remotedata, undef, $head);
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]7052 }
Giuseppe Bilottabb607762010-11-11 13:26:14 +0100[diff] [blame]7053
Giuseppe Bilotta00fa6fe2010-11-11 13:26:11 +0100[diff] [blame]7054 git_footer_html();
7055}
7056
Luben Tuikov930cf7d2006-07-09 20:18:57 -0700[diff] [blame]7057sub git_blob_plain {
Jakub Narebski7f718e82008-06-03 16:47:10 +0200[diff] [blame]7058 my $type = shift;
Jakub Narebskif2e73302006-08-26 19:14:25 +0200[diff] [blame]7059 my $expires;
Jakub Narebskif2e73302006-08-26 19:14:25 +0200[diff] [blame]7060
Luben Tuikovcff07712006-07-23 13:28:55 -0700[diff] [blame]7061 if (!defined $hash) {
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7062 if (defined $file_name) {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7063 my $base = $hash_base || git_get_head_hash($project);
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7064 $hash = git_get_hash_by_path($base, $file_name, "blob")
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7065 or die_error(404, "Cannot find file");
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7066 } else {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7067 die_error(400, "No file name defined");
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7068 }
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7069 } elsif ($hash =~ m/^$oid_regex$/) {
Martin Waitz800764c2006-09-16 23:09:02 +0200[diff] [blame]7070 # blobs defined by non-textual hash id's can be cached
7071 $expires = "+1d";
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7072 }
Martin Waitz800764c2006-09-16 23:09:02 +0200[diff] [blame]7073
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]7074 open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7075 or die_error(500, "Open git-cat-file blob '$hash' failed");
Luben Tuikov930cf7d2006-07-09 20:18:57 -0700[diff] [blame]7076
Jakub Narebski7f718e82008-06-03 16:47:10 +0200[diff] [blame]7077 # content-type (can include charset)
7078 $type = blob_contenttype($fd, $file_name, $type);
Luben Tuikov930cf7d2006-07-09 20:18:57 -0700[diff] [blame]7079
Jakub Narebski7f718e82008-06-03 16:47:10 +0200[diff] [blame]7080 # "save as" filename, even when no $file_name is given
Luben Tuikov930cf7d2006-07-09 20:18:57 -0700[diff] [blame]7081 my $save_as = "$hash";
7082 if (defined $file_name) {
7083 $save_as = $file_name;
7084 } elsif ($type =~ m/^text\//) {
7085 $save_as .= '.txt';
7086 }
7087
Matt McCutchen7e1100e2009-02-07 19:00:09 -0500[diff] [blame]7088 # With XSS prevention on, blobs of all types except a few known safe
7089 # ones are served with "Content-Disposition: attachment" to make sure
7090 # they don't run in our security domain. For certain image types,
7091 # blob view writes an <img> tag referring to blob_plain view, and we
7092 # want to be sure not to break that by serving the image as an
7093 # attachment (though Firefox 3 doesn't seem to care).
7094 my $sandbox = $prevent_xss &&
Jakub Narebski86afbd02011-06-30 11:39:20 +0200[diff] [blame]7095 $type !~ m!^(?:text/[a-z]+|image/(?:gif|png|jpeg))(?:[ ;]|$)!;
7096
7097 # serve text/* as text/plain
7098 if ($prevent_xss &&
Jakub Narebskie8c35312011-06-30 11:39:21 +0200[diff] [blame]7099 ($type =~ m!^text/[a-z]+\b(.*)$! ||
7100 ($type =~ m!^[a-z]+/[a-z]\+xml\b(.*)$! && -T $fd))) {
Jakub Narebski86afbd02011-06-30 11:39:20 +0200[diff] [blame]7101 my $rest = $1;
7102 $rest = defined $rest ? $rest : '';
7103 $type = "text/plain$rest";
7104 }
Matt McCutchen7e1100e2009-02-07 19:00:09 -0500[diff] [blame]7105
Jakub Narebskif2e73302006-08-26 19:14:25 +0200[diff] [blame]7106 print $cgi->header(
Jakub Narebski7f718e82008-06-03 16:47:10 +0200[diff] [blame]7107 -type => $type,
7108 -expires => $expires,
Matt McCutchen7e1100e2009-02-07 19:00:09 -0500[diff] [blame]7109 -content_disposition =>
7110 ($sandbox ? 'attachment' : 'inline')
7111 . '; filename="' . $save_as . '"');
Jakub Narebski34122b52009-05-11 03:29:40 +0200[diff] [blame]7112 local $/ = undef;
Julien Moutinho2ecfcde2020-03-29 01:20:28 +0100[diff] [blame]7113 local *FCGI::Stream::PRINT = $FCGI_Stream_PRINT_raw;
Luben Tuikov930cf7d2006-07-09 20:18:57 -0700[diff] [blame]7114 binmode STDOUT, ':raw';
7115 print <$fd>;
7116 binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
Luben Tuikov930cf7d2006-07-09 20:18:57 -0700[diff] [blame]7117 close $fd;
7118}
7119
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7120sub git_blob {
Jakub Narebskif2e73302006-08-26 19:14:25 +0200[diff] [blame]7121 my $expires;
Jakub Narebskif2e73302006-08-26 19:14:25 +0200[diff] [blame]7122
Luben Tuikovcff07712006-07-23 13:28:55 -0700[diff] [blame]7123 if (!defined $hash) {
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7124 if (defined $file_name) {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7125 my $base = $hash_base || git_get_head_hash($project);
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7126 $hash = git_get_hash_by_path($base, $file_name, "blob")
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7127 or die_error(404, "Cannot find file");
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7128 } else {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7129 die_error(400, "No file name defined");
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7130 }
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7131 } elsif ($hash =~ m/^$oid_regex$/) {
Martin Waitz800764c2006-09-16 23:09:02 +0200[diff] [blame]7132 # blobs defined by non-textual hash id's can be cached
7133 $expires = "+1d";
Jakub Narebski5be01bc2006-07-29 22:43:40 +0200[diff] [blame]7134 }
Martin Waitz800764c2006-09-16 23:09:02 +0200[diff] [blame]7135
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]7136 my $have_blame = gitweb_check_feature('blame');
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]7137 open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7138 or die_error(500, "Couldn't cat $file_name, $hash");
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7139 my $mimetype = blob_mimetype($fd, $file_name);
Johannes Schindelinb331fe52010-04-27 21:34:44 +0200[diff] [blame]7140 # use 'blob_plain' (aka 'raw') view for files that cannot be displayed
Jakub Narebskidfa7c7d2007-12-15 15:41:49 +0100[diff] [blame]7141 if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)! && -B $fd) {
Luben Tuikov930cf7d2006-07-09 20:18:57 -0700[diff] [blame]7142 close $fd;
7143 return git_blob_plain($mimetype);
7144 }
Jakub Narebski5a4cf332006-12-04 23:47:22 +0100[diff] [blame]7145 # we can have blame only for text/* mimetype
7146 $have_blame &&= ($mimetype =~ m!^text/!);
7147
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]7148 my $highlight = gitweb_check_feature('highlight');
Ian Kellingc151aa32016-09-24 15:32:57 -0700[diff] [blame]7149 my $syntax = guess_file_syntax($highlight, $file_name);
Ian Kelling779a2062016-09-24 15:32:58 -0700[diff] [blame]7150 $fd = run_highlighter($fd, $highlight, $syntax);
Johannes Schindelinb331fe52010-04-27 21:34:44 +0200[diff] [blame]7151
Jakub Narebskif2e73302006-08-26 19:14:25 +0200[diff] [blame]7152 git_header_html(undef, $expires);
Jakub Narebski0d83ddc2006-07-30 15:01:07 +0200[diff] [blame]7153 my $formats_nav = '';
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7154 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
Kay Sievers93129442005-10-17 03:27:54 +0200[diff] [blame]7155 if (defined $file_name) {
Florian Forster5996ca02006-06-12 10:31:57 +0200[diff] [blame]7156 if ($have_blame) {
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7157 $formats_nav .=
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]7158 $cgi->a({-href => href(action=>"blame", -replay=>1)},
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7159 "blame") .
7160 " | ";
Florian Forster5996ca02006-06-12 10:31:57 +0200[diff] [blame]7161 }
Jakub Narebski0d83ddc2006-07-30 15:01:07 +0200[diff] [blame]7162 $formats_nav .=
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]7163 $cgi->a({-href => href(action=>"history", -replay=>1)},
Petr Baudiscae18622006-09-22 03:19:41 +0200[diff] [blame]7164 "history") .
7165 " | " .
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]7166 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
Petr Baudis35329cc2006-09-22 03:19:50 +0200[diff] [blame]7167 "raw") .
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7168 " | " .
7169 $cgi->a({-href => href(action=>"blob",
7170 hash_base=>"HEAD", file_name=>$file_name)},
Petr Baudisf35274d2006-09-22 03:19:53 +0200[diff] [blame]7171 "HEAD");
Kay Sievers93129442005-10-17 03:27:54 +0200[diff] [blame]7172 } else {
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7173 $formats_nav .=
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]7174 $cgi->a({-href => href(action=>"blob_plain", -replay=>1)},
7175 "raw");
Kay Sievers93129442005-10-17 03:27:54 +0200[diff] [blame]7176 }
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7177 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
7178 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7179 } else {
7180 print "<div class=\"page_nav\">\n" .
7181 "<br/><br/></div>\n" .
Jakub Narebski3017ed62010-12-15 00:34:01 +0100[diff] [blame]7182 "<div class=\"title\">".esc_html($hash)."</div>\n";
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7183 }
Luben Tuikov59fb1c92006-08-17 10:39:29 -0700[diff] [blame]7184 git_print_page_path($file_name, "blob", $hash_base);
Kay Sieversc07ad4b2005-08-07 20:22:44 +0200[diff] [blame]7185 print "<div class=\"page_body\">\n";
Jakub Narebskidfa7c7d2007-12-15 15:41:49 +0100[diff] [blame]7186 if ($mimetype =~ m!^image/!) {
Andrew Keller46a74712014-02-17 09:25:13 -0500[diff] [blame]7187 print qq!<img class="blob" type="!.esc_attr($mimetype).qq!"!;
Jakub Narebski5a4cf332006-12-04 23:47:22 +0100[diff] [blame]7188 if ($file_name) {
Jakub Narebski3017ed62010-12-15 00:34:01 +0100[diff] [blame]7189 print qq! alt="!.esc_attr($file_name).qq!" title="!.esc_attr($file_name).qq!"!;
Jakub Narebski5a4cf332006-12-04 23:47:22 +0100[diff] [blame]7190 }
7191 print qq! src="! .
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]7192 esc_attr(href(action=>"blob_plain", hash=>$hash,
7193 hash_base=>$hash_base, file_name=>$file_name)) .
Jakub Narebski5a4cf332006-12-04 23:47:22 +0100[diff] [blame]7194 qq!" />\n!;
Jakub Narebskidfa7c7d2007-12-15 15:41:49 +0100[diff] [blame]7195 } else {
7196 my $nr;
7197 while (my $line = <$fd>) {
7198 chomp $line;
7199 $nr++;
7200 $line = untabify($line);
Jakub Narebski592ea412010-04-27 21:34:45 +0200[diff] [blame]7201 printf qq!<div class="pre"><a id="l%i" href="%s#l%i" class="linenr">%4i</a> %s</div>\n!,
Jakub Narebski08667862011-09-16 14:41:57 +0200[diff] [blame]7202 $nr, esc_attr(href(-replay => 1)), $nr, $nr,
Ian Kelling779a2062016-09-24 15:32:58 -0700[diff] [blame]7203 $highlight ? sanitize($line) : esc_html($line, -nbsp=>1);
Jakub Narebskidfa7c7d2007-12-15 15:41:49 +0100[diff] [blame]7204 }
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]7205 }
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7206 close $fd
7207 or print "Reading blob failed.\n";
Kay Sieversfbb592a2005-08-07 20:12:11 +0200[diff] [blame]7208 print "</div>";
Kay Sievers12a88f22005-08-07 20:02:47 +0200[diff] [blame]7209 git_footer_html();
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7210}
7211
7212sub git_tree {
Luben Tuikov6f7ea5f2006-09-29 09:57:43 -0700[diff] [blame]7213 if (!defined $hash_base) {
7214 $hash_base = "HEAD";
7215 }
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]7216 if (!defined $hash) {
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7217 if (defined $file_name) {
Luben Tuikov6f7ea5f2006-09-29 09:57:43 -0700[diff] [blame]7218 $hash = git_get_hash_by_path($hash_base, $file_name, "tree");
7219 } else {
7220 $hash = $hash_base;
Kay Sievers10dba282005-08-07 20:25:27 +0200[diff] [blame]7221 }
Kay Sieverse925f382005-08-07 20:23:35 +0200[diff] [blame]7222 }
Jakub Narebski2d7a3532008-10-02 16:50:04 +0200[diff] [blame]7223 die_error(404, "No such tree") unless defined($hash);
Jakub Narebski34122b52009-05-11 03:29:40 +0200[diff] [blame]7224
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]7225 my $show_sizes = gitweb_check_feature('show-sizes');
7226 my $have_blame = gitweb_check_feature('blame');
7227
Jakub Narebski34122b52009-05-11 03:29:40 +0200[diff] [blame]7228 my @entries = ();
7229 {
7230 local $/ = "\0";
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]7231 open my $fd, "-|", git_cmd(), "ls-tree", '-z',
7232 ($show_sizes ? '-l' : ()), @extra_options, $hash
Jakub Narebski34122b52009-05-11 03:29:40 +0200[diff] [blame]7233 or die_error(500, "Open git-ls-tree failed");
7234 @entries = map { chomp; $_ } <$fd>;
7235 close $fd
7236 or die_error(404, "Reading tree failed");
7237 }
Kay Sieversd63577d2005-08-07 20:18:13 +0200[diff] [blame]7238
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7239 my $refs = git_get_references();
7240 my $ref = format_ref_marker($refs, $hash_base);
Kay Sievers12a88f22005-08-07 20:02:47 +0200[diff] [blame]7241 git_header_html();
Jakub Narebski300454f2006-10-21 17:53:09 +0200[diff] [blame]7242 my $basedir = '';
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7243 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
Petr Baudiscae18622006-09-22 03:19:41 +0200[diff] [blame]7244 my @views_nav = ();
7245 if (defined $file_name) {
7246 push @views_nav,
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]7247 $cgi->a({-href => href(action=>"history", -replay=>1)},
Petr Baudiscae18622006-09-22 03:19:41 +0200[diff] [blame]7248 "history"),
7249 $cgi->a({-href => href(action=>"tree",
7250 hash_base=>"HEAD", file_name=>$file_name)},
Petr Baudisf35274d2006-09-22 03:19:53 +0200[diff] [blame]7251 "HEAD"),
Petr Baudiscae18622006-09-22 03:19:41 +0200[diff] [blame]7252 }
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]7253 my $snapshot_links = format_snapshot_links($hash);
7254 if (defined $snapshot_links) {
Petr Baudiscae18622006-09-22 03:19:41 +0200[diff] [blame]7255 # FIXME: Should be available when we have no hash base as well.
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]7256 push @views_nav, $snapshot_links;
Petr Baudiscae18622006-09-22 03:19:41 +0200[diff] [blame]7257 }
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]7258 git_print_page_nav('tree','', $hash_base, undef, undef,
7259 join(' | ', @views_nav));
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7260 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash_base);
Kay Sieversd63577d2005-08-07 20:18:13 +0200[diff] [blame]7261 } else {
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]7262 undef $hash_base;
Kay Sieversd63577d2005-08-07 20:18:13 +0200[diff] [blame]7263 print "<div class=\"page_nav\">\n";
7264 print "<br/><br/></div>\n";
Jakub Narebski3017ed62010-12-15 00:34:01 +0100[diff] [blame]7265 print "<div class=\"title\">".esc_html($hash)."</div>\n";
Kay Sieversd63577d2005-08-07 20:18:13 +0200[diff] [blame]7266 }
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7267 if (defined $file_name) {
Jakub Narebski300454f2006-10-21 17:53:09 +0200[diff] [blame]7268 $basedir = $file_name;
7269 if ($basedir ne '' && substr($basedir, -1) ne '/') {
7270 $basedir .= '/';
7271 }
Jakub Narebski2d7a3532008-10-02 16:50:04 +0200[diff] [blame]7272 git_print_page_path($file_name, 'tree', $hash_base);
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7273 }
Kay Sieversfbb592a2005-08-07 20:12:11 +0200[diff] [blame]7274 print "<div class=\"page_body\">\n";
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]7275 print "<table class=\"tree\">\n";
Luben Tuikov6dd36ac2006-09-28 16:47:50 -0700[diff] [blame]7276 my $alternate = 1;
Jakub Narebskib6b7fc72006-10-21 17:54:44 +0200[diff] [blame]7277 # '..' (top directory) link if possible
7278 if (defined $hash_base &&
7279 defined $file_name && $file_name =~ m![^/]+$!) {
7280 if ($alternate) {
7281 print "<tr class=\"dark\">\n";
7282 } else {
7283 print "<tr class=\"light\">\n";
7284 }
7285 $alternate ^= 1;
7286
7287 my $up = $file_name;
7288 $up =~ s!/?[^/]+$!!;
7289 undef $up unless $up;
7290 # based on git_print_tree_entry
7291 print '<td class="mode">' . mode_str('040000') . "</td>\n";
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]7292 print '<td class="size">&nbsp;</td>'."\n" if $show_sizes;
Jakub Narebskib6b7fc72006-10-21 17:54:44 +0200[diff] [blame]7293 print '<td class="list">';
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]7294 print $cgi->a({-href => href(action=>"tree",
7295 hash_base=>$hash_base,
Jakub Narebskib6b7fc72006-10-21 17:54:44 +0200[diff] [blame]7296 file_name=>$up)},
7297 "..");
7298 print "</td>\n";
7299 print "<td class=\"link\"></td>\n";
7300
7301 print "</tr>\n";
7302 }
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]7303 foreach my $line (@entries) {
Jakub Narebskie4b48ea2009-09-07 14:40:00 +0200[diff] [blame]7304 my %t = parse_ls_tree_line($line, -z => 1, -l => $show_sizes);
Jakub Narebskicb849b42006-08-31 00:32:15 +0200[diff] [blame]7305
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7306 if ($alternate) {
Kay Sieversc994d622005-08-07 20:27:18 +0200[diff] [blame]7307 print "<tr class=\"dark\">\n";
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7308 } else {
Kay Sieversc994d622005-08-07 20:27:18 +0200[diff] [blame]7309 print "<tr class=\"light\">\n";
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7310 }
7311 $alternate ^= 1;
Jakub Narebskicb849b42006-08-31 00:32:15 +0200[diff] [blame]7312
Jakub Narebski300454f2006-10-21 17:53:09 +0200[diff] [blame]7313 git_print_tree_entry(\%t, $basedir, $hash_base, $have_blame);
Jakub Narebskifa702002006-08-31 00:35:07 +0200[diff] [blame]7314
Kay Sievers42f7eb92005-08-07 20:21:46 +0200[diff] [blame]7315 print "</tr>\n";
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]7316 }
Kay Sievers42f7eb92005-08-07 20:21:46 +0200[diff] [blame]7317 print "</table>\n" .
7318 "</div>";
Kay Sievers12a88f22005-08-07 20:02:47 +0200[diff] [blame]7319 git_footer_html();
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7320}
7321
Krzesimir Nowake3747472013-12-11 12:54:44 +0100[diff] [blame]7322sub sanitize_for_filename {
7323 my $name = shift;
7324
7325 $name =~ s!/!-!g;
7326 $name =~ s/[^[:alnum:]_.-]//g;
7327
7328 return $name;
7329}
7330
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7331sub snapshot_name {
7332 my ($project, $hash) = @_;
7333
7334 # path/to/project.git -> project
7335 # path/to/project/.git -> project
7336 my $name = to_utf8($project);
7337 $name =~ s,([^/])/*\.git$,$1,;
Krzesimir Nowake3747472013-12-11 12:54:44 +0100[diff] [blame]7338 $name = sanitize_for_filename(basename($name));
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7339
7340 my $ver = $hash;
7341 if ($hash =~ /^[0-9a-fA-F]+$/) {
7342 # shorten SHA-1 hash
7343 my $full_hash = git_get_full_hash($project, $hash);
7344 if ($full_hash =~ /^$hash/ && length($hash) > 7) {
7345 $ver = git_get_short_hash($project, $hash);
7346 }
7347 } elsif ($hash =~ m!^refs/tags/(.*)$!) {
7348 # tags don't need shortened SHA-1 hash
7349 $ver = $1;
7350 } else {
7351 # branches and other need shortened SHA-1 hash
Krzesimir Nowak8d646a92013-12-11 12:54:43 +0100[diff] [blame]7352 my $strip_refs = join '|', map { quotemeta } get_branch_refs();
7353 if ($hash =~ m!^refs/($strip_refs|remotes)/(.*)$!) {
Krzesimir Nowake3747472013-12-11 12:54:44 +0100[diff] [blame]7354 my $ref_dir = (defined $1) ? $1 : '';
7355 $ver = $2;
7356
7357 $ref_dir = sanitize_for_filename($ref_dir);
7358 # for refs neither in heads nor remotes we want to
7359 # add a ref dir to archive name
7360 if ($ref_dir ne '' and $ref_dir ne 'heads' and $ref_dir ne 'remotes') {
7361 $ver = $ref_dir . '-' . $ver;
7362 }
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7363 }
7364 $ver .= '-' . git_get_short_hash($project, $hash);
7365 }
Krzesimir Nowake3747472013-12-11 12:54:44 +0100[diff] [blame]7366 # special case of sanitization for filename - we change
7367 # slashes to dots instead of dashes
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7368 # in case of hierarchical branch names
7369 $ver =~ s!/!.!g;
Krzesimir Nowake3747472013-12-11 12:54:44 +0100[diff] [blame]7370 $ver =~ s/[^[:alnum:]_.-]//g;
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7371
7372 # name = project-version_string
7373 $name = "$name-$ver";
7374
7375 return wantarray ? ($name, $name) : $name;
7376}
7377
W. Trevor Kingb7d565e2012-03-29 08:45:48 -0400[diff] [blame]7378sub exit_if_unmodified_since {
7379 my ($latest_epoch) = @_;
7380 our $cgi;
7381
7382 my $if_modified = $cgi->http('IF_MODIFIED_SINCE');
7383 if (defined $if_modified) {
7384 my $since;
7385 if (eval { require HTTP::Date; 1; }) {
7386 $since = HTTP::Date::str2time($if_modified);
7387 } elsif (eval { require Time::ParseDate; 1; }) {
7388 $since = Time::ParseDate::parsedate($if_modified, GMT => 1);
7389 }
7390 if (defined $since && $latest_epoch <= $since) {
7391 my %latest_date = parse_date($latest_epoch);
7392 print $cgi->header(
7393 -last_modified => $latest_date{'rfc2822'},
7394 -status => '304 Not Modified');
7395 goto DONE_GITWEB;
7396 }
7397 }
7398}
7399
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]7400sub git_snapshot {
Giuseppe Bilotta1b2d2972008-10-10 20:42:26 +0200[diff] [blame]7401 my $format = $input_params{'snapshot_format'};
Giuseppe Bilotta5e166842008-11-02 10:21:37 +0100[diff] [blame]7402 if (!@snapshot_fmts) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7403 die_error(403, "Snapshots not allowed");
Jakub Narebski3473e7d2007-07-25 01:19:58 +0200[diff] [blame]7404 }
7405 # default to first supported snapshot format
Giuseppe Bilotta5e166842008-11-02 10:21:37 +0100[diff] [blame]7406 $format ||= $snapshot_fmts[0];
Jakub Narebski3473e7d2007-07-25 01:19:58 +0200[diff] [blame]7407 if ($format !~ m/^[a-z0-9]+$/) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7408 die_error(400, "Invalid snapshot format parameter");
Jakub Narebski3473e7d2007-07-25 01:19:58 +0200[diff] [blame]7409 } elsif (!exists($known_snapshot_formats{$format})) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7410 die_error(400, "Unknown snapshot format");
Mark A Rada1bfd3632009-08-06 10:25:39 -0400[diff] [blame]7411 } elsif ($known_snapshot_formats{$format}{'disabled'}) {
7412 die_error(403, "Snapshot format not allowed");
Mark Rada34b31a82009-08-25 00:59:48 -0400[diff] [blame]7413 } elsif (!grep($_ eq $format, @snapshot_fmts)) {
7414 die_error(403, "Unsupported snapshot format");
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]7415 }
7416
Mark Radafdb0c362009-09-26 13:46:08 -0400[diff] [blame]7417 my $type = git_get_type("$hash^{}");
7418 if (!$type) {
7419 die_error(404, 'Object does not exist');
7420 } elsif ($type eq 'blob') {
7421 die_error(400, 'Object is not a tree-ish');
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]7422 }
7423
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7424 my ($name, $prefix) = snapshot_name($project, $hash);
7425 my $filename = "$name$known_snapshot_formats{$format}{'suffix'}";
W. Trevor King8745db62012-03-29 08:45:49 -0400[diff] [blame]7426
7427 my %co = parse_commit($hash);
7428 exit_if_unmodified_since($co{'committer_epoch'}) if %co;
7429
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7430 my $cmd = quote_command(
Lea Wiemann516381d2008-06-17 23:46:35 +0200[diff] [blame]7431 git_cmd(), 'archive',
7432 "--format=$known_snapshot_formats{$format}{'format'}",
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7433 "--prefix=$prefix/", $hash);
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]7434 if (exists $known_snapshot_formats{$format}{'compressor'}) {
Lea Wiemann516381d2008-06-17 23:46:35 +0200[diff] [blame]7435 $cmd .= ' | ' . quote_command(@{$known_snapshot_formats{$format}{'compressor'}});
Mark Levedahl072570e2007-05-20 11:46:46 -0400[diff] [blame]7436 }
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]7437
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7438 $filename =~ s/(["\\])/\\$1/g;
W. Trevor King8745db62012-03-29 08:45:49 -0400[diff] [blame]7439 my %latest_date;
7440 if (%co) {
7441 %latest_date = parse_date($co{'committer_epoch'}, $co{'committer_tz'});
7442 }
7443
Jakub Narebskiab41dfb2006-09-26 01:59:43 +0200[diff] [blame]7444 print $cgi->header(
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]7445 -type => $known_snapshot_formats{$format}{'type'},
Mark Radab6292752009-11-07 16:13:29 +0100[diff] [blame]7446 -content_disposition => 'inline; filename="' . $filename . '"',
W. Trevor King8745db62012-03-29 08:45:49 -0400[diff] [blame]7447 %co ? (-last_modified => $latest_date{'rfc2822'}) : (),
Jakub Narebskiab41dfb2006-09-26 01:59:43 +0200[diff] [blame]7448 -status => '200 OK');
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]7449
Mark Levedahl072570e2007-05-20 11:46:46 -0400[diff] [blame]7450 open my $fd, "-|", $cmd
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7451 or die_error(500, "Execute git-archive failed");
Julien Moutinho2ecfcde2020-03-29 01:20:28 +0100[diff] [blame]7452 local *FCGI::Stream::PRINT = $FCGI_Stream_PRINT_raw;
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]7453 binmode STDOUT, ':raw';
7454 print <$fd>;
7455 binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
7456 close $fd;
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]7457}
7458
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7459sub git_log_generic {
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7460 my ($fmt_name, $body_subr, $base, $parent, $file_name, $file_hash) = @_;
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7461
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7462 my $head = git_get_head_hash($project);
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7463 if (!defined $base) {
7464 $base = $head;
Kay Sievers0db37972005-08-07 20:24:35 +0200[diff] [blame]7465 }
Kay Sieversea4a6df2005-08-07 20:26:49 +0200[diff] [blame]7466 if (!defined $page) {
7467 $page = 0;
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]7468 }
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7469 my $refs = git_get_references();
Kay Sieversea4a6df2005-08-07 20:26:49 +0200[diff] [blame]7470
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7471 my $commit_hash = $base;
7472 if (defined $parent) {
7473 $commit_hash = "$parent..$base";
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7474 }
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7475 my @commitlist =
7476 parse_commits($commit_hash, 101, (100 * $page),
7477 defined $file_name ? ($file_name, "--full-history") : ());
Kay Sieversea4a6df2005-08-07 20:26:49 +0200[diff] [blame]7478
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7479 my $ftype;
7480 if (!defined $file_hash && defined $file_name) {
7481 # some commits could have deleted file in question,
7482 # and not have it in tree, but one of them has to have it
7483 for (my $i = 0; $i < @commitlist; $i++) {
7484 $file_hash = git_get_hash_by_path($commitlist[$i]{'id'}, $file_name);
7485 last if defined $file_hash;
7486 }
7487 }
7488 if (defined $file_hash) {
7489 $ftype = git_get_type($file_hash);
7490 }
7491 if (defined $file_name && !defined $ftype) {
7492 die_error(500, "Unknown type of object");
7493 }
7494 my %co;
7495 if (defined $file_name) {
7496 %co = parse_commit($base)
7497 or die_error(404, "Unknown commit object");
7498 }
7499
7500
7501 my $paging_nav = format_paging_nav($fmt_name, $page, $#commitlist >= 100);
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7502 my $next_link = '';
Jakub Narebski42671ca2009-11-13 02:02:12 +0100[diff] [blame]7503 if ($#commitlist >= 100) {
7504 $next_link =
7505 $cgi->a({-href => href(-replay=>1, page=>$page+1),
7506 -accesskey => "n", -title => "Alt-n"}, "next");
7507 }
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7508 my $patch_max = gitweb_get_feature('patches');
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]7509 if ($patch_max && !defined $file_name &&
7510 !gitweb_check_feature('email-privacy')) {
Giuseppe Bilotta75bf2cb2008-12-18 08:13:19 +0100[diff] [blame]7511 if ($patch_max < 0 || @commitlist <= $patch_max) {
7512 $paging_nav .= " &sdot; " .
7513 $cgi->a({-href => href(action=>"patches", -replay=>1)},
7514 "patches");
7515 }
7516 }
7517
Jakub Narebski0d83ddc2006-07-30 15:01:07 +0200[diff] [blame]7518 git_header_html();
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7519 git_print_page_nav($fmt_name,'', $hash,$hash,$hash, $paging_nav);
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7520 if (defined $file_name) {
7521 git_print_header_div('commit', esc_html($co{'title'}), $base);
7522 } else {
7523 git_print_header_div('summary', $project)
7524 }
7525 git_print_page_path($file_name, $ftype, $hash_base)
7526 if (defined $file_name);
Jakub Narebski0d83ddc2006-07-30 15:01:07 +0200[diff] [blame]7527
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7528 $body_subr->(\@commitlist, 0, 99, $refs, $next_link,
7529 $file_name, $file_hash, $ftype);
Jakub Narebski42671ca2009-11-13 02:02:12 +0100[diff] [blame]7530
Kay Sievers034df392005-08-07 20:20:07 +0200[diff] [blame]7531 git_footer_html();
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7532}
7533
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7534sub git_log {
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]7535 git_log_generic('log', \&git_log_body,
7536 $hash, $hash_parent);
Jakub Narebski15f0b112009-11-13 02:02:13 +0100[diff] [blame]7537}
7538
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7539sub git_commit {
Jakub Narebski9954f772006-11-18 23:35:41 +0100[diff] [blame]7540 $hash ||= $hash_base || "HEAD";
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7541 my %co = parse_commit($hash)
7542 or die_error(404, "Unknown commit object");
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]7543
Jakub Narebskic9d193d2006-12-15 21:57:16 +0100[diff] [blame]7544 my $parent = $co{'parent'};
7545 my $parents = $co{'parents'}; # listref
7546
7547 # we need to prepare $formats_nav before any parameter munging
7548 my $formats_nav;
7549 if (!defined $parent) {
7550 # --root commitdiff
7551 $formats_nav .= '(initial)';
7552 } elsif (@$parents == 1) {
7553 # single parent commit
7554 $formats_nav .=
7555 '(parent: ' .
7556 $cgi->a({-href => href(action=>"commit",
7557 hash=>$parent)},
7558 esc_html(substr($parent, 0, 7))) .
7559 ')';
7560 } else {
7561 # merge commit
7562 $formats_nav .=
7563 '(merge: ' .
7564 join(' ', map {
Jakub Narebskif9308a12007-03-23 21:04:31 +0100[diff] [blame]7565 $cgi->a({-href => href(action=>"commit",
Jakub Narebskic9d193d2006-12-15 21:57:16 +0100[diff] [blame]7566 hash=>$_)},
7567 esc_html(substr($_, 0, 7)));
7568 } @$parents ) .
7569 ')';
7570 }
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]7571 if (gitweb_check_feature('patches') && @$parents <= 1 &&
7572 !gitweb_check_feature('email-privacy')) {
Giuseppe Bilotta75bf2cb2008-12-18 08:13:19 +0100[diff] [blame]7573 $formats_nav .= " | " .
7574 $cgi->a({-href => href(action=>"patch", -replay=>1)},
7575 "patch");
7576 }
Jakub Narebskic9d193d2006-12-15 21:57:16 +0100[diff] [blame]7577
Kay Sieversd8a20ba2005-08-07 20:28:53 +0200[diff] [blame]7578 if (!defined $parent) {
Jakub Narebskib9182982006-07-30 18:28:34 -0700[diff] [blame]7579 $parent = "--root";
Kay Sievers6191f8e2005-08-07 20:19:56 +0200[diff] [blame]7580 }
Jakub Narebski549ab4a2006-12-15 17:53:45 +0100[diff] [blame]7581 my @difftree;
Jakub Narebski208ecb22007-05-07 01:10:08 +0200[diff] [blame]7582 open my $fd, "-|", git_cmd(), "diff-tree", '-r', "--no-commit-id",
7583 @diff_opts,
7584 (@$parents <= 1 ? $parent : '-c'),
7585 $hash, "--"
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7586 or die_error(500, "Open git-diff-tree failed");
Jakub Narebski208ecb22007-05-07 01:10:08 +0200[diff] [blame]7587 @difftree = map { chomp; $_ } <$fd>;
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7588 close $fd or die_error(404, "Reading git-diff-tree failed");
Kay Sievers11044292005-10-19 03:18:45 +0200[diff] [blame]7589
7590 # non-textual hash id's can be cached
7591 my $expires;
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7592 if ($hash =~ m/^$oid_regex$/) {
Kay Sievers11044292005-10-19 03:18:45 +0200[diff] [blame]7593 $expires = "+1d";
7594 }
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7595 my $refs = git_get_references();
7596 my $ref = format_ref_marker($refs, $co{'id'});
Aneesh Kumar K.Vddb8d902006-08-20 11:53:04 +0530[diff] [blame]7597
Jakub Narebski594e2122006-07-31 02:21:52 +0200[diff] [blame]7598 git_header_html(undef, $expires);
Petr Baudisa1441542006-10-06 18:59:33 +0200[diff] [blame]7599 git_print_page_nav('commit', '',
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7600 $hash, $co{'tree'}, $hash,
Jakub Narebskic9d193d2006-12-15 21:57:16 +0100[diff] [blame]7601 $formats_nav);
Luben Tuikov4f7b34c2006-07-23 13:36:32 -0700[diff] [blame]7602
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]7603 if (defined $co{'parent'}) {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7604 git_print_header_div('commitdiff', esc_html($co{'title'}) . $ref, $hash);
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]7605 } else {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]7606 git_print_header_div('tree', esc_html($co{'title'}) . $ref, $co{'tree'}, $hash);
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]7607 }
Kay Sievers6191f8e2005-08-07 20:19:56 +0200[diff] [blame]7608 print "<div class=\"title_text\">\n" .
Jakub Narebski591ebf62007-11-19 14:16:11 +0100[diff] [blame]7609 "<table class=\"object_header\">\n";
Giuseppe Bilotta1c49a4e2009-06-30 00:00:48 +0200[diff] [blame]7610 git_print_authorship_rows(\%co);
Jakub Narebski1f1ab5f2006-06-20 14:58:12 +0000[diff] [blame]7611 print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7612 print "<tr>" .
7613 "<td>tree</td>" .
Jakub Narebski1f1ab5f2006-06-20 14:58:12 +0000[diff] [blame]7614 "<td class=\"sha1\">" .
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7615 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash),
7616 class => "list"}, $co{'tree'}) .
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]7617 "</td>" .
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7618 "<td class=\"link\">" .
7619 $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash)},
7620 "tree");
Matt McCutchena3c8ab32007-07-22 01:30:27 +0200[diff] [blame]7621 my $snapshot_links = format_snapshot_links($hash);
7622 if (defined $snapshot_links) {
7623 print " | " . $snapshot_links;
Aneesh Kumar K.Vcb9c6e52006-08-17 20:59:46 +0530[diff] [blame]7624 }
7625 print "</td>" .
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7626 "</tr>\n";
Jakub Narebski549ab4a2006-12-15 17:53:45 +0100[diff] [blame]7627
Kay Sievers3e029292005-08-07 20:05:15 +0200[diff] [blame]7628 foreach my $par (@$parents) {
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7629 print "<tr>" .
7630 "<td>parent</td>" .
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7631 "<td class=\"sha1\">" .
7632 $cgi->a({-href => href(action=>"commit", hash=>$par),
7633 class => "list"}, $par) .
7634 "</td>" .
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7635 "<td class=\"link\">" .
Martin Waitz1c2a4f52006-08-16 00:24:30 +0200[diff] [blame]7636 $cgi->a({-href => href(action=>"commit", hash=>$par)}, "commit") .
Jakub Narebski952c65f2006-08-22 16:52:50 +0200[diff] [blame]7637 " | " .
Jakub Narebskif2e60942006-09-03 23:43:03 +0200[diff] [blame]7638 $cgi->a({-href => href(action=>"commitdiff", hash=>$hash, hash_parent=>$par)}, "diff") .
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7639 "</td>" .
7640 "</tr>\n";
Kay Sievers3e029292005-08-07 20:05:15 +0200[diff] [blame]7641 }
Jakub Narebski7a9b4c52006-06-21 09:48:02 +0200[diff] [blame]7642 print "</table>".
Kay Sieversb87d78d2005-08-07 20:21:04 +0200[diff] [blame]7643 "</div>\n";
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]7644
Kay Sieversfbb592a2005-08-07 20:12:11 +0200[diff] [blame]7645 print "<div class=\"page_body\">\n";
Jakub Narebskid16d0932006-08-17 11:21:23 +0200[diff] [blame]7646 git_print_log($co{'comment'});
Kay Sievers927dcec2005-08-07 20:18:44 +0200[diff] [blame]7647 print "</div>\n";
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]7648
Jakub Narebski208ecb22007-05-07 01:10:08 +0200[diff] [blame]7649 git_difftree_body(\@difftree, $hash, @$parents);
Jakub Narebski4a4a1a52006-08-14 02:18:33 +0200[diff] [blame]7650
Kay Sievers12a88f22005-08-07 20:02:47 +0200[diff] [blame]7651 git_footer_html();
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7652}
7653
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7654sub git_object {
7655 # object is defined by:
7656 # - hash or hash_base alone
7657 # - hash_base and file_name
7658 my $type;
7659
7660 # - hash or hash_base alone
7661 if ($hash || ($hash_base && !defined $file_name)) {
7662 my $object_id = $hash || $hash_base;
7663
Lea Wiemann516381d2008-06-17 23:46:35 +0200[diff] [blame]7664 open my $fd, "-|", quote_command(
7665 git_cmd(), 'cat-file', '-t', $object_id) . ' 2> /dev/null'
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7666 or die_error(404, "Object does not exist");
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7667 $type = <$fd>;
Øyvind A. Holma9eb90a2016-01-12 04:31:56 +0100[diff] [blame]7668 defined $type && chomp $type;
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7669 close $fd
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7670 or die_error(404, "Object does not exist");
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7671
7672 # - hash_base and file_name
7673 } elsif ($hash_base && defined $file_name) {
7674 $file_name =~ s,/+$,,;
7675
7676 system(git_cmd(), "cat-file", '-e', $hash_base) == 0
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7677 or die_error(404, "Base object does not exist");
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7678
Stefano Lattarini41ccfdd2013-04-12 00:36:10 +0200[diff] [blame]7679 # here errors should not happen
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7680 open my $fd, "-|", git_cmd(), "ls-tree", $hash_base, "--", $file_name
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7681 or die_error(500, "Open git-ls-tree failed");
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7682 my $line = <$fd>;
7683 close $fd;
7684
7685 #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7686 unless ($line && $line =~ m/^([0-9]+) (.+) ($oid_regex)\t/) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7687 die_error(404, "File or directory for given base does not exist");
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7688 }
7689 $type = $2;
7690 $hash = $3;
7691 } else {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7692 die_error(400, "Not enough information to find object");
Jakub Narebskica946012006-12-10 13:25:47 +0100[diff] [blame]7693 }
7694
7695 print $cgi->redirect(-uri => href(action=>$type, -full=>1,
7696 hash=>$hash, hash_base=>$hash_base,
7697 file_name=>$file_name),
7698 -status => '302 Found');
7699}
7700
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7701sub git_blobdiff {
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7702 my $format = shift || 'html';
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]7703 my $diff_style = $input_params{'diff_style'} || 'inline';
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7704
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7705 my $fd;
7706 my @difftree;
7707 my %diffinfo;
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7708 my $expires;
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7709
7710 # preparing $fd and %diffinfo for git_patchset_body
7711 # new style URI
7712 if (defined $hash_base && defined $hash_parent_base) {
7713 if (defined $file_name) {
7714 # read raw output
Jakub Narebski45bd0c82006-10-30 22:29:06 +0100[diff] [blame]7715 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
7716 $hash_parent_base, $hash_base,
Jakub Narebski5ae917a2007-03-30 23:41:26 +0200[diff] [blame]7717 "--", (defined $file_parent ? $file_parent : ()), $file_name
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7718 or die_error(500, "Open git-diff-tree failed");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7719 @difftree = map { chomp; $_ } <$fd>;
7720 close $fd
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7721 or die_error(404, "Reading git-diff-tree failed");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7722 @difftree
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7723 or die_error(404, "Blob diff not found");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7724
Jakub Narebski0aea3372006-08-27 23:45:26 +0200[diff] [blame]7725 } elsif (defined $hash &&
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7726 $hash =~ $oid_regex) {
Jakub Narebski0aea3372006-08-27 23:45:26 +0200[diff] [blame]7727 # try to find filename from $hash
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7728
7729 # read filtered raw output
Jakub Narebski45bd0c82006-10-30 22:29:06 +0100[diff] [blame]7730 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
7731 $hash_parent_base, $hash_base, "--"
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7732 or die_error(500, "Open git-diff-tree failed");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7733 @difftree =
7734 # ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
7735 # $hash == to_id
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7736 grep { /^:[0-7]{6} [0-7]{6} $oid_regex $hash/ }
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7737 map { chomp; $_ } <$fd>;
7738 close $fd
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7739 or die_error(404, "Reading git-diff-tree failed");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7740 @difftree
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7741 or die_error(404, "Blob diff not found");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7742
7743 } else {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7744 die_error(400, "Missing one of the blob diff parameters");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7745 }
7746
7747 if (@difftree > 1) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7748 die_error(400, "Ambiguous blob diff specification");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7749 }
7750
7751 %diffinfo = parse_difftree_raw_line($difftree[0]);
Jakub Narebski9d301452007-11-01 12:38:08 +0100[diff] [blame]7752 $file_parent ||= $diffinfo{'from_file'} || $file_name;
7753 $file_name ||= $diffinfo{'to_file'};
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7754
7755 $hash_parent ||= $diffinfo{'from_id'};
7756 $hash ||= $diffinfo{'to_id'};
7757
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7758 # non-textual hash id's can be cached
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7759 if ($hash_base =~ m/^$oid_regex$/ &&
7760 $hash_parent_base =~ m/^$oid_regex$/) {
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7761 $expires = '+1d';
7762 }
7763
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7764 # open patch output
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]7765 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
Jakub Narebski957d6ea2007-04-05 13:45:41 +0200[diff] [blame]7766 '-p', ($format eq 'html' ? "--full-index" : ()),
7767 $hash_parent_base, $hash_base,
Jakub Narebski5ae917a2007-03-30 23:41:26 +0200[diff] [blame]7768 "--", (defined $file_parent ? $file_parent : ()), $file_name
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7769 or die_error(500, "Open git-diff-tree failed");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7770 }
7771
Junio C Hamanob54dc9f2008-12-16 19:42:02 -0800[diff] [blame]7772 # old/legacy style URI -- not generated anymore since 1.4.3.
7773 if (!%diffinfo) {
7774 die_error('404 Not Found', "Missing one of the blob diff parameters")
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7775 }
7776
7777 # header
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7778 if ($format eq 'html') {
7779 my $formats_nav =
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]7780 $cgi->a({-href => href(action=>"blobdiff_plain", -replay=>1)},
Petr Baudis35329cc2006-09-22 03:19:50 +0200[diff] [blame]7781 "raw");
Kato Kazuyoshi6ae683c2011-10-31 00:36:27 +0100[diff] [blame]7782 $formats_nav .= diff_style_nav($diff_style);
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7783 git_header_html(undef, $expires);
7784 if (defined $hash_base && (my %co = parse_commit($hash_base))) {
7785 git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
7786 git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
7787 } else {
7788 print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
Jakub Narebski3017ed62010-12-15 00:34:01 +0100[diff] [blame]7789 print "<div class=\"title\">".esc_html("$hash vs $hash_parent")."</div>\n";
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7790 }
7791 if (defined $file_name) {
7792 git_print_page_path($file_name, "blob", $hash_base);
7793 } else {
7794 print "<div class=\"page_path\"></div>\n";
7795 }
7796
7797 } elsif ($format eq 'plain') {
7798 print $cgi->header(
7799 -type => 'text/plain',
7800 -charset => 'utf-8',
7801 -expires => $expires,
Luben Tuikova2a3bf72006-09-28 16:51:43 -0700[diff] [blame]7802 -content_disposition => 'inline; filename="' . "$file_name" . '.patch"');
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7803
7804 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
7805
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7806 } else {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7807 die_error(400, "Unknown blobdiff format");
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7808 }
7809
7810 # patch
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7811 if ($format eq 'html') {
7812 print "<div class=\"page_body\">\n";
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7813
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]7814 git_patchset_body($fd, $diff_style,
7815 [ \%diffinfo ], $hash_base, $hash_parent_base);
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7816 close $fd;
Jakub Narebski7c5e2eb2006-08-25 21:13:34 +0200[diff] [blame]7817
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7818 print "</div>\n"; # class="page_body"
7819 git_footer_html();
7820
7821 } else {
7822 while (my $line = <$fd>) {
Jakub Narebski403d0902006-11-08 11:48:56 +0100[diff] [blame]7823 $line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
7824 $line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7825
7826 print $line;
7827
7828 last if $line =~ m!^\+\+\+!;
7829 }
7830 local $/ = undef;
7831 print <$fd>;
7832 close $fd;
7833 }
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7834}
7835
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]7836sub git_blobdiff_plain {
Jakub Narebski9b71b1f2006-08-25 21:14:49 +0200[diff] [blame]7837 git_blobdiff('plain');
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]7838}
7839
Kato Kazuyoshi6ae683c2011-10-31 00:36:27 +0100[diff] [blame]7840# assumes that it is added as later part of already existing navigation,
7841# so it returns "| foo | bar" rather than just "foo | bar"
7842sub diff_style_nav {
7843 my ($diff_style, $is_combined) = @_;
7844 $diff_style ||= 'inline';
7845
7846 return "" if ($is_combined);
7847
7848 my @styles = (inline => 'inline', 'sidebyside' => 'side by side');
7849 my %styles = @styles;
7850 @styles =
7851 @styles[ map { $_ * 2 } 0..$#styles/2 ];
7852
7853 return join '',
7854 map { " | ".$_ }
7855 map {
7856 $_ eq $diff_style ? $styles{$_} :
7857 $cgi->a({-href => href(-replay=>1, diff_style => $_)}, $styles{$_})
7858 } @styles;
7859}
7860
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]7861sub git_commitdiff {
Giuseppe Bilotta20209852008-12-18 08:13:17 +0100[diff] [blame]7862 my %params = @_;
7863 my $format = $params{-format} || 'html';
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]7864 my $diff_style = $input_params{'diff_style'} || 'inline';
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]7865
Giuseppe Bilotta75bf2cb2008-12-18 08:13:19 +0100[diff] [blame]7866 my ($patch_max) = gitweb_get_feature('patches');
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]7867 if ($format eq 'patch') {
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]7868 die_error(403, "Patch view not allowed") unless $patch_max;
7869 }
7870
Jakub Narebski9954f772006-11-18 23:35:41 +0100[diff] [blame]7871 $hash ||= $hash_base || "HEAD";
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7872 my %co = parse_commit($hash)
7873 or die_error(404, "Unknown commit object");
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7874
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]7875 # choose format for commitdiff for merge
7876 if (! defined $hash_parent && @{$co{'parents'}} > 1) {
7877 $hash_parent = '--cc';
7878 }
7879 # we need to prepare $formats_nav before almost any parameter munging
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7880 my $formats_nav;
7881 if ($format eq 'html') {
7882 $formats_nav =
Jakub Narebskia3823e52007-11-01 13:06:29 +0100[diff] [blame]7883 $cgi->a({-href => href(action=>"commitdiff_plain", -replay=>1)},
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7884 "raw");
Georgios Kontaxis0996dd32021-03-28 23:26:03 +0000[diff] [blame]7885 if ($patch_max && @{$co{'parents'}} <= 1 &&
7886 !gitweb_check_feature('email-privacy')) {
Giuseppe Bilotta75bf2cb2008-12-18 08:13:19 +0100[diff] [blame]7887 $formats_nav .= " | " .
7888 $cgi->a({-href => href(action=>"patch", -replay=>1)},
7889 "patch");
7890 }
Kato Kazuyoshi6ae683c2011-10-31 00:36:27 +0100[diff] [blame]7891 $formats_nav .= diff_style_nav($diff_style, @{$co{'parents'}} > 1);
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7892
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]7893 if (defined $hash_parent &&
7894 $hash_parent ne '-c' && $hash_parent ne '--cc') {
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7895 # commitdiff with two commits given
7896 my $hash_parent_short = $hash_parent;
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]7897 if ($hash_parent =~ m/^$oid_regex$/) {
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7898 $hash_parent_short = substr($hash_parent, 0, 7);
7899 }
7900 $formats_nav .=
Jakub Narebskiada3e1f2007-06-08 13:26:31 +0200[diff] [blame]7901 ' (from';
7902 for (my $i = 0; $i < @{$co{'parents'}}; $i++) {
7903 if ($co{'parents'}[$i] eq $hash_parent) {
7904 $formats_nav .= ' parent ' . ($i+1);
7905 last;
7906 }
7907 }
7908 $formats_nav .= ': ' .
Jakub Narebskid0e6e292011-10-31 00:36:26 +0100[diff] [blame]7909 $cgi->a({-href => href(-replay=>1,
7910 hash=>$hash_parent, hash_base=>undef)},
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7911 esc_html($hash_parent_short)) .
7912 ')';
7913 } elsif (!$co{'parent'}) {
7914 # --root commitdiff
7915 $formats_nav .= ' (initial)';
7916 } elsif (scalar @{$co{'parents'}} == 1) {
7917 # single parent commit
7918 $formats_nav .=
7919 ' (parent: ' .
Jakub Narebskid0e6e292011-10-31 00:36:26 +0100[diff] [blame]7920 $cgi->a({-href => href(-replay=>1,
7921 hash=>$co{'parent'}, hash_base=>undef)},
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7922 esc_html(substr($co{'parent'}, 0, 7))) .
7923 ')';
7924 } else {
7925 # merge commit
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]7926 if ($hash_parent eq '--cc') {
7927 $formats_nav .= ' | ' .
Jakub Narebskid0e6e292011-10-31 00:36:26 +0100[diff] [blame]7928 $cgi->a({-href => href(-replay=>1,
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]7929 hash=>$hash, hash_parent=>'-c')},
7930 'combined');
7931 } else { # $hash_parent eq '-c'
7932 $formats_nav .= ' | ' .
Jakub Narebskid0e6e292011-10-31 00:36:26 +0100[diff] [blame]7933 $cgi->a({-href => href(-replay=>1,
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]7934 hash=>$hash, hash_parent=>'--cc')},
7935 'compact');
7936 }
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7937 $formats_nav .=
7938 ' (merge: ' .
7939 join(' ', map {
Jakub Narebskid0e6e292011-10-31 00:36:26 +0100[diff] [blame]7940 $cgi->a({-href => href(-replay=>1,
7941 hash=>$_, hash_base=>undef)},
Jakub Narebski151602d2006-10-23 00:37:56 +0200[diff] [blame]7942 esc_html(substr($_, 0, 7)));
7943 } @{$co{'parents'}} ) .
7944 ')';
7945 }
7946 }
7947
Jakub Narebskifb1dde42007-05-07 01:10:07 +0200[diff] [blame]7948 my $hash_parent_param = $hash_parent;
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]7949 if (!defined $hash_parent_param) {
7950 # --cc for multiple parents, --root for parentless
Jakub Narebskifb1dde42007-05-07 01:10:07 +0200[diff] [blame]7951 $hash_parent_param =
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]7952 @{$co{'parents'}} > 1 ? '--cc' : $co{'parent'} || '--root';
Kay Sieversbddec012005-08-07 20:25:42 +0200[diff] [blame]7953 }
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]7954
7955 # read commitdiff
7956 my $fd;
7957 my @difftree;
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]7958 if ($format eq 'html') {
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]7959 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
Jakub Narebski45bd0c82006-10-30 22:29:06 +0100[diff] [blame]7960 "--no-commit-id", "--patch-with-raw", "--full-index",
Jakub Narebskifb1dde42007-05-07 01:10:07 +0200[diff] [blame]7961 $hash_parent_param, $hash, "--"
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7962 or die_error(500, "Open git-diff-tree failed");
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]7963
Jakub Narebski04408c32006-11-18 23:35:38 +0100[diff] [blame]7964 while (my $line = <$fd>) {
7965 chomp $line;
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]7966 # empty line ends raw part of diff-tree output
7967 last unless $line;
Jakub Narebski493e01d2007-05-07 01:10:06 +0200[diff] [blame]7968 push @difftree, scalar parse_difftree_raw_line($line);
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]7969 }
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]7970
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]7971 } elsif ($format eq 'plain') {
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]7972 open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
Jakub Narebskifb1dde42007-05-07 01:10:07 +0200[diff] [blame]7973 '-p', $hash_parent_param, $hash, "--"
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]7974 or die_error(500, "Open git-diff-tree failed");
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]7975 } elsif ($format eq 'patch') {
7976 # For commit ranges, we limit the output to the number of
7977 # patches specified in the 'patches' feature.
7978 # For single commits, we limit the output to a single patch,
7979 # diverging from the git-format-patch default.
7980 my @commit_spec = ();
7981 if ($hash_parent) {
7982 if ($patch_max > 0) {
7983 push @commit_spec, "-$patch_max";
7984 }
7985 push @commit_spec, '-n', "$hash_parent..$hash";
7986 } else {
Giuseppe Bilottaa3411f82008-12-18 08:13:18 +0100[diff] [blame]7987 if ($params{-single}) {
7988 push @commit_spec, '-1';
7989 } else {
7990 if ($patch_max > 0) {
7991 push @commit_spec, "-$patch_max";
7992 }
7993 push @commit_spec, "-n";
7994 }
7995 push @commit_spec, '--root', $hash;
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]7996 }
Pavan Kumar Sunkara04794fd2010-05-10 18:41:35 +0200[diff] [blame]7997 open $fd, "-|", git_cmd(), "format-patch", @diff_opts,
7998 '--encoding=utf8', '--stdout', @commit_spec
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]7999 or die_error(500, "Open git-format-patch failed");
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8000 } else {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]8001 die_error(400, "Unknown commitdiff format");
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8002 }
Kay Sievers4c02e3c2005-08-07 19:52:52 +0200[diff] [blame]8003
Kay Sievers11044292005-10-19 03:18:45 +0200[diff] [blame]8004 # non-textual hash id's can be cached
8005 my $expires;
brian m. carlsoncfb04912019-02-19 00:05:26 +0000[diff] [blame]8006 if ($hash =~ m/^$oid_regex$/) {
Kay Sievers11044292005-10-19 03:18:45 +0200[diff] [blame]8007 $expires = "+1d";
8008 }
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]8009
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8010 # write commit message
8011 if ($format eq 'html') {
8012 my $refs = git_get_references();
8013 my $ref = format_ref_marker($refs, $co{'id'});
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8014
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8015 git_header_html(undef, $expires);
8016 git_print_page_nav('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
8017 git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash);
Giuseppe Bilottaf88bafa2009-06-30 00:00:49 +0200[diff] [blame]8018 print "<div class=\"title_text\">\n" .
8019 "<table class=\"object_header\">\n";
8020 git_print_authorship_rows(\%co);
8021 print "</table>".
8022 "</div>\n";
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8023 print "<div class=\"page_body\">\n";
Jakub Narebski82560982006-10-24 13:55:33 +0200[diff] [blame]8024 if (@{$co{'comment'}} > 1) {
8025 print "<div class=\"log\">\n";
8026 git_print_log($co{'comment'}, -final_empty_line=> 1, -remove_title => 1);
8027 print "</div>\n"; # class="log"
8028 }
Kay Sievers1b1cd422005-08-07 20:28:01 +0200[diff] [blame]8029
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8030 } elsif ($format eq 'plain') {
8031 my $refs = git_get_references("tags");
Jakub Narebskiedf735a2006-08-24 19:45:30 +0200[diff] [blame]8032 my $tagname = git_get_rev_name_tags($hash);
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8033 my $filename = basename($project) . "-$hash.patch";
8034
8035 print $cgi->header(
8036 -type => 'text/plain',
8037 -charset => 'utf-8',
8038 -expires => $expires,
Luben Tuikova2a3bf72006-09-28 16:51:43 -0700[diff] [blame]8039 -content_disposition => 'inline; filename="' . "$filename" . '"');
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8040 my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
Yasushi SHOJI77202242008-01-29 21:16:02 +0900[diff] [blame]8041 print "From: " . to_utf8($co{'author'}) . "\n";
8042 print "Date: $ad{'rfc2822'} ($ad{'tz_local'})\n";
8043 print "Subject: " . to_utf8($co{'title'}) . "\n";
8044
Jakub Narebskiedf735a2006-08-24 19:45:30 +0200[diff] [blame]8045 print "X-Git-Tag: $tagname\n" if $tagname;
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8046 print "X-Git-Url: " . $cgi->self_url() . "\n\n";
Jakub Narebskiedf735a2006-08-24 19:45:30 +0200[diff] [blame]8047
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8048 foreach my $line (@{$co{'comment'}}) {
Yasushi SHOJI77202242008-01-29 21:16:02 +0900[diff] [blame]8049 print to_utf8($line) . "\n";
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8050 }
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8051 print "---\n\n";
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]8052 } elsif ($format eq 'patch') {
8053 my $filename = basename($project) . "-$hash.patch";
8054
8055 print $cgi->header(
8056 -type => 'text/plain',
8057 -charset => 'utf-8',
8058 -expires => $expires,
8059 -content_disposition => 'inline; filename="' . "$filename" . '"');
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8060 }
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8061
8062 # write patch
8063 if ($format eq 'html') {
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]8064 my $use_parents = !defined $hash_parent ||
8065 $hash_parent eq '-c' || $hash_parent eq '--cc';
8066 git_difftree_body(\@difftree, $hash,
8067 $use_parents ? @{$co{'parents'}} : $hash_parent);
Jakub Narebskib4657e72006-08-28 14:48:14 +0200[diff] [blame]8068 print "<br/>\n";
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8069
Kato Kazuyoshi6ba1eb52011-10-31 00:36:22 +0100[diff] [blame]8070 git_patchset_body($fd, $diff_style,
8071 \@difftree, $hash,
Jakub Narebskicd030c32007-06-08 13:33:28 +0200[diff] [blame]8072 $use_parents ? @{$co{'parents'}} : $hash_parent);
Jakub Narebski157e43b2006-08-24 19:34:36 +0200[diff] [blame]8073 close $fd;
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8074 print "</div>\n"; # class="page_body"
8075 git_footer_html();
8076
8077 } elsif ($format eq 'plain') {
8078 local $/ = undef;
8079 print <$fd>;
8080 close $fd
8081 or print "Reading git-diff-tree failed\n";
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]8082 } elsif ($format eq 'patch') {
8083 local $/ = undef;
8084 print <$fd>;
8085 close $fd
8086 or print "Reading git-format-patch failed\n";
Jakub Narebskieee08902006-08-24 00:15:14 +0200[diff] [blame]8087 }
8088}
8089
8090sub git_commitdiff_plain {
Giuseppe Bilotta20209852008-12-18 08:13:17 +0100[diff] [blame]8091 git_commitdiff(-format => 'plain');
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8092}
8093
Giuseppe Bilotta9872cd62008-12-18 08:13:16 +0100[diff] [blame]8094# format-patch-style patches
8095sub git_patch {
Jakub Narebski1655c982009-10-09 14:26:44 +0200[diff] [blame]8096 git_commitdiff(-format => 'patch', -single => 1);
Giuseppe Bilottaa3411f82008-12-18 08:13:18 +0100[diff] [blame]8097}
8098
8099sub git_patches {
Giuseppe Bilotta20209852008-12-18 08:13:17 +0100[diff] [blame]8100 git_commitdiff(-format => 'patch');
Kay Sievers09bd7892005-08-07 20:21:23 +0200[diff] [blame]8101}
8102
8103sub git_history {
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]8104 git_log_generic('history', \&git_history_body,
8105 $hash_base, $hash_parent_base,
8106 $file_name, $hash);
Kay Sievers161332a2005-08-07 19:49:46 +0200[diff] [blame]8107}
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8108
8109sub git_search {
Jakub Narebskie0ca3642011-06-22 17:28:52 +0200[diff] [blame]8110 $searchtype ||= 'commit';
8111
8112 # check if appropriate features are enabled
8113 gitweb_check_feature('search')
8114 or die_error(403, "Search is disabled");
8115 if ($searchtype eq 'pickaxe') {
8116 # pickaxe may take all resources of your box and run for several minutes
8117 # with every query - so decide by yourself how public you make this feature
8118 gitweb_check_feature('pickaxe')
8119 or die_error(403, "Pickaxe search is disabled");
8120 }
8121 if ($searchtype eq 'grep') {
8122 # grep search might be potentially CPU-intensive, too
8123 gitweb_check_feature('grep')
8124 or die_error(403, "Grep search is disabled");
8125 }
8126
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8127 if (!defined $searchtext) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]8128 die_error(400, "Text field is empty");
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8129 }
8130 if (!defined $hash) {
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]8131 $hash = git_get_head_hash($project);
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8132 }
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]8133 my %co = parse_commit($hash);
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8134 if (!%co) {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]8135 die_error(404, "Unknown commit object");
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8136 }
Robert Fitzsimons8dbc0fc2006-12-23 14:57:12 +0000[diff] [blame]8137 if (!defined $page) {
8138 $page = 0;
8139 }
Jakub Narebski04f7a942006-09-11 00:29:27 +0200[diff] [blame]8140
Jakub Narebski16f20722011-06-22 17:28:53 +0200[diff] [blame]8141 if ($searchtype eq 'commit' ||
8142 $searchtype eq 'author' ||
8143 $searchtype eq 'committer') {
8144 git_search_message(%co);
8145 } elsif ($searchtype eq 'pickaxe') {
8146 git_search_changes(%co);
8147 } elsif ($searchtype eq 'grep') {
8148 git_search_files(%co);
Jakub Narebski1ae05be2011-06-22 17:28:55 +0200[diff] [blame]8149 } else {
8150 die_error(400, "Unknown search type");
Kay Sieversc994d622005-08-07 20:27:18 +0200[diff] [blame]8151 }
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8152}
8153
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]8154sub git_search_help {
8155 git_header_html();
8156 git_print_page_nav('','', $hash,$hash,$hash);
8157 print <<EOT;
Petr Baudis0e559912008-02-26 13:22:08 +0100[diff] [blame]8158<p><strong>Pattern</strong> is by default a normal string that is matched precisely (but without
8159regard to case, except in the case of pickaxe). However, when you check the <em>re</em> checkbox,
8160the pattern entered is recognized as the POSIX extended
Sven Strickroth5e687292017-05-13 11:54:51 +0200[diff] [blame]8161<a href="https://en.wikipedia.org/wiki/Regular_expression">regular expression</a> (also case
Petr Baudis0e559912008-02-26 13:22:08 +0100[diff] [blame]8162insensitive).</p>
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]8163<dl>
8164<dt><b>commit</b></dt>
Petr Baudis0e559912008-02-26 13:22:08 +0100[diff] [blame]8165<dd>The commit messages and authorship information will be scanned for the given pattern.</dd>
Petr Baudise7738552007-05-17 04:31:12 +0200[diff] [blame]8166EOT
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]8167 my $have_grep = gitweb_check_feature('grep');
Petr Baudise7738552007-05-17 04:31:12 +0200[diff] [blame]8168 if ($have_grep) {
8169 print <<EOT;
8170<dt><b>grep</b></dt>
8171<dd>All files in the currently selected tree (HEAD unless you are explicitly browsing
Petr Baudis0e559912008-02-26 13:22:08 +0100[diff] [blame]8172 a different one) are searched for the given pattern. On large trees, this search can take
8173a while and put some strain on the server, so please use it with some consideration. Note that
8174due to git-grep peculiarity, currently if regexp mode is turned off, the matches are
8175case-sensitive.</dd>
Petr Baudise7738552007-05-17 04:31:12 +0200[diff] [blame]8176EOT
8177 }
8178 print <<EOT;
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]8179<dt><b>author</b></dt>
Petr Baudis0e559912008-02-26 13:22:08 +0100[diff] [blame]8180<dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given pattern.</dd>
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]8181<dt><b>committer</b></dt>
Petr Baudis0e559912008-02-26 13:22:08 +0100[diff] [blame]8182<dd>Name and e-mail of the committer and date of commit will be scanned for the given pattern.</dd>
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]8183EOT
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]8184 my $have_pickaxe = gitweb_check_feature('pickaxe');
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]8185 if ($have_pickaxe) {
8186 print <<EOT;
8187<dt><b>pickaxe</b></dt>
8188<dd>All commits that caused the string to appear or disappear from any file (changes that
8189added, removed or "modified" the string) will be listed. This search can take a while and
Petr Baudis0e559912008-02-26 13:22:08 +0100[diff] [blame]8190takes a lot of strain on the server, so please use it wisely. Note that since you may be
8191interested even in changes just changing the case as well, this search is case sensitive.</dd>
Petr Baudis88ad7292006-10-24 05:15:46 +0200[diff] [blame]8192EOT
8193 }
8194 print "</dl>\n";
8195 git_footer_html();
8196}
8197
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8198sub git_shortlog {
Jakub Narebski69ca37d2009-11-13 02:02:14 +0100[diff] [blame]8199 git_log_generic('shortlog', \&git_shortlog_body,
8200 $hash, $hash_parent);
Kay Sievers19806692005-08-07 20:26:27 +0200[diff] [blame]8201}
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8202
8203## ......................................................................
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8204## feeds (RSS, Atom; OPML)
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8205
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8206sub git_feed {
8207 my $format = shift || 'atom';
Giuseppe Bilotta25b27902008-11-29 13:07:29 -0800[diff] [blame]8208 my $have_blame = gitweb_check_feature('blame');
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8209
8210 # Atom: http://www.atomenabled.org/developers/syndication/
8211 # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
8212 if ($format ne 'rss' && $format ne 'atom') {
Lea Wiemann074afaa2008-06-19 22:03:21 +0200[diff] [blame]8213 die_error(400, "Unknown web feed format");
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8214 }
8215
8216 # log/feed of current (HEAD) branch, log of given branch, history of file/directory
8217 my $head = $hash || 'HEAD';
Jakub Narebski311e5522008-02-26 13:22:06 +0100[diff] [blame]8218 my @commitlist = parse_commits($head, 150, 0, $file_name);
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8219
8220 my %latest_commit;
8221 my %latest_date;
8222 my $content_type = "application/$format+xml";
8223 if (defined $cgi->http('HTTP_ACCEPT') &&
8224 $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
8225 # browser (feed reader) prefers text/xml
8226 $content_type = 'text/xml';
8227 }
Robert Fitzsimonsb6093a52006-12-24 14:31:47 +0000[diff] [blame]8228 if (defined($commitlist[0])) {
8229 %latest_commit = %{$commitlist[0]};
Giuseppe Bilottacd956c72009-01-26 12:50:16 +0100[diff] [blame]8230 my $latest_epoch = $latest_commit{'committer_epoch'};
W. Trevor Kingb7d565e2012-03-29 08:45:48 -0400[diff] [blame]8231 exit_if_unmodified_since($latest_epoch);
Dylan Alex Simondebf29d2012-10-11 16:40:35 -0400[diff] [blame]8232 %latest_date = parse_date($latest_epoch, $latest_commit{'committer_tz'});
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8233 }
W. Trevor Kingb7d565e2012-03-29 08:45:48 -0400[diff] [blame]8234 print $cgi->header(
8235 -type => $content_type,
8236 -charset => 'utf-8',
8237 %latest_date ? (-last_modified => $latest_date{'rfc2822'}) : (),
8238 -status => '200 OK');
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8239
8240 # Optimization: skip generating the body if client asks only
8241 # for Last-Modified date.
8242 return if ($cgi->request_method() eq 'HEAD');
8243
8244 # header variables
8245 my $title = "$site_name - $project/$action";
8246 my $feed_type = 'log';
8247 if (defined $hash) {
8248 $title .= " - '$hash'";
8249 $feed_type = 'branch log';
8250 if (defined $file_name) {
8251 $title .= " :: $file_name";
8252 $feed_type = 'history';
8253 }
8254 } elsif (defined $file_name) {
8255 $title .= " - $file_name";
8256 $feed_type = 'history';
8257 }
8258 $title .= " $feed_type";
Jeff King0f0ecf62012-11-12 16:34:28 -0500[diff] [blame]8259 $title = esc_html($title);
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8260 my $descr = git_get_project_description($project);
8261 if (defined $descr) {
8262 $descr = esc_html($descr);
8263 } else {
8264 $descr = "$project " .
8265 ($format eq 'rss' ? 'RSS' : 'Atom') .
8266 " feed";
8267 }
8268 my $owner = git_get_project_owner($project);
8269 $owner = esc_html($owner);
8270
8271 #header
8272 my $alt_url;
8273 if (defined $file_name) {
8274 $alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
8275 } elsif (defined $hash) {
8276 $alt_url = href(-full=>1, action=>"log", hash=>$hash);
8277 } else {
8278 $alt_url = href(-full=>1, action=>"summary");
8279 }
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]8280 $alt_url = esc_attr($alt_url);
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8281 print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
8282 if ($format eq 'rss') {
8283 print <<XML;
Jakub Narebski59b9f612006-08-22 23:42:53 +0200[diff] [blame]8284<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
8285<channel>
Jakub Narebski59b9f612006-08-22 23:42:53 +0200[diff] [blame]8286XML
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8287 print "<title>$title</title>\n" .
8288 "<link>$alt_url</link>\n" .
8289 "<description>$descr</description>\n" .
Giuseppe Bilotta3ac109a2009-01-26 12:50:13 +0100[diff] [blame]8290 "<language>en</language>\n" .
8291 # project owner is responsible for 'editorial' content
8292 "<managingEditor>$owner</managingEditor>\n";
Giuseppe Bilotta1ba68ce2009-01-26 12:50:11 +0100[diff] [blame]8293 if (defined $logo || defined $favicon) {
8294 # prefer the logo to the favicon, since RSS
8295 # doesn't allow both
8296 my $img = esc_url($logo || $favicon);
8297 print "<image>\n" .
8298 "<url>$img</url>\n" .
8299 "<title>$title</title>\n" .
8300 "<link>$alt_url</link>\n" .
8301 "</image>\n";
8302 }
Giuseppe Bilotta0cf31282009-01-26 12:50:14 +0100[diff] [blame]8303 if (%latest_date) {
8304 print "<pubDate>$latest_date{'rfc2822'}</pubDate>\n";
8305 print "<lastBuildDate>$latest_date{'rfc2822'}</lastBuildDate>\n";
8306 }
Giuseppe Bilottaad59a7a2009-01-26 12:50:12 +0100[diff] [blame]8307 print "<generator>gitweb v.$version/$git_version</generator>\n";
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8308 } elsif ($format eq 'atom') {
8309 print <<XML;
8310<feed xmlns="http://www.w3.org/2005/Atom">
8311XML
8312 print "<title>$title</title>\n" .
8313 "<subtitle>$descr</subtitle>\n" .
8314 '<link rel="alternate" type="text/html" href="' .
8315 $alt_url . '" />' . "\n" .
8316 '<link rel="self" type="' . $content_type . '" href="' .
8317 $cgi->self_url() . '" />' . "\n" .
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]8318 "<id>" . esc_url(href(-full=>1)) . "</id>\n" .
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8319 # use project owner for feed author
8320 "<author><name>$owner</name></author>\n";
8321 if (defined $favicon) {
8322 print "<icon>" . esc_url($favicon) . "</icon>\n";
8323 }
Jonathan Nieder9d9f5e72010-09-03 19:44:39 -0500[diff] [blame]8324 if (defined $logo) {
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8325 # not twice as wide as tall: 72 x 27 pixels
Jakub Narebskie1147262006-12-04 14:09:43 +0100[diff] [blame]8326 print "<logo>" . esc_url($logo) . "</logo>\n";
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8327 }
8328 if (! %latest_date) {
8329 # dummy date to keep the feed valid until commits trickle in:
8330 print "<updated>1970-01-01T00:00:00Z</updated>\n";
8331 } else {
8332 print "<updated>$latest_date{'iso-8601'}</updated>\n";
8333 }
Giuseppe Bilottaad59a7a2009-01-26 12:50:12 +0100[diff] [blame]8334 print "<generator version='$version/$git_version'>gitweb</generator>\n";
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8335 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8336
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8337 # contents
Robert Fitzsimonsb6093a52006-12-24 14:31:47 +0000[diff] [blame]8338 for (my $i = 0; $i <= $#commitlist; $i++) {
8339 my %co = %{$commitlist[$i]};
8340 my $commit = $co{'id'};
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8341 # we read 150, we always show 30 and the ones more recent than 48 hours
Jakub Narebski91fd2bf2006-11-25 15:54:34 +0100[diff] [blame]8342 if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8343 last;
8344 }
Jakub Narebski6368d9f2011-03-19 23:53:55 +0100[diff] [blame]8345 my %cd = parse_date($co{'author_epoch'}, $co{'author_tz'});
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8346
8347 # get list of changed files
Robert Fitzsimonsb6093a52006-12-24 14:31:47 +0000[diff] [blame]8348 open my $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
Jakub Narebskic906b182007-05-19 02:47:51 +0200[diff] [blame]8349 $co{'parent'} || "--root",
8350 $co{'id'}, "--", (defined $file_name ? $file_name : ())
Jakub Narebski6bcf4b42006-08-27 23:49:36 +0200[diff] [blame]8351 or next;
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8352 my @difftree = map { chomp; $_ } <$fd>;
Jakub Narebski6bcf4b42006-08-27 23:49:36 +0200[diff] [blame]8353 close $fd
8354 or next;
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8355
8356 # print element (entry, item)
Florian La Rochee62a6412008-02-03 12:38:46 +0100[diff] [blame]8357 my $co_url = href(-full=>1, action=>"commitdiff", hash=>$commit);
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8358 if ($format eq 'rss') {
8359 print "<item>\n" .
8360 "<title>" . esc_html($co{'title'}) . "</title>\n" .
8361 "<author>" . esc_html($co{'author'}) . "</author>\n" .
8362 "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
8363 "<guid isPermaLink=\"true\">$co_url</guid>\n" .
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]8364 "<link>" . esc_html($co_url) . "</link>\n" .
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8365 "<description>" . esc_html($co{'title'}) . "</description>\n" .
8366 "<content:encoded>" .
8367 "<![CDATA[\n";
8368 } elsif ($format eq 'atom') {
8369 print "<entry>\n" .
8370 "<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
8371 "<updated>$cd{'iso-8601'}</updated>\n" .
Jakub Narebskiab23c192006-11-25 15:54:33 +0100[diff] [blame]8372 "<author>\n" .
8373 " <name>" . esc_html($co{'author_name'}) . "</name>\n";
8374 if ($co{'author_email'}) {
8375 print " <email>" . esc_html($co{'author_email'}) . "</email>\n";
8376 }
8377 print "</author>\n" .
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8378 # use committer for contributor
Jakub Narebskiab23c192006-11-25 15:54:33 +0100[diff] [blame]8379 "<contributor>\n" .
8380 " <name>" . esc_html($co{'committer_name'}) . "</name>\n";
8381 if ($co{'committer_email'}) {
8382 print " <email>" . esc_html($co{'committer_email'}) . "</email>\n";
8383 }
8384 print "</contributor>\n" .
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8385 "<published>$cd{'iso-8601'}</published>\n" .
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]8386 "<link rel=\"alternate\" type=\"text/html\" href=\"" . esc_attr($co_url) . "\" />\n" .
8387 "<id>" . esc_html($co_url) . "</id>\n" .
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8388 "<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
8389 "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
8390 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8391 my $comment = $co{'comment'};
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8392 print "<pre>\n";
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8393 foreach my $line (@$comment) {
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8394 $line = esc_html($line);
8395 print "$line\n";
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8396 }
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8397 print "</pre><ul>\n";
8398 foreach my $difftree_line (@difftree) {
8399 my %difftree = parse_difftree_raw_line($difftree_line);
8400 next if !$difftree{'from_id'};
8401
8402 my $file = $difftree{'file'} || $difftree{'to_file'};
8403
8404 print "<li>" .
8405 "[" .
8406 $cgi->a({-href => href(-full=>1, action=>"blobdiff",
8407 hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
8408 hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
8409 file_name=>$file, file_parent=>$difftree{'from_file'}),
8410 -title => "diff"}, 'D');
8411 if ($have_blame) {
8412 print $cgi->a({-href => href(-full=>1, action=>"blame",
8413 file_name=>$file, hash_base=>$commit),
8414 -title => "blame"}, 'B');
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8415 }
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8416 # if this is not a feed of a file history
8417 if (!defined $file_name || $file_name ne $file) {
8418 print $cgi->a({-href => href(-full=>1, action=>"history",
8419 file_name=>$file, hash=>$commit),
8420 -title => "history"}, 'H');
8421 }
8422 $file = esc_path($file);
8423 print "] ".
8424 "$file</li>\n";
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8425 }
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8426 if ($format eq 'rss') {
8427 print "</ul>]]>\n" .
8428 "</content:encoded>\n" .
8429 "</item>\n";
8430 } elsif ($format eq 'atom') {
8431 print "</ul>\n</div>\n" .
8432 "</content>\n" .
8433 "</entry>\n";
8434 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8435 }
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8436
8437 # end of feed
8438 if ($format eq 'rss') {
8439 print "</channel>\n</rss>\n";
Jakub Narebski3278fbc2009-05-11 19:37:28 +0200[diff] [blame]8440 } elsif ($format eq 'atom') {
Jakub Narebskiaf6feeb2006-11-19 15:05:22 +0100[diff] [blame]8441 print "</feed>\n";
8442 }
8443}
8444
8445sub git_rss {
8446 git_feed('rss');
8447}
8448
8449sub git_atom {
8450 git_feed('atom');
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8451}
8452
8453sub git_opml {
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]8454 my @list = git_get_projects_list($project_filter, $strict_export);
Jakub Narebski12b14432011-04-29 19:51:56 +0200[diff] [blame]8455 if (!@list) {
8456 die_error(404, "No projects found");
8457 }
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8458
Giuseppe Bilottaae357852009-01-02 13:49:30 +0100[diff] [blame]8459 print $cgi->header(
8460 -type => 'text/xml',
8461 -charset => 'utf-8',
8462 -content_disposition => 'inline; filename="opml.xml"');
8463
Jürgen Kreileder5d791052011-12-17 10:22:22 +0100[diff] [blame]8464 my $title = esc_html($site_name);
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]8465 my $filter = " within subdirectory ";
8466 if (defined $project_filter) {
8467 $filter .= esc_html($project_filter);
8468 } else {
8469 $filter = "";
8470 }
Jakub Narebski59b9f612006-08-22 23:42:53 +0200[diff] [blame]8471 print <<XML;
8472<?xml version="1.0" encoding="utf-8"?>
8473<opml version="1.0">
8474<head>
Bernhard R. Link19d2d232012-01-30 21:07:37 +0100[diff] [blame]8475 <title>$title OPML Export$filter</title>
Jakub Narebski59b9f612006-08-22 23:42:53 +0200[diff] [blame]8476</head>
8477<body>
8478<outline text="git RSS feeds">
8479XML
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8480
8481 foreach my $pr (@list) {
8482 my %proj = %$pr;
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]8483 my $head = git_get_head_hash($proj{'path'});
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8484 if (!defined $head) {
8485 next;
8486 }
Dennis Stosberg25691fb2006-08-28 17:49:58 +0200[diff] [blame]8487 $git_dir = "$projectroot/$proj{'path'}";
Jakub Narebski847e01f2006-08-14 02:05:47 +0200[diff] [blame]8488 my %co = parse_commit($head);
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8489 if (!%co) {
8490 next;
8491 }
8492
8493 my $path = esc_html(chop_str($proj{'path'}, 25, 5));
Jeff Kinga376e372019-11-15 04:06:07 -0500[diff] [blame]8494 my $rss = esc_attr(href('project' => $proj{'path'}, 'action' => 'rss', -full => 1));
8495 my $html = esc_attr(href('project' => $proj{'path'}, 'action' => 'summary', -full => 1));
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8496 print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";
8497 }
Jakub Narebski59b9f612006-08-22 23:42:53 +0200[diff] [blame]8498 print <<XML;
8499</outline>
8500</body>
8501</opml>
8502XML
Jakub Narebski717b8312006-07-31 21:22:15 +0200[diff] [blame]8503}