use strict;

use lib "/usr/share/bugzilla3";

use Bugzilla;

use Bugzilla::Constants;

use Bugzilla::Error;

use IO::String;

my $user = Bugzilla->login(LOGIN_REQUIRED);

my $cgi = Bugzilla->cgi;

my $template = Bugzilla->template;

my $vars = {};

if ($cgi->param('logout')) {

Bugzilla->logout();

$user = Bugzilla->user;

$vars->{'message'} = "logged_out";

# Make sure that templates or other code doesn't get confused about this.

$cgi->delete('logout');

}

my $bz_header = $cgi->header();

$ENV{'GITWEB_CONFIG_SYSTEM'} = '/etc/bugzilla3/gitweb.conf';

{

my $binary;

sub binary_content {

$binary = $_[0] if $_[0];

return $binary;

}

}

{

my $fh;

sub original_stdout {

$fh = $_[0] if $_[0];

return $fh;

}

}

my $str;

do {

my $str_fh = IO::String->new($str);

original_stdout(select($str_fh));

bugzilla_git_web_print();

select(original_stdout()) if defined original_stdout();

$str =~ s{ ^ .* <body.*?> }{}gxms;

$str =~ s{ </body> .*$ }{}gxms;

};

if (!binary_content()) {

$vars->{'gitweb'} = $str;

# Return the appropriate HTTP response headers.

print $bz_header;

# Generate and return the UI (HTML page) from the appropriate template.

$template->process("gitweb.html.tmpl", $vars)

|| ThrowTemplateError($template->error());

}

else {

# binary stream is already printed from bugzilla_git_web_print()

}

sub bugzilla_git_web_print {

use CGI::Util qw(unescape);

use CGI::Carp qw(fatalsToBrowser);

use Encode;

use Fcntl ':mode';

use File::Find qw();

use File::Basename qw(basename);

binmode STDOUT, ':utf8';

our $t0;

if (eval { require Time::HiRes; 1; }) {

$t0 = [Time::HiRes::gettimeofday()];

}

our $number_of_git_cmds = 0;

our $cgi = new CGI;

our $version = "1.7.1";

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

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

our $base_url = $my_url;

our $path_info = $ENV{"PATH_INFO"};

if ($path_info) {

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'};

}

}

our $GIT = "/usr/bin/git";

our $projectroot = "/pub/git";

our $project_maxdepth = 2007;

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

our $home_link_str = "projects";

our $site_name = ""

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

our $site_header = "";

our $home_text = "indextext.html";

our $site_footer = "";

our @stylesheets = ("gitweb.css");

our $stylesheet = undef;

our $logo = "git-logo.png";

our $favicon = "git-favicon.png";

our $javascript = "gitweb.js";

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

our $logo_label = "git homepage";

our $projects_list = "";

our $projects_list_description_width = 25;

our $default_projects_order = "project";

our $export_ok = "";

our $export_auth_hook = undef;

our $strict_export = "";

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

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 %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']},

'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 %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

# overriden

#

# 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.

'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.

# 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.

# 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 described in ctags/

# of project repository, and display the popular Web 2.0-ish

# "tag cloud" near the project 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 an external application for that.

# For an example script, check Girocco's cgi/tagproj.cgi.

# 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'} = ['path_to_tag_script'];

# Project specific override is not supported.

'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]},

);

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 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;

}

our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "gitweb_config.perl";

our $GITWEB_CONFIG_SYSTEM = $ENV{'GITWEB_CONFIG_SYSTEM'} || "/etc/gitweb.conf";

if (-e $GITWEB_CONFIG) {

do $GITWEB_CONFIG;

die $@ if $@;

} elsif (-e $GITWEB_CONFIG_SYSTEM) {

do $GITWEB_CONFIG_SYSTEM;

die $@ if $@;

}

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 = qx("$GIT" --version) =~ m/git version (.*)$/ ? $1 : "unknown";

$number_of_git_cmds++;

$projects_list ||= $projectroot;

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",

# 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,

"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) ],

);

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

if ($symbol eq 'opt') {

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

} else {

$input_params{$name} = $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

# [$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.

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

if (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

# CGI parameter sf)

# It's also useless to try any matching unless $refname has a dot,

# so we check for that too

if (defined $input_params{'action'} &&

$input_params{'action'} eq 'snapshot' &&

defined $refname && index($refname, '.') != -1 &&

$refname eq $input_params{'hash'} &&

!defined $input_params{'snapshot_format'}) {

# We loop over the known snapshot formats, checking for

# extensions. Allowed extensions are both the defined suffix

# (which includes the initial dot already) and the snapshot

# format key itself, with a prepended dot

while (my ($fmt, $opt) = each %known_snapshot_formats) {

my $hash = $refname;

unless ($hash =~ s/(\Q$opt->{'suffix'}\E|\Q.$fmt\E)$//) {

next;

}

my $sfx = $1;

# a valid suffix was found, so set the snapshot format

# and reset the hash parameter

$input_params{'snapshot_format'} = $fmt;

$input_params{'hash'} = $hash;

# we also set the format suffix to the one requested

# in the URL: this way a request for e.g. .tgz returns

# a .tgz instead of a .tar.gz

$known_snapshot_formats{$fmt}{'suffix'} = $sfx;

last;

}

}

}

evaluate_path_info();

our $action = $input_params{'action'};

if (defined $action) {

if (!validate_action($action)) {

die_error(400, "Invalid action parameter");

}

}

our $project = $input_params{'project'};

if (defined $project) {

if (!validate_project($project)) {

undef $project;

die_error(404, "No such project");

}

}

our $file_name = $input_params{'file_name'};

if (defined $file_name) {

if (!validate_pathname($file_name)) {

die_error(400, "Invalid file parameter");

}

}

our $file_parent = $input_params{'file_parent'};

if (defined $file_parent) {

if (!validate_pathname($file_parent)) {

die_error(400, "Invalid file parent parameter");

}

}

our $hash = $input_params{'hash'};

if (defined $hash) {

if (!validate_refname($hash)) {

die_error(400, "Invalid hash parameter");

}

}

our $hash_parent = $input_params{'hash_parent'};

if (defined $hash_parent) {

if (!validate_refname($hash_parent)) {

die_error(400, "Invalid hash parent parameter");

}

}

our $hash_base = $input_params{'hash_base'};

if (defined $hash_base) {

if (!validate_refname($hash_base)) {

die_error(400, "Invalid hash base parameter");

}

}

our @extra_options = @{$input_params{'extra_options'}};

foreach my $opt (@extra_options) {

if (not exists $allowed_options{$opt}) {

die_error(400, "Invalid option parameter");

}

if (not grep(/^$action$/, @{$allowed_options{$opt}})) {

die_error(400, "Invalid option parameter for this action");

}

}

our $hash_parent_base = $input_params{'hash_parent_base'};

if (defined $hash_parent_base) {

if (!validate_refname($hash_parent_base)) {

die_error(400, "Invalid hash parent base parameter");

}

}

our $page = $input_params{'page'};

if (defined $page) {

if ($page =~ m/[^0-9]/) {

die_error(400, "Invalid page parameter");

}

}

our $searchtype = $input_params{'searchtype'};

if (defined $searchtype) {

if ($searchtype =~ m/[^a-z]/) {

die_error(400, "Invalid searchtype parameter");

}

}

our $search_use_regexp = $input_params{'search_use_regexp'};

our $searchtext = $input_params{'searchtext'};