use 5.008;

use strict;

use warnings;

use CGI qw(:standard :escapeHTML -nosticky);

use CGI::Util qw(unescape);

use CGI::Carp qw(fatalsToBrowser set_message);

use Encode;

use Fcntl ':mode';

use File::Find qw();

use File::Basename qw(basename);

use Time::HiRes qw(gettimeofday tv_interval);

binmode STDOUT, ':utf8';

our $t0 = [ gettimeofday() ];

our $number_of_git_cmds = 0;

BEGIN {

CGI->compile() if $ENV{'MOD_PERL'};

}

our $version = "++GIT_VERSION++";

our ($my_url, $my_uri, $base_url, $path_info, $home_link);

sub evaluate_uri {

our $cgi;

our $my_url = $cgi->url();

our $my_uri = $cgi->url(-absolute => 1);

# Base URL for relative URLs in gitweb ($logo, $favicon, ...),

# needed and used only for URLs with nonempty PATH_INFO

our $base_url = $my_url;

# When the script is used as DirectoryIndex, the URL does not contain the name

# of the script file itself, and $cgi->url() fails to strip PATH_INFO, so we

# have to do it ourselves. We make $path_info global because it's also used

# later on.

#

# Another issue with the script being the DirectoryIndex is that the resulting

# $my_url data is not the full script URL: this is good, because we want

# generated links to keep implying the script name if it wasn't explicitly

# indicated in the URL we're handling, but it means that $my_url cannot be used

# as base URL.

# Therefore, if we needed to strip PATH_INFO, then we know that we have

# to build the base URL ourselves:

our $path_info = decode_utf8($ENV{"PATH_INFO"});

if ($path_info) {

# $path_info has already been URL-decoded by the web server, but

# $my_url and $my_uri have not. URL-decode them so we can properly

# strip $path_info.

$my_url = unescape($my_url);

$my_uri = unescape($my_uri);

if ($my_url =~ s,\Q$path_info\E$,, &&

$my_uri =~ s,\Q$path_info\E$,, &&

defined $ENV{'SCRIPT_NAME'}) {

$base_url = $cgi->url(-base => 1) . $ENV{'SCRIPT_NAME'};

}

}

# target of the home link on top of all pages

our $home_link = $my_uri || "/";

}

our $GIT = "++GIT_BINDIR++/git";

our $projectroot = "++GITWEB_PROJECTROOT++";

our $project_maxdepth = "++GITWEB_PROJECT_MAXDEPTH++";

our $home_link_str = "++GITWEB_HOME_LINK_STR++";

our @extra_breadcrumbs = ();

our $site_name = "++GITWEB_SITENAME++"

|| ($ENV{'SERVER_NAME'} || "Untitled") . " Git";

our $site_html_head_string = "++GITWEB_SITE_HTML_HEAD_STRING++";

our $site_header = "++GITWEB_SITE_HEADER++";

our $home_text = "++GITWEB_HOMETEXT++";

our $site_footer = "++GITWEB_SITE_FOOTER++";

our @stylesheets = ("++GITWEB_CSS++");

our $stylesheet = undef;

our $logo = "++GITWEB_LOGO++";

our $favicon = "++GITWEB_FAVICON++";

our $javascript = "++GITWEB_JS++";

our $logo_url = "http://git-scm.com/";

our $logo_label = "git homepage";

our $projects_list = "++GITWEB_LIST++";

our $projects_list_description_width = 25;

our $projects_list_group_categories = 0;

our $project_list_default_category = "";

our $default_projects_order = "project";

our $export_ok = "++GITWEB_EXPORT_OK++";

our $omit_age_column = 0;

our $omit_owner=0;

our $export_auth_hook = undef;

our $strict_export = "++GITWEB_STRICT_EXPORT++";

our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");

our $default_blob_plain_mimetype = 'text/plain';

our $default_text_plain_charset = undef;

our $mimetypes_file = undef;

our $fallback_encoding = 'latin1';

our @diff_opts = ('-M'); # taken from git_commit

our $prevent_xss = 0;

our $highlight_bin = "++HIGHLIGHT_BIN++";

our %known_snapshot_formats = (

# name => {

# 'display' => display name,

# 'type' => mime type,

# 'suffix' => filename suffix,

# 'format' => --format for git-archive,

# 'compressor' => [compressor command and arguments]

# (array reference, optional)

# 'disabled' => boolean (optional)}

#

'tgz' => {

'display' => 'tar.gz',

'type' => 'application/x-gzip',

'suffix' => '.tar.gz',

'format' => 'tar',

'compressor' => ['gzip', '-n']},

'tbz2' => {

'display' => 'tar.bz2',

'type' => 'application/x-bzip2',

'suffix' => '.tar.bz2',

'format' => 'tar',

'compressor' => ['bzip2']},

'txz' => {

'display' => 'tar.xz',

'type' => 'application/x-xz',

'suffix' => '.tar.xz',

'format' => 'tar',

'compressor' => ['xz'],

'disabled' => 1},

'zip' => {

'display' => 'zip',

'type' => 'application/x-zip',

'suffix' => '.zip',

'format' => 'zip'},

);

our %known_snapshot_format_aliases = (

'gzip' => 'tgz',

'bzip2' => 'tbz2',

'xz' => 'txz',

# backward compatibility: legacy gitweb config support

'x-gzip' => undef, 'gz' => undef,

'x-bzip2' => undef, 'bz2' => undef,

'x-zip' => undef, '' => undef,

);

our %avatar_size = (

'default' => 16,

'double' => 32

);

our $maxload = 300;

our %highlight_basename = (

#'Program' => 'py',

#'Library' => 'py',

'SConstruct' => 'py', # SCons equivalent of Makefile

'Makefile' => 'make',

);

our %highlight_ext = (

# main extensions, defining name of syntax;

# see files in /usr/share/highlight/langDefs/ directory

(map { $_ => $_ } qw(py rb java css js tex bib xml awk bat ini spec tcl sql)),

# alternate extensions, see /etc/highlight/filetypes.conf

(map { $_ => 'c' } qw(c h)),

(map { $_ => 'sh' } qw(sh bash zsh ksh)),

(map { $_ => 'cpp' } qw(cpp cxx c++ cc)),

(map { $_ => 'php' } qw(php php3 php4 php5 phps)),

(map { $_ => 'pl' } qw(pl perl pm)), # perhaps also 'cgi'

(map { $_ => 'make'} qw(make mak mk)),

(map { $_ => 'xml' } qw(xml xhtml html htm)),

);

our %feature = (

# feature => {

# 'sub' => feature-sub (subroutine),

# 'override' => allow-override (boolean),

# 'default' => [ default options...] (array reference)}

#

# if feature is overridable (it means that allow-override has true value),

# then feature-sub will be called with default options as parameters;

# return value of feature-sub indicates if to enable specified feature

#

# if there is no 'sub' key (no feature-sub), then feature cannot be

# overridden

#

# use gitweb_get_feature(<feature>) to retrieve the <feature> value

# (an array) or gitweb_check_feature(<feature>) to check if <feature>

# is enabled

# Enable the 'blame' blob view, showing the last commit that modified

# each line in the file. This can be very CPU-intensive.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'blame'}{'default'} = [1];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'blame'}{'override'} = 1;

# and in project config gitweb.blame = 0|1;

'blame' => {

'sub' => sub { feature_bool('blame', @_) },

'override' => 0,

'default' => [0]},

# Enable the 'snapshot' link, providing a compressed archive of any

# tree. This can potentially generate high traffic if you have large

# project.

# Value is a list of formats defined in %known_snapshot_formats that

# you wish to offer.

# To disable system wide have in $GITWEB_CONFIG

# $feature{'snapshot'}{'default'} = [];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'snapshot'}{'override'} = 1;

# and in project config, a comma-separated list of formats or "none"

# to disable. Example: gitweb.snapshot = tbz2,zip;

'snapshot' => {

'sub' => \&feature_snapshot,

'override' => 0,

'default' => ['tgz']},

# Enable text search, which will list the commits which match author,

# committer or commit text to a given string. Enabled by default.

# Project specific override is not supported.

#

# Note that this controls all search features, which means that if

# it is disabled, then 'grep' and 'pickaxe' search would also be

# disabled.

'search' => {

'override' => 0,

'default' => [1]},

# Enable grep search, which will list the files in currently selected

# tree containing the given string. Enabled by default. This can be

# potentially CPU-intensive, of course.

# Note that you need to have 'search' feature enabled too.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'grep'}{'default'} = [1];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'grep'}{'override'} = 1;

# and in project config gitweb.grep = 0|1;

'grep' => {

'sub' => sub { feature_bool('grep', @_) },

'override' => 0,

'default' => [1]},

# Enable the pickaxe search, which will list the commits that modified

# a given string in a file. This can be practical and quite faster

# alternative to 'blame', but still potentially CPU-intensive.

# Note that you need to have 'search' feature enabled too.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'pickaxe'}{'default'} = [1];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'pickaxe'}{'override'} = 1;

# and in project config gitweb.pickaxe = 0|1;

'pickaxe' => {

'sub' => sub { feature_bool('pickaxe', @_) },

'override' => 0,

'default' => [1]},

# Enable showing size of blobs in a 'tree' view, in a separate

# column, similar to what 'ls -l' does. This cost a bit of IO.

# To disable system wide have in $GITWEB_CONFIG

# $feature{'show-sizes'}{'default'} = [0];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'show-sizes'}{'override'} = 1;

# and in project config gitweb.showsizes = 0|1;

'show-sizes' => {

'sub' => sub { feature_bool('showsizes', @_) },

'override' => 0,

'default' => [1]},

# Make gitweb use an alternative format of the URLs which can be

# more readable and natural-looking: project name is embedded

# directly in the path and the query string contains other

# auxiliary information. All gitweb installations recognize

# URL in either format; this configures in which formats gitweb

# generates links.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'pathinfo'}{'default'} = [1];

# Project specific override is not supported.

# Note that you will need to change the default location of CSS,

# favicon, logo and possibly other files to an absolute URL. Also,

# if gitweb.cgi serves as your indexfile, you will need to force

# $my_uri to contain the script name in your $GITWEB_CONFIG.

'pathinfo' => {

'override' => 0,

'default' => [0]},

# Make gitweb consider projects in project root subdirectories

# to be forks of existing projects. Given project $projname.git,

# projects matching $projname/*.git will not be shown in the main

# projects list, instead a '+' mark will be added to $projname

# there and a 'forks' view will be enabled for the project, listing

# all the forks. If project list is taken from a file, forks have

# to be listed after the main project.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'forks'}{'default'} = [1];

# Project specific override is not supported.

'forks' => {

'override' => 0,

'default' => [0]},

# Insert custom links to the action bar of all project pages.

# This enables you mainly to link to third-party scripts integrating

# into gitweb; e.g. git-browser for graphical history representation

# or custom web-based repository administration interface.

# The 'default' value consists of a list of triplets in the form

# (label, link, position) where position is the label after which

# to insert the link and link is a format string where %n expands

# to the project name, %f to the project path within the filesystem,

# %h to the current hash (h gitweb parameter) and %b to the current

# hash base (hb gitweb parameter); %% expands to %.

# To enable system wide have in $GITWEB_CONFIG e.g.

# $feature{'actions'}{'default'} = [('graphiclog',

# '/git-browser/by-commit.html?r=%n', 'summary')];

# Project specific override is not supported.

'actions' => {

'override' => 0,

'default' => []},

# Allow gitweb scan project content tags of project repository,

# and display the popular Web 2.0-ish "tag cloud" near the projects

# list. Note that this is something COMPLETELY different from the

# normal Git tags.

# gitweb by itself can show existing tags, but it does not handle

# tagging itself; you need to do it externally, outside gitweb.

# The format is described in git_get_project_ctags() subroutine.

# You may want to install the HTML::TagCloud Perl module to get

# a pretty tag cloud instead of just a list of tags.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'ctags'}{'default'} = [1];

# Project specific override is not supported.

# In the future whether ctags editing is enabled might depend

# on the value, but using 1 should always mean no editing of ctags.

'ctags' => {

'override' => 0,

'default' => [0]},

# The maximum number of patches in a patchset generated in patch

# view. Set this to 0 or undef to disable patch view, or to a

# negative number to remove any limit.

# To disable system wide have in $GITWEB_CONFIG

# $feature{'patches'}{'default'} = [0];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'patches'}{'override'} = 1;

# and in project config gitweb.patches = 0|n;

# where n is the maximum number of patches allowed in a patchset.

'patches' => {

'sub' => \&feature_patches,

'override' => 0,

'default' => [16]},

# Avatar support. When this feature is enabled, views such as

# shortlog or commit will display an avatar associated with

# the email of the committer(s) and/or author(s).

# Currently available providers are gravatar and picon.

# If an unknown provider is specified, the feature is disabled.

# Gravatar depends on Digest::MD5.

# Picon currently relies on the indiana.edu database.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'avatar'}{'default'} = ['<provider>'];

# where <provider> is either gravatar or picon.

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'avatar'}{'override'} = 1;

# and in project config gitweb.avatar = <provider>;

'avatar' => {

'sub' => \&feature_avatar,

'override' => 0,

'default' => ['']},

# Enable displaying how much time and how many git commands

# it took to generate and display page. Disabled by default.

# Project specific override is not supported.

'timed' => {

'override' => 0,

'default' => [0]},

# Enable turning some links into links to actions which require

# JavaScript to run (like 'blame_incremental'). Not enabled by

# default. Project specific override is currently not supported.

'javascript-actions' => {

'override' => 0,

'default' => [0]},

# Enable and configure ability to change common timezone for dates

# in gitweb output via JavaScript. Enabled by default.

# Project specific override is not supported.

'javascript-timezone' => {

'override' => 0,

'default' => [

'local', # default timezone: 'utc', 'local', or '(-|+)HHMM' format,

# or undef to turn off this feature

'gitweb_tz', # name of cookie where to store selected timezone

'datetime', # CSS class used to mark up dates for manipulation

]},

# Syntax highlighting support. This is based on Daniel Svensson's

# and Sham Chukoury's work in gitweb-xmms2.git.

# It requires the 'highlight' program present in $PATH,

# and therefore is disabled by default.

# To enable system wide have in $GITWEB_CONFIG

# $feature{'highlight'}{'default'} = [1];

'highlight' => {

'sub' => sub { feature_bool('highlight', @_) },

'override' => 0,

'default' => [0]},

# Enable displaying of remote heads in the heads list

# To enable system wide have in $GITWEB_CONFIG

# $feature{'remote_heads'}{'default'} = [1];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'remote_heads'}{'override'} = 1;

# and in project config gitweb.remoteheads = 0|1;

'remote_heads' => {

'sub' => sub { feature_bool('remote_heads', @_) },

'override' => 0,

'default' => [0]},

# Enable showing branches under other refs in addition to heads

# To set system wide extra branch refs have in $GITWEB_CONFIG

# $feature{'extra-branch-refs'}{'default'} = ['dirs', 'of', 'choice'];

# To have project specific config enable override in $GITWEB_CONFIG

# $feature{'extra-branch-refs'}{'override'} = 1;

# and in project config gitweb.extrabranchrefs = dirs of choice

# Every directory is separated with whitespace.

'extra-branch-refs' => {

'sub' => \&feature_extra_branch_refs,

'override' => 0,

'default' => []},

);

sub gitweb_get_feature {

my ($name) = @_;

return unless exists $feature{$name};

my ($sub, $override, @defaults) = (

$feature{$name}{'sub'},

$feature{$name}{'override'},

@{$feature{$name}{'default'}});

# project specific override is possible only if we have project

our $git_dir; # global variable, declared later

if (!$override || !defined $git_dir) {

return @defaults;

}

if (!defined $sub) {

warn "feature $name is not overridable";

return @defaults;

}

return $sub->(@defaults);

}

sub gitweb_check_feature {

return (gitweb_get_feature(@_))[0];

}

sub feature_bool {

my $key = shift;

my ($val) = git_get_project_config($key, '--bool');

if (!defined $val) {

return ($_[0]);

} elsif ($val eq 'true') {

return (1);

} elsif ($val eq 'false') {

return (0);

}

}

sub feature_snapshot {

my (@fmts) = @_;

my ($val) = git_get_project_config('snapshot');

if ($val) {

@fmts = ($val eq 'none' ? () : split /\s*[,\s]\s*/, $val);

}

return @fmts;

}

sub feature_patches {

my @val = (git_get_project_config('patches', '--int'));

if (@val) {

return @val;

}

return ($_[0]);

}

sub feature_avatar {

my @val = (git_get_project_config('avatar'));

return @val ? @val : @_;

}

sub feature_extra_branch_refs {

my (@branch_refs) = @_;

my $values = git_get_project_config('extrabranchrefs');

if ($values) {

$values = config_to_multi ($values);

@branch_refs = ();

foreach my $value (@{$values}) {

push @branch_refs, split /\s+/, $value;

}

}

return @branch_refs;

}

sub check_head_link {

my ($dir) = @_;

my $headfile = "$dir/HEAD";

return ((-e $headfile) ||

(-l $headfile && readlink($headfile) =~ /^refs\/heads\//));

}

sub check_export_ok {

my ($dir) = @_;

return (check_head_link($dir) &&

(!$export_ok || -e "$dir/$export_ok") &&

(!$export_auth_hook || $export_auth_hook->($dir)));

}

sub filter_snapshot_fmts {

my @fmts = @_;

@fmts = map {

exists $known_snapshot_format_aliases{$_} ?

$known_snapshot_format_aliases{$_} : $_} @fmts;

@fmts = grep {

exists $known_snapshot_formats{$_} &&

!$known_snapshot_formats{$_}{'disabled'}} @fmts;

}

sub filter_and_validate_refs {

my @refs = @_;

my %unique_refs = ();

foreach my $ref (@refs) {

die_error(500, "Invalid ref '$ref' in 'extra-branch-refs' feature") unless (is_valid_ref_format($ref));

# 'heads' are added implicitly in get_branch_refs().

$unique_refs{$ref} = 1 if ($ref ne 'heads');

}

return sort keys %unique_refs;

}

our $per_request_config = 1;

sub read_config_file {

my $filename = shift;

return unless defined $filename;

# die if there are errors parsing config file

if (-e $filename) {

do $filename;

die $@ if $@;

return 1;

}

return;

}

our ($GITWEB_CONFIG, $GITWEB_CONFIG_SYSTEM, $GITWEB_CONFIG_COMMON);

sub evaluate_gitweb_config {

our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";

our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "++GITWEB_CONFIG_SYSTEM++";

our $GITWEB_CONFIG_COMMON = $ENV{'GITWEB_CONFIG_COMMON'} || "++GITWEB_CONFIG_COMMON++";

# Protect against duplications of file names, to not read config twice.

# Only one of $GITWEB_CONFIG and $GITWEB_CONFIG_SYSTEM is used, so

# there possibility of duplication of filename there doesn't matter.

$GITWEB_CONFIG = "" if ($GITWEB_CONFIG eq $GITWEB_CONFIG_COMMON);

$GITWEB_CONFIG_SYSTEM = "" if ($GITWEB_CONFIG_SYSTEM eq $GITWEB_CONFIG_COMMON);

# Common system-wide settings for convenience.

# Those settings can be ovverriden by GITWEB_CONFIG or GITWEB_CONFIG_SYSTEM.

read_config_file($GITWEB_CONFIG_COMMON);

# Use first config file that exists. This means use the per-instance

# GITWEB_CONFIG if exists, otherwise use GITWEB_SYSTEM_CONFIG.

read_config_file($GITWEB_CONFIG) and return;

read_config_file($GITWEB_CONFIG_SYSTEM);

}

sub get_loadavg {

if( -e '/proc/loadavg' ){

open my $fd, '<', '/proc/loadavg'

or return 0;

my @load = split(/\s+/, scalar <$fd>);

close $fd;

# The first three columns measure CPU and IO utilization of the last one,

# five, and 10 minute periods. The fourth column shows the number of

# currently running processes and the total number of processes in the m/n

# format. The last column displays the last process ID used.

return $load[0] || 0;

}

# additional checks for load average should go here for things that don't export

# /proc/loadavg

return 0;

}

our $git_version;

sub evaluate_git_version {

our $git_version = qx("$GIT" --version) =~ m/git version (.*)$/ ? $1 : "unknown";

$number_of_git_cmds++;

}

sub check_loadavg {

if (defined $maxload && get_loadavg() > $maxload) {

die_error(503, "The load average on the server is too high");

}

}

our %input_params = ();

our @cgi_param_mapping = (

project => "p",

action => "a",

file_name => "f",

file_parent => "fp",

hash => "h",

hash_parent => "hp",

hash_base => "hb",

hash_parent_base => "hpb",

page => "pg",

order => "o",

searchtext => "s",

searchtype => "st",

snapshot_format => "sf",

extra_options => "opt",

search_use_regexp => "sr",

ctag => "by_tag",

diff_style => "ds",

project_filter => "pf",

# this must be last entry (for manipulation from JavaScript)

javascript => "js"

);

our %cgi_param_mapping = @cgi_param_mapping;

our %actions = (

"blame" => \&git_blame,

"blame_incremental" => \&git_blame_incremental,

"blame_data" => \&git_blame_data,

"blobdiff" => \&git_blobdiff,

"blobdiff_plain" => \&git_blobdiff_plain,

"blob" => \&git_blob,

"blob_plain" => \&git_blob_plain,

"commitdiff" => \&git_commitdiff,

"commitdiff_plain" => \&git_commitdiff_plain,

"commit" => \&git_commit,

"forks" => \&git_forks,

"heads" => \&git_heads,

"history" => \&git_history,

"log" => \&git_log,

"patch" => \&git_patch,

"patches" => \&git_patches,

"remotes" => \&git_remotes,

"rss" => \&git_rss,

"atom" => \&git_atom,

"search" => \&git_search,

"search_help" => \&git_search_help,

"shortlog" => \&git_shortlog,

"summary" => \&git_summary,

"tag" => \&git_tag,

"tags" => \&git_tags,

"tree" => \&git_tree,

"snapshot" => \&git_snapshot,

"object" => \&git_object,

# those below don't need $project

"opml" => \&git_opml,

"project_list" => \&git_project_list,

"project_index" => \&git_project_index,

);

our %allowed_options = (

"--no-merges" => [ qw(rss atom log shortlog history) ],

);

sub evaluate_query_params {

our $cgi;

while (my ($name, $symbol) = each %cgi_param_mapping) {

if ($symbol eq 'opt') {

$input_params{$name} = [ map { decode_utf8($_) } $cgi->param($symbol) ];

} else {

$input_params{$name} = decode_utf8($cgi->param($symbol));

}

}

}

sub evaluate_path_info {

return if defined $input_params{'project'};

return if !$path_info;

$path_info =~ s,^/+,,;

return if !$path_info;

# find which part of PATH_INFO is project

my $project = $path_info;

$project =~ s,/+$,,;

while ($project && !check_head_link("$projectroot/$project")) {

$project =~ s,/*[^/]*$,,;

}

return unless $project;

$input_params{'project'} = $project;

# do not change any parameters if an action is given using the query string

return if $input_params{'action'};

$path_info =~ s,^\Q$project\E/*,,;

# next, check if we have an action

my $action = $path_info;

$action =~ s,/.*$,,;

if (exists $actions{$action}) {

$path_info =~ s,^$action/*,,;

$input_params{'action'} = $action;

}

# list of actions that want hash_base instead of hash, but can have no

# pathname (f) parameter

my @wants_base = (

'tree',

'history',

);

# we want to catch, among others

# [$hash_parent_base[:$file_parent]..]$hash_parent[:$file_name]

my ($parentrefname, $parentpathname, $refname, $pathname) =

($path_info =~ /^(?:(.+?)(?::(.+))?\.\.)?([^:]+?)?(?::(.+))?$/);

# first, analyze the 'current' part

if (defined $pathname) {

# we got "branch:filename" or "branch:dir/"

# we could use git_get_type(branch:pathname), but:

# - it needs $git_dir

# - it does a git() call

# - the convention of terminating directories with a slash

# makes it superfluous

# - embedding the action in the PATH_INFO would make it even

# more superfluous

$pathname =~ s,^/+,,;

if (!$pathname || substr($pathname, -1) eq "/") {

$input_params{'action'} ||= "tree";

$pathname =~ s,/$,,;

} else {

# the default action depends on whether we had parent info

# or not

if ($parentrefname) {

$input_params{'action'} ||= "blobdiff_plain";

} else {

$input_params{'action'} ||= "blob_plain";

}

}

$input_params{'hash_base'} ||= $refname;

$input_params{'file_name'} ||= $pathname;

} elsif (defined $refname) {

# we got "branch". In this case we have to choose if we have to

# set hash or hash_base.

#

# Most of the actions without a pathname only want hash to be

# set, except for the ones specified in @wants_base that want

# hash_base instead. It should also be noted that hand-crafted

# links having 'history' as an action and no pathname or hash

# set will fail, but that happens regardless of PATH_INFO.

if (defined $parentrefname) {

# if there is parent let the default be 'shortlog' action

# (for http://git.example.com/repo.git/A..B links); if there

# is no parent, dispatch will detect type of object and set

# action appropriately if required (if action is not set)

$input_params{'action'} ||= "shortlog";

}

if ($input_params{'action'} &&

grep { $_ eq $input_params{'action'} } @wants_base) {

$input_params{'hash_base'} ||= $refname;

} else {

$input_params{'hash'} ||= $refname;

}

}

# next, handle the 'parent' part, if present

if (defined $parentrefname) {

# a missing pathspec defaults to the 'current' filename, allowing e.g.

# someproject/blobdiff/oldrev..newrev:/filename

if ($parentpathname) {

$parentpathname =~ s,^/+,,;

$parentpathname =~ s,/$,,;

$input_params{'file_parent'} ||= $parentpathname;

} else {

$input_params{'file_parent'} ||= $input_params{'file_name'};

}

# we assume that hash_parent_base is wanted if a path was specified,

# or if the action wants hash_base instead of hash

if (defined $input_params{'file_parent'} ||

grep { $_ eq $input_params{'action'} } @wants_base) {

$input_params{'hash_parent_base'} ||= $parentrefname;

} else {

$input_params{'hash_parent'} ||= $parentrefname;

}

}

# for the snapshot action, we allow URLs in the form

# $project/snapshot/$hash.ext

# where .ext determines the snapshot and gets removed from the

# passed $refname to provide the $hash.

#

# To be able to tell that $refname includes the format extension, we

# require the following two conditions to be satisfied:

# - the hash input parameter MUST have been set from the $refname part

# of the URL (i.e. they must be equal)

# - the snapshot format MUST NOT have been defined already (e.g. from