381 lines
13 KiB
Perl
381 lines
13 KiB
Perl
#
|
|
# Copyright 2021 Centreon (http://www.centreon.com/)
|
|
#
|
|
# Centreon is a full-fledged industry-strength solution that meets
|
|
# the needs in IT infrastructure and application monitoring for
|
|
# service performance.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
package centreon::plugins::backend::http::lwp;
|
|
|
|
use strict;
|
|
use warnings;
|
|
use centreon::plugins::backend::http::useragent;
|
|
use URI;
|
|
use IO::Socket::SSL;
|
|
|
|
sub new {
|
|
my ($class, %options) = @_;
|
|
my $self = {};
|
|
bless $self, $class;
|
|
|
|
if (!defined($options{noptions}) || $options{noptions} != 1) {
|
|
$options{options}->add_options(arguments => {
|
|
'ssl:s' => { name => 'ssl' },
|
|
'ssl-opt:s@' => { name => 'ssl_opt' },
|
|
});
|
|
$options{options}->add_help(package => __PACKAGE__, sections => 'BACKEND LWP OPTIONS', once => 1);
|
|
}
|
|
|
|
$self->{output} = $options{output};
|
|
$self->{ua} = undef;
|
|
$self->{debug_handlers} = 0;
|
|
|
|
return $self;
|
|
}
|
|
|
|
sub check_options {
|
|
my ($self, %options) = @_;
|
|
|
|
foreach (('unknown_status', 'warning_status', 'critical_status')) {
|
|
if (defined($options{request}->{$_})) {
|
|
$options{request}->{$_} =~ s/%\{http_code\}/\$self->{response}->code/g;
|
|
}
|
|
}
|
|
|
|
$self->{ssl_context} = '';
|
|
if (!defined($options{request}->{ssl_opt})) {
|
|
$options{request}->{ssl_opt} = [];
|
|
}
|
|
if (defined($options{request}->{ssl}) && $options{request}->{ssl} ne '') {
|
|
push @{$options{request}->{ssl_opt}}, 'SSL_version => ' . $options{request}->{ssl};
|
|
}
|
|
if (defined($options{request}->{cert_file}) && !defined($options{request}->{cert_pkcs12})) {
|
|
push @{$options{request}->{ssl_opt}}, 'SSL_use_cert => 1';
|
|
push @{$options{request}->{ssl_opt}}, 'SSL_cert_file => "' . $options{request}->{cert_file} . '"';
|
|
push @{$options{request}->{ssl_opt}}, 'SSL_key_file => "' . $options{request}->{key_file} . '"'
|
|
if (defined($options{request}->{key_file}));
|
|
push @{$options{request}->{ssl_opt}}, 'SSL_ca_file => "' . $options{request}->{cacert_file} . '"'
|
|
if (defined($options{request}->{cacert_file}));
|
|
}
|
|
if ($options{request}->{insecure}) {
|
|
push @{$options{request}->{ssl_opt}}, 'SSL_verify_mode => SSL_VERIFY_NONE';
|
|
}
|
|
|
|
my $append = '';
|
|
foreach (@{$options{request}->{ssl_opt}}) {
|
|
if ($_ ne '') {
|
|
$self->{ssl_context} .= $append . $_;
|
|
$append = ', ';
|
|
}
|
|
}
|
|
}
|
|
|
|
sub set_proxy {
|
|
my ($self, %options) = @_;
|
|
|
|
if (defined($options{request}->{proxypac}) && $options{request}->{proxypac} ne '') {
|
|
centreon::plugins::misc::mymodule_load(
|
|
output => $self->{output}, module => 'HTTP::ProxyPAC',
|
|
error_msg => "Cannot load module 'HTTP::ProxyPAC'."
|
|
);
|
|
my ($pac, $pac_uri);
|
|
eval {
|
|
if ($options{request}->{proxypac} =~ /^(http|https):\/\//) {
|
|
$pac_uri = URI->new($options{request}->{proxypac});
|
|
$pac = HTTP::ProxyPAC->new($pac_uri);
|
|
} else {
|
|
$pac = HTTP::ProxyPAC->new($options{request}->{proxypac});
|
|
}
|
|
};
|
|
if ($@) {
|
|
$self->{output}->add_option_msg(short_msg => 'issue to load proxypac: ' . $@);
|
|
$self->{output}->option_exit();
|
|
}
|
|
my $res = $pac->find_proxy($options{url});
|
|
if (defined($res->direct) && $res->direct != 1) {
|
|
my $proxy_uri = URI->new($res->proxy);
|
|
$proxy_uri->userinfo($pac_uri->userinfo) if (defined($pac_uri->userinfo));
|
|
$self->{ua}->proxy(['http', 'https'], $proxy_uri->as_string);
|
|
}
|
|
}
|
|
if (defined($options{request}->{proxyurl}) && $options{request}->{proxyurl} ne '') {
|
|
my $proxyurl = $options{request}->{proxyurl};
|
|
if ($options{request}->{proto} eq "https" ||
|
|
(defined($options{request}->{full_url}) && $options{request}->{full_url} =~ /^https/)) {
|
|
$proxyurl = 'connect://' . $2 if ($proxyurl =~ /^(http|https):\/\/(.*)/);
|
|
}
|
|
$self->{ua}->proxy(['http', 'https'], $proxyurl);
|
|
}
|
|
}
|
|
|
|
sub request {
|
|
my ($self, %options) = @_;
|
|
|
|
my %user_agent_params = (keep_alive => 1);
|
|
if (defined($options{request}->{certinfo}) && $options{request}->{certinfo} == 1) {
|
|
centreon::plugins::misc::mymodule_load(
|
|
output => $self->{output}, module => 'LWP::ConnCache',
|
|
error_msg => "Cannot load module 'LWP::ConnCache'."
|
|
);
|
|
$self->{cache} = LWP::ConnCache->new();
|
|
$self->{cache}->total_capacity(1);
|
|
%user_agent_params = (conn_cache => $self->{cache});
|
|
}
|
|
|
|
my $request_options = $options{request};
|
|
if (!defined($self->{ua})) {
|
|
my $timeout;
|
|
$timeout = $1 if (defined($request_options->{timeout}) && $request_options->{timeout} =~ /(\d+)/);
|
|
$self->{ua} = centreon::plugins::backend::http::useragent->new(
|
|
%user_agent_params,
|
|
protocols_allowed => ['http', 'https'],
|
|
timeout => $timeout,
|
|
credentials => $request_options->{credentials},
|
|
username => $request_options->{username},
|
|
password => $request_options->{password}
|
|
);
|
|
if (defined($request_options->{cookies_file})) {
|
|
centreon::plugins::misc::mymodule_load(
|
|
output => $self->{output},
|
|
module => 'HTTP::Cookies',
|
|
error_msg => "Cannot load module 'HTTP::Cookies'."
|
|
);
|
|
$self->{ua}->cookie_jar(
|
|
HTTP::Cookies->new(
|
|
file => $request_options->{cookies_file},
|
|
autosave => 1
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
if ($self->{output}->is_debug() && $self->{debug_handlers} == 0) {
|
|
$self->{debug_handlers} = 1;
|
|
$self->{ua}->add_handler('request_send', sub {
|
|
my ($response, $ua, $handler) = @_;
|
|
|
|
$self->{output}->output_add(long_msg => '======> request send', debug => 1);
|
|
$self->{output}->output_add(long_msg => $response->as_string, debug => 1);
|
|
return ;
|
|
});
|
|
$self->{ua}->add_handler("response_done", sub {
|
|
my ($response, $ua, $handler) = @_;
|
|
|
|
$self->{output}->output_add(long_msg => '======> response done', debug => 1);
|
|
$self->{output}->output_add(long_msg => $response->as_string, debug => 1);
|
|
return ;
|
|
});
|
|
}
|
|
|
|
if (defined($request_options->{no_follow})) {
|
|
$self->{ua}->requests_redirectable(undef);
|
|
} else {
|
|
$self->{ua}->requests_redirectable([ 'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'PATCH' ]);
|
|
}
|
|
if (defined($request_options->{http_peer_addr})) {
|
|
push @LWP::Protocol::http::EXTRA_SOCK_OPTS, PeerAddr => $request_options->{http_peer_addr};
|
|
}
|
|
|
|
my ($req, $url);
|
|
if (defined($request_options->{full_url})) {
|
|
$url = $request_options->{full_url};
|
|
} elsif (defined($request_options->{port}) && $request_options->{port} =~ /^[0-9]+$/) {
|
|
$url = $request_options->{proto}. '://' . $request_options->{hostname} . ':' . $request_options->{port} . $request_options->{url_path};
|
|
} else {
|
|
$url = $request_options->{proto}. '://' . $request_options->{hostname} . $request_options->{url_path};
|
|
}
|
|
|
|
my $uri = URI->new($url);
|
|
if (defined($request_options->{get_params})) {
|
|
$uri->query_form($request_options->{get_params});
|
|
}
|
|
$req = HTTP::Request->new($request_options->{method}, $uri);
|
|
|
|
my $content_type_forced = 0;
|
|
foreach my $key (keys %{$request_options->{headers}}) {
|
|
$req->header($key => $request_options->{headers}->{$key});
|
|
if ($key =~ /content-type/i) {
|
|
$content_type_forced = 1;
|
|
}
|
|
}
|
|
|
|
if ($content_type_forced == 1) {
|
|
$req->content($request_options->{query_form_post});
|
|
} elsif (defined($options{request}->{post_params})) {
|
|
my $uri_post = URI->new();
|
|
$uri_post->query_form($request_options->{post_params});
|
|
$req->content_type('application/x-www-form-urlencoded');
|
|
$req->content($uri_post->query);
|
|
}
|
|
|
|
if (defined($request_options->{credentials}) && defined($request_options->{ntlmv2})) {
|
|
centreon::plugins::misc::mymodule_load(
|
|
output => $self->{output},
|
|
module => 'Authen::NTLM',
|
|
error_msg => "Cannot load module 'Authen::NTLM'."
|
|
);
|
|
Authen::NTLM::ntlmv2(1);
|
|
}
|
|
|
|
if (defined($request_options->{credentials}) && defined($request_options->{basic})) {
|
|
$req->authorization_basic($request_options->{username}, $request_options->{password});
|
|
}
|
|
|
|
$self->set_proxy(request => $request_options, url => $url);
|
|
|
|
if (defined($request_options->{cert_pkcs12}) && $request_options->{cert_file} ne '' && $request_options->{cert_pwd} ne '') {
|
|
eval 'use Net::SSL'; die $@ if $@;
|
|
$ENV{HTTPS_PKCS12_FILE} = $request_options->{cert_file};
|
|
$ENV{HTTPS_PKCS12_PASSWORD} = $request_options->{cert_pwd};
|
|
}
|
|
|
|
if (defined($self->{ssl_context}) && $self->{ssl_context} ne '') {
|
|
my $context = new IO::Socket::SSL::SSL_Context(eval $self->{ssl_context});
|
|
IO::Socket::SSL::set_default_context($context);
|
|
}
|
|
|
|
$self->{response} = $self->{ua}->request($req);
|
|
|
|
# Check response
|
|
my $status = 'ok';
|
|
my $message;
|
|
|
|
eval {
|
|
local $SIG{__WARN__} = sub { $message = $_[0]; };
|
|
local $SIG{__DIE__} = sub { $message = $_[0]; };
|
|
|
|
if (defined($request_options->{critical_status}) && $request_options->{critical_status} ne '' &&
|
|
eval "$request_options->{critical_status}") {
|
|
$status = 'critical';
|
|
} elsif (defined($request_options->{warning_status}) && $request_options->{warning_status} ne '' &&
|
|
eval "$request_options->{warning_status}") {
|
|
$status = 'warning';
|
|
} elsif (defined($request_options->{unknown_status}) && $request_options->{unknown_status} ne '' &&
|
|
eval "$request_options->{unknown_status}") {
|
|
$status = 'unknown';
|
|
}
|
|
};
|
|
if (defined($message)) {
|
|
$self->{output}->add_option_msg(short_msg => 'filter status issue: ' . $message);
|
|
$self->{output}->option_exit();
|
|
}
|
|
|
|
if (!$self->{output}->is_status(value => $status, compare => 'ok', litteral => 1)) {
|
|
my $short_msg = $self->{response}->status_line;
|
|
if ($short_msg =~ /^401/) {
|
|
$short_msg .= ' (' . $1 . ' authentication expected)' if (defined($self->{response}->www_authenticate) &&
|
|
$self->{response}->www_authenticate =~ /(\S+)/);
|
|
}
|
|
|
|
$self->{output}->output_add(
|
|
severity => $status,
|
|
short_msg => $short_msg
|
|
);
|
|
$self->{output}->display();
|
|
$self->{output}->exit();
|
|
}
|
|
|
|
$self->{headers} = $self->{response}->headers();
|
|
return $self->{response}->content;
|
|
}
|
|
|
|
sub get_headers {
|
|
my ($self, %options) = @_;
|
|
|
|
my $headers = '';
|
|
foreach ($options{response}->header_field_names()) {
|
|
my $value = $options{response}->header($_);
|
|
$headers .= "$_: " . (defined($value) ? $value : '') . "\n";
|
|
}
|
|
|
|
return $headers;
|
|
}
|
|
|
|
sub get_first_header {
|
|
my ($self, %options) = @_;
|
|
|
|
my @redirects = $self->{response}->redirects();
|
|
if (!defined($options{name})) {
|
|
return $self->get_headers(response => defined($redirects[0]) ? $redirects[0] : $self->{response});
|
|
}
|
|
|
|
return
|
|
defined($redirects[0]) ?
|
|
$redirects[0]->headers()->header($options{name}) :
|
|
$self->{headers}->header($options{name})
|
|
;
|
|
}
|
|
|
|
sub get_header {
|
|
my ($self, %options) = @_;
|
|
|
|
if (!defined($options{name})) {
|
|
return $self->get_headers(response => $self->{response});
|
|
}
|
|
return $self->{headers}->header($options{name});
|
|
}
|
|
|
|
sub get_code {
|
|
my ($self, %options) = @_;
|
|
|
|
return $self->{response}->code();
|
|
}
|
|
|
|
sub get_message {
|
|
my ($self, %options) = @_;
|
|
|
|
return $self->{response}->message();
|
|
}
|
|
|
|
sub get_certificate {
|
|
my ($self, %options) = @_;
|
|
|
|
my ($con) = $self->{cache}->get_connections('https');
|
|
return ('socket', $con);
|
|
}
|
|
|
|
1;
|
|
|
|
__END__
|
|
|
|
=head1 NAME
|
|
|
|
HTTP LWP backend layer.
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
HTTP LWP backend layer.
|
|
|
|
=head1 BACKEND LWP OPTIONS
|
|
|
|
=over 8
|
|
|
|
=item B<--ssl-opt>
|
|
|
|
Set SSL Options (--ssl-opt="SSL_version => TLSv1" --ssl-opt="SSL_verify_mode => SSL_VERIFY_NONE").
|
|
|
|
=item B<--ssl>
|
|
|
|
Set SSL version (--ssl=TLSv1).
|
|
|
|
=back
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
B<http>.
|
|
|
|
=cut
|