view release on metacpan or search on metacpan
t/live_engine_request_headers.t view on Meta::CPAN
my $request = GET( 'http://localhost/dump/request',
'User-Agent' => 'MyAgen/1.0',
'X-Whats-Cool' => 'Catalyst',
'X-Multiple' => [ 1 .. 5 ],
'X-Forwarded-Host' => 'frontend.server.com',
'X-Forwarded-For' => '192.168.1.1, 1.2.3.4',
);
ok( my $response = request($request), 'Request' );
ok( $response->is_success, 'Response Successful 2xx' );
is( $response->content_type, 'text/plain', 'Response Content-Type' );
view release on metacpan or search on metacpan
lib/Catalyst/Engine/HTTP/Prefork.pm view on Meta::CPAN
# Add headers
my $headers = $h->getHeaders();
$self->{client}->{headers} = $headers;
# prepare_connection and prepare_path need a few headers in %ENV
$ENV{HTTP_X_FORWARDED_FOR} = $headers->{'X-Forwarded-For'}
if $headers->{'X-Forwarded-For'};
$ENV{HTTP_X_FORWARDED_HOST} = $headers->{'X-Forwarded-Host'}
if $headers->{'X-Forwarded-Host'};
# Determine whether we will keep the connection open after the request
my $connection = $headers->{Connection};
view release on metacpan or search on metacpan
lib/Catalyst/Engine/PSGI.pm view on Meta::CPAN
=item *
When your application runs behind the frontend proxy like nginx or
lighttpd, this Catalyst engine doesn't automatically recognize the
incoming headers like C<X-Forwarded-For>, because respecting these
headers by default causes a potential security issue.
You have to enable L<Plack::Middleware::ReverseProxy> or
L<Plack::Middleware::ForwardedHeaders> to automatically promote those
forwarded headers into C<REMOTE_ADDR> hence IP address of the request.
view release on metacpan or search on metacpan
t/13-extjs-cachefly.t view on Meta::CPAN
$mech->content_contains('http://extjs.cachefly.net/',
"pages are using the ExtJS CacheFly links");
# mimic that the webserver is running behind a reverse proxy that proxies from
# HTTPS to HTTP
$mech->default_header('X-Forwarded-For' => '127.0.0.1');
$mech->default_header('X-Forwarded-Host' => 'localhost');
$mech->default_header('X-Forwarded-Port' => 443);
# get basic template, no Metadata
$mech->get_ok('/autocrud/helloworld', 'Get Hello World page (HTTPS)');
view release on metacpan or search on metacpan
lib/Catalyst.pm view on Meta::CPAN
Catalyst will automatically detect this situation when you are running
the frontend and backend servers on the same machine. The following
changes are made to the request.
$c->req->address is set to the user's real IP address, as read from
the HTTP X-Forwarded-For header.
The host value for $c->req->base and $c->req->uri is set to the real
host, as read from the HTTP X-Forwarded-Host header.
Additionally, you may be running your backend application on an insecure
view release on metacpan or search on metacpan
option abortonclose
option httpclose
balance roundrobin
# capture request header X-Forwarded-For len 15
capture response header X-Serverside-Cache len 30
server cache1 10.10.118.41:80 maxconn 400 check inter 2000 fall 8 weight 3
server cache2 10.10.118.43:80 maxconn 400 check inter 2000 fall 8 weight 2
server cache4 10.10.118.44:80 maxconn 400 check inter 2000 fall 8 weight 2
# option httpchk
## option httpchk /img/logo.png
#
# balance roundrobin
#
## capture request header X-Forwarded-For len 15
# capture response header X-Serverside-Cache len 30
#
# server testcache2 10.10.118.3:1080 maxconn 100 check inter 2000 fall 3
# server testcache4 10.10.118.4:1080 maxconn 100 check inter 2000 fall 3
# server bck 127.0.0.1:8881 check backup
option abortonclose
option httpclose
balance roundrobin
# capture request header X-Forwarded-For len 15
capture response header Cache-Control len 64
# server www17 10.10.118.72:80 maxconn 100 check inter 2000 fall 3
server www18 10.10.118.73:80 maxconn 100 check inter 2000 fall 3
server www19 10.10.118.74:80 maxconn 100 check inter 2000 fall 3
# option httpchk
## option httpchk /img/logo.png
#
# balance roundrobin
#
## capture request header X-Forwarded-For len 15
# capture response header Cache-Control len 15
#
# server www20 10.10.118.75:80 maxconn 100 check inter 2000 fall 3
# server bck 127.0.0.1:8881 check backup
#
view release on metacpan or search on metacpan
lib/Convos/Manual/HttpHeaders.pod view on Meta::CPAN
# generic headers for correct handling of ws and http
proxy_http_version 1.1;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $host;
# set this if you are running SSL
proxy_set_header X-Forwarded-HTTPS 1;
view release on metacpan or search on metacpan
lib/DDG/Rewrite.pm view on Meta::CPAN
predicate => 'has_proxy_ssl_session_reuse',
);
has proxy_x_forwarded_for => (
is => 'ro',
default => sub { 'X-Forwarded-For $proxy_add_x_forwarded_for' }
);
has post_body => (
is => 'ro',
predicate => 'has_post_body',
view release on metacpan or search on metacpan
lib/Dancer/Deployment.pod view on Meta::CPAN
location @proxy {
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_pass http://backendurl;
}
}
view release on metacpan or search on metacpan
lib/Dancer2/Manual/Deployment.pod view on Meta::CPAN
location @proxy {
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://backendurl;
}
}
view release on metacpan or search on metacpan
t/sample_mail.txt view on Meta::CPAN
Received: by mail-ve0-f176.google.com with SMTP id c14so4732160vea.21
for <tenshouser@tensho-saki-host.com>; Mon, 18 Nov 2013 01:35:15 -0800 (PST)
X-Received: by 10.58.136.231 with SMTP id qd7mr14608129veb.1.1384767315376;
Mon, 18 Nov 2013 01:35:15 -0800 (PST)
X-Forwarded-To: tenshouser@tensho-saki-host.com
X-Forwarded-For: hirobanex@gmail.com tenshouser@tensho-saki-host.com
Delivered-To: hirobanex@gmail.com
Received: by 10.52.245.10 with SMTP id xk10csp197545vdc;
Mon, 18 Nov 2013 01:35:15 -0800 (PST)
X-Received: by 10.236.30.70 with SMTP id j46mr2312552yha.73.1384767314704;
Mon, 18 Nov 2013 01:35:14 -0800 (PST)
view release on metacpan or search on metacpan
lib/Gantry/Utils/PerlbalFixup.pm view on Meta::CPAN
use strict;
sub handler {
my $r = shift;
$r->connection->remote_ip( $r->header_in('X-Forwarded-For') )
if $r->header_in('X-Forwarded-For') ne "";
return 1;
}
1;
lib/Gantry/Utils/PerlbalFixup.pm view on Meta::CPAN
#can be any Perl*Handler
PerlInitHandler Gantry::Utils::PerlbalFixup
=head1 DESCRIPTION
This module will set the proper client ip using the X-Forwarded-For header
which is set by Perlbal and other proxy methods. This module should be loaded
at the PerlInitHandler or PerlReadParseHeaders phase during the request life-
cycle
=head1 METHODS
=head2 handler
The apache fixup handler. Stores the value of the X-Forwarded-For header
in the remote_ip of the request's connection, so apps behind a perlbal proxy
can tell who their client is.
=head1 SEE ALSO
view release on metacpan or search on metacpan
lib/DBI/Gofer/Transport/mod_perl.pm view on Meta::CPAN
my ($frozen_response, $response, $response_serializer);
my $executor;
my $http_status = SERVER_ERROR;
my $remote_ip = $headers_in->{Client_ip} # e.g., cisco load balancer
|| $headers_in->{'X-Forwarded-For'} # e.g., mod_proxy (XXX may contain more than one ip)
|| $r->connection->remote_ip;
eval {
$executor = $self->executor_for_apache_request($r);
view release on metacpan or search on metacpan
lib/Grimlock.pm view on Meta::CPAN
error_log /var/log/nginx/error.log;
location / {
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://localhost:5000/;
}
location /static {
root /path/to/grimlock.me;
view release on metacpan or search on metacpan
lib/HTTP/Promise/Headers.pm view on Meta::CPAN
sub x_content_type_options { return( shift->_set_get_one( 'X-Content-Type-Options', @_ ) ); }
# <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-DNS-Prefetch-Control>
sub x_dns_prefetch_control { return( shift->_set_get_one( 'X-DNS-Prefetch-Control', @_ ) ); }
# <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For>
sub x_forwarded_for { return( shift->_set_get_one( 'X-Forwarded-For', @_ ) ); }
# <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Host>
sub x_forwarded_host { return( shift->_set_get_one( 'X-Forwarded-Host', @_ ) ); }
# <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto>
lib/HTTP/Promise/Headers.pm view on Meta::CPAN
See also L<Mozilla documentation|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-DNS-Prefetch-Control>
=head2 x_forwarded_for
This sets or gets the C<X-Forwarded-For> header value. It takes a string value.
Example:
X-Forwarded-For: 2001:db8:85a3:8d3:1319:8a2e:370:7348
X-Forwarded-For: 203.0.113.195
X-Forwarded-For: 203.0.113.195, 2001:db8:85a3:8d3:1319:8a2e:370:7348
See also L</host>, L</forwarded>, L</x_forwarded_host>, L</x_forwarded_proto>, L<Mozilla documentation|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For>
=head2 x_forwarded_host
This sets or gets the C<X-Forwarded-Host> header value. It takes a string value.
view release on metacpan or search on metacpan
lib/HTTP/Proxy.pm view on Meta::CPAN
The content of the Via: header. Setting it to an empty string will
prevent its addition. (default: C<$hostname (HTTP::Proxy/$VERSION)>)
=item x_forwarded_for
If set to a true value, the proxy will send the C<X-Forwarded-For:> header.
(default: true)
=back
=head2 Connection handling methods
view release on metacpan or search on metacpan
t/parse-cgi.t view on Meta::CPAN
use HTTP::Response::CGI;
# Example test values.
my @headers = (
'Content-type: text/html',
'X-Forwarded-For: 127.0.0.1',
);
my $body = 'This is the body.';
my $output;
my $response;
view release on metacpan or search on metacpan
lib/Haineko/HTTPD.pm view on Meta::CPAN
}
if( ref $mesg eq 'HASH' ) {
# Respond as a JSON
require Haineko::SMTPD::Session;
my $addr = [ split( ',', $self->req->header('X-Forwarded-For') || q() ) ];
my $sess = Haineko::SMTPD::Session->new(
'referer' => $self->req->referer // undef,
'response' => [ $mesg ],
'remoteaddr' => pop @$addr || $self->req->address // undef,
'remoteport' => $self->req->env->{'REMOTE_ADDR'} // undef,
view release on metacpan or search on metacpan
share/templates/suricata_outputs.tt view on Meta::CPAN
community-id-seed: 0
xff:
enabled: yes
mode: extra-data
deployment: reverse
header: X-Forwarded-For
types:
- alert:
payload: yes
payload-buffer-size: 64kb
packet: yes
share/templates/suricata_outputs.tt view on Meta::CPAN
level: Info
xff:
enabled: yes
mode: extra-data
deployment: reverse
header: X-Forwarded-For
pcap-file: false
community-id: false
community-id-seed: 0
types:
- http:
share/templates/suricata_outputs.tt view on Meta::CPAN
force-hash: [sha1, md5]
xff:
enabled: no
mode: extra-data
deployment: reverse
header: X-Forwarded-For
[% END %]
##
## regular files
##
share/templates/suricata_outputs.tt view on Meta::CPAN
community-id-seed: 0
xff:
enabled: yes
mode: extra-data
deployment: reverse
header: X-Forwarded-For
types:
- alert:
payload: yes
payload-buffer-size: 64kb
packet: 'yes'
share/templates/suricata_outputs.tt view on Meta::CPAN
filename: /var/log/suricata/flows/current/http.json
xff:
enabled: yes
mode: extra-data
deployment: reverse
header: X-Forwarded-For
pcap-file: false
community-id: false
community-id-seed: 0
types:
- http:
view release on metacpan or search on metacpan
lib/Jifty/Plugin/AccessLog.pm view on Meta::CPAN
The file to log to; defaults to F<log/access_log>.
=item respect_proxy
If set to a true value, will display the C<X-Forwarded-For> header as
the originating IP of requests.
=item format
The format string to use when logging. This module attempts to be as
lib/Jifty/Plugin/AccessLog.pm view on Meta::CPAN
}
};
my %ESCAPES = (
'%' => sub { '%' },
a => sub { ($self->respect_proxy && $r->header("X-Forwarded-For")) || $r->address },
C => sub { my $c = { CGI::Cookie->fetch() }->{+shift}; $c ? $c->value : undef },
D => sub { sprintf "%.3fms", (Time::HiRes::time - $self->start)*1000 },
e => sub { $r->env->{+shift} },
h => sub { ($self->respect_proxy && $r->header("X-Forwarded-For")) || $r->remote_host || $r->address },
i => sub { $r->header(shift) },
l => sub { substr( Jifty->web->session->id || '-', 0, 8 ) },
m => sub { $r->method },
n => sub { $r->template_argument($_[0]) || $r->argument($_[0]) },
o => sub { Jifty->web->response->header(shift) },
view release on metacpan or search on metacpan
lib/Lemonldap/NG/Handler/Lib/AuthBasic.pm view on Meta::CPAN
# Send a create session request to the Portal
# @return true if the session is created, else false
sub createSession {
my ( $class, $req, $id ) = @_;
# Add client IP as X-Forwarded-For IP in request
my $xheader = $req->env->{'HTTP_X_FORWARDED_FOR'};
$xheader .= ", " if ($xheader);
$xheader .= $req->address;
#my $soapHeaders = HTTP::Headers->new( "X-Forwarded-For" => $xheader );
## TODO: use adminSession or sessions
#my $soapClient = SOAP::Lite->proxy(
# $class->tsv->{portal}->() . '/sessions',
# default_headers => $soapHeaders
#)->uri('urn:Lemonldap/NG/Common/PSGI/SOAPService');
lib/Lemonldap/NG/Handler/Lib/AuthBasic.pm view on Meta::CPAN
#my $soapRequest = $soapClient->getCookies( $user, $pwd, $id );
my $url = $class->tsv->{portal}->($req) . "/sessions/global/$id?auth";
$url =~ s#//sessions/#/sessions/#g;
my $get = HTTP::Request->new( POST => $url );
$get->header( 'X-Forwarded-For' => $xheader );
$get->header( 'Content-Type' => 'application/x-www-form-urlencoded' );
$get->header( Accept => 'application/json' );
$get->content(
build_urlencoded(
user => $user,
view release on metacpan or search on metacpan
lib/MVC/Neaf/Request.pm view on Meta::CPAN
# Should we join them all? Maybe...
=head2 client_ip()
Returns the IP of the client.
If C<X-Forwarded-For> header is set, returns that instead.
=cut
sub client_ip {
my $self = shift;
return $self->{client_ip} ||= do {
my @fwd = $self->header_in( 'X-Forwarded-For', '.*' );
@fwd == 1 && $fwd[0] || $self->do_get_client_ip || "127.0.0.1";
};
};
=head2 http_version()
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/BlogSpam.pm view on Meta::CPAN
use Mojo::IOLoop;
use Scalar::Util 'weaken';
our $VERSION = '0.12';
# TODO: X-Forwarded-For in Config per index steuern
# TODO: - Check for blacklist/whitelist/max words etc. yourself.
# - Create a route condition for posts.
# -> $r->post('/comment')->over('blogspam')->to('#');
our @OPTION_ARRAY =
lib/Mojolicious/Plugin/BlogSpam.pm view on Meta::CPAN
# No ip manually given
unless ($obj->ip) {
# Get forwarded ip
if (my $ip = $headers->to_hash->{'X-Forwarded-For'}) {
$obj->ip( split(/\s*,\s*/, $ip) );
};
# Get host ip, because X-Forwarded-For wasn't set
unless ($obj->ip) {
$obj->ip( split(/\s*:\s*/, ($headers->host || '')) );
};
};
lib/Mojolicious/Plugin/BlogSpam.pm view on Meta::CPAN
$bs->ip('192.168.0.1');
my $ip = $bs->ip;
The ip address of the commenter.
Defaults to the ip address of the request.
Supports C<X-Forwarded-For> proxy information.
=head2 link
$bs->link('http://grimms-abenteuer.de/');
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/CGI.pm view on Meta::CPAN
.----------------------------------------.
| Header | Variable |
|-----------------|----------------------|
| Referer | HTTP_REFERER |
| User-Agent | HTTP_USER_AGENT |
| X-Forwarded-For | HTTP_X_FORWARDED_FOR |
'----------------------------------------'
=head2 register
$self->register($app, [ $route => $script ]);
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/ClientIP/Pluggable.pm view on Meta::CPAN
allows to specify different HTTP-headers (and their priorities) for client IP address
extraction. This is needed as different cloud providers set different headers to disclose
real IP address.
If the address cannot be extracted from headers different fallback options are available:
detect IP address from C<X-Forwarded-For> header, detect IP address from C<forwarded> header
(rfc-7239), or use C<remote_address> environment.
The plugin is inspired by L<Mojolicious::Plugin::ClientIP>.
=head1 METHODS
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/ClientIP.pm view on Meta::CPAN
state $key = '__plugin_clientip_ip';
return $c->stash($key) if $c->stash($key);
my $xff = $c->req->headers->header('X-Forwarded-For') // '';
my @candidates = reverse grep { $_ } split /,\s*/, $xff;
my $ip = $self->_find(\@candidates) // $c->tx->remote_address;
$c->stash($key => $ip);
return $ip;
lib/Mojolicious/Plugin/ClientIP.pm view on Meta::CPAN
=encoding utf-8
=head1 NAME
Mojolicious::Plugin::ClientIP - Get client's IP address from X-Forwarded-For
=head1 SYNOPSIS
use Mojolicious::Lite;
lib/Mojolicious/Plugin/ClientIP.pm view on Meta::CPAN
app->start;
=head1 DESCRIPTION
Mojolicious::Plugin::ClientIP is a Mojolicious plugin to get an IP address looks like client, not proxy, from X-Forwarded-For header.
=head1 METHODS
=head2 client_ip
Find a client IP address from X-Forwarded-For. Private network addresses in XFF are ignored by default. If the good IP address is not found, it returns Mojo::Transaction#remote_address.
=head1 OPTIONS
=head2 ignore
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/ForwardedFor.pm view on Meta::CPAN
die "Invalid reverse proxy 'levels' for ForwardedFor: $err" if defined $err;
$app->helper(forwarded_for => sub {
my $c = shift;
return $c->tx->original_remote_address unless $levels > 0;
my @addresses = split /\s*,\s*/, trim($c->tx->req->headers->header('X-Forwarded-For') // '');
return $addresses[-$levels] // $addresses[0] // $c->tx->original_remote_address;
});
}
1;
=head1 NAME
Mojolicious::Plugin::ForwardedFor - Retrieve the remote address from X-Forwarded-For
=head1 SYNOPSIS
use Mojolicious::Lite;
plugin ForwardedFor => {levels => 2}; # number of reverse proxies you control
lib/Mojolicious/Plugin/ForwardedFor.pm view on Meta::CPAN
L<Mojolicious> supports deployment via a
L<reverse proxy|Mojolicious::Guides::Cookbook/"Reverse proxy"> setup by
specifying the L<proxy|Mojo::Server::Hypnotoad/"proxy"> configuration option
for Hypnotoad, or the C<MOJO_REVERSE_PROXY> environment variable. However,
L<Mojo::Transaction/"remote_address"> will in this case only return the most
recent address from the C<X-Forwarded-For> header, as it cannot automatically
determine how many remote addresses correspond to proxies.
L<Mojolicious::Plugin::ForwardedFor> can be configured with the number of
reverse proxy L</"levels"> that you control, and provides a L</"forwarded_for">
helper method that will return the remote address at that level. It is
important to set L</"levels"> no higher than the number of proxies that will
have appended addresses to the C<X-Forwarded-For> header, as the original
requests can pass anything as the initial value of the header, and thus spoof
additional proxy levels.
Since Mojolicious 8.72, you can configure
L<Mojo::Server::Hypnotoad/"trusted_proxies"> as a more reliable alternative to
lib/Mojolicious/Plugin/ForwardedFor.pm view on Meta::CPAN
=head2 forwarded_for
my $remote_addr = $c->forwarded_for;
Returns the least recently appended remote address from the C<X-Forwarded-For>
header, while skipping no more than the configured number of reverse proxy
L</"levels">. Returns the originating address of the current request if
configured for 0 reverse proxy levels, or if no addresses have been appended to
the header.
lib/Mojolicious/Plugin/ForwardedFor.pm view on Meta::CPAN
=over 4
=item levels
Number of remote proxy levels to allow for when parsing C<X-Forwarded-For>.
Defaults to the value of the C<MOJO_REVERSE_PROXY> environment variable, or 1.
=back
=head1 BUGS
view release on metacpan or search on metacpan
local $ENV{MOJO_REVERSE_PROXY} = 1;
my $t = Test::Mojo->new;
$t->get_ok('/', {'X-Forwarded-For' => '176.9.54.163'})
->status_is(200)
->json_is('/city/names/en' => 'Falkenstein')
->json_is('/country/names/en' => 'Germany');
$t->get_ok('/176.9.54.163')
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/OpenTelemetry.pod view on Meta::CPAN
=item C<client.address>
Set to the
L<remote address of the transaction|Mojo::Transaction/remote_address>. This
will respect the value set in the C<X-Forwarded-For> header, if any.
=item C<client.port>
Set to the L<remote port of the transaction|Mojo::Transaction/remote_port>.
view release on metacpan or search on metacpan
lib/Mojo/Server/Hypnotoad.pm view on Meta::CPAN
=head2 proxy
proxy => 1
Activate reverse proxy support, which allows for the C<X-Forwarded-For> and C<X-Forwarded-Proto> headers to be picked
up automatically, defaults to the value of L<Mojo::Server/"reverse_proxy">.
=head2 requests
requests => 50