package Catalyst::Request;
-use IO::Socket qw[AF_INET inet_aton];
+use Socket qw( getaddrinfo getnameinfo AI_NUMERICHOST NI_NAMEREQD NIx_NOSERV );
use Carp;
use utf8;
use URI::http;
# Not sure if these returns should not be exceptions...
my $content_type = $self->content_type || return;
- return unless ($self->method eq 'POST' || $self->method eq 'PUT');
+ return unless ($self->method eq 'POST' || $self->method eq 'PUT' || $self->method eq 'PATCH');
my ($match) = grep { $content_type =~/$_/i }
keys(%{$self->data_handlers});
my $fh = $self->body;
local $_ = $fh;
return $self->data_handlers->{$match}->($fh, $self);
- } else {
- Catalyst::Exception->throw("$content_type is does not have an available data handler");
+ } else {
+ Catalyst::Exception->throw(
+ sprintf '%s does not have an available data handler. Valid data_handlers are %s.',
+ $content_type, join ', ', sort keys %{$self->data_handlers}
+ );
}
}
has _use_hash_multivalue => (
- is=>'ro',
- required=>1,
+ is=>'ro',
+ required=>1,
default=> sub {0});
# Amount of data to read from input on each pass
my ( $self ) = @_;
# If previously applied middleware created the HTTP::Body object, then we
- # just use that one.
+ # just use that one.
if(my $plack_body = $self->_has_env ? $self->env->{'plack.request.http.body'} : undef) {
$self->_body($plack_body);
# Ok if we get this far, we have to read psgi.input into the new body
# object. Lets play nice with any plack app or other downstream, so
# we create a buffer unless one exists.
-
+
my $stream_buffer;
if ($self->env->{'psgix.input.buffered'}) {
# Be paranoid about previous psgi middleware or apps that read the
# Check for definedness as you could read '0'
while ( defined ( my $chunk = $self->read() ) ) {
$self->prepare_body_chunk($chunk);
- $stream_buffer->print($chunk) if $stream_buffer;
+ next unless $stream_buffer;
+
+ $stream_buffer->print($chunk)
+ || die sprintf "Failed to write %d bytes to psgi.input file: $!", length( $chunk );
}
# Ok, we read the body. Lets play nice for any PSGI app down the pipe
my $proto_value = $part_data{$key};
my ($val, @extra) = (ref($proto_value)||'') eq 'ARRAY' ? @$proto_value : ($proto_value);
+ $key = $c->_handle_param_unicode_decoding($key)
+ if ($c and $c->encoding and !$c->config->{skip_body_param_unicode_decoding});
+
if(@extra) {
- $params->{$key} = [map { Catalyst::Request::PartData->build_from_part_data($_) } ($val,@extra)];
+ $params->{$key} = [map { Catalyst::Request::PartData->build_from_part_data($c, $_) } ($val,@extra)];
} else {
- $params->{$key} = Catalyst::Request::PartData->build_from_part_data($val);
+ $params->{$key} = Catalyst::Request::PartData->build_from_part_data($c, $val);
}
}
} else {
$params = $self->_body->param;
- }
- # If we have an encoding configured (like UTF-8) in general we expect a client
- # to POST with the encoding we fufilled the request in. Otherwise don't do any
- # encoding (good change wide chars could be in HTML entity style llike the old
- # days -JNAP
+ # If we have an encoding configured (like UTF-8) in general we expect a client
+ # to POST with the encoding we fufilled the request in. Otherwise don't do any
+ # encoding (good change wide chars could be in HTML entity style llike the old
+ # days -JNAP
- # so, now that HTTP::Body prepared the body params, we gotta 'walk' the structure
- # and do any needed decoding.
+ # so, now that HTTP::Body prepared the body params, we gotta 'walk' the structure
+ # and do any needed decoding.
- # This only does something if the encoding is set via the encoding param. Remember
- # this is assuming the client is not bad and responds with what you provided. In
- # general you can just use utf8 and get away with it.
- #
- # I need to see if $c is here since this also doubles as a builder for the object :(
+ # This only does something if the encoding is set via the encoding param. Remember
+ # this is assuming the client is not bad and responds with what you provided. In
+ # general you can just use utf8 and get away with it.
+ #
+ # I need to see if $c is here since this also doubles as a builder for the object :(
- if($c and $c->encoding and !$c->config->{skip_body_param_unicode_decoding}) {
+ if($c and $c->encoding and !$c->config->{skip_body_param_unicode_decoding}) {
$params = $c->_handle_unicode_decoding($params);
+ }
}
my $return = $self->_use_hash_multivalue ?
has hostname => (
is => 'rw',
- required => 1,
lazy => 1,
default => sub {
my ($self) = @_;
- gethostbyaddr( inet_aton( $self->address ), AF_INET ) || $self->address
+ my ( $err, $sockaddr ) = getaddrinfo(
+ $self->address,
+ # no service
+ '',
+ { flags => AI_NUMERICHOST }
+ );
+ if ( $err ) {
+ $self->_log->warn("resolve of hostname failed: $err");
+ return $self->address;
+ }
+ ( $err, my $hostname ) = getnameinfo(
+ $sockaddr->{addr},
+ NI_NAMEREQD,
+ # we are only interested in the hostname, not the servicename
+ NIx_NOSERV
+ );
+ if ( $err ) {
+ $self->_log->warn("resolve of hostname failed: $err");
+ return $self->address;
+ }
+ return $hostname;
},
);
These are the parameters from the POST part of the request, if any.
B<NOTE> If your POST is multipart, but contains non file upload parts (such
-as an line part with an alternative encoding or content type) we cannot determine
-the correct way to extra a meaningful value from the upload. In this case any
+as an line part with an alternative encoding or content type) we do our best to
+try and figure out how the value should be presented. If there's a specified character
+set we will use that to decode rather than the default encoding set by the application.
+However if there are complex headers and we cannot determine
+the correct way to extra a meaningful value from the upload, in this case any
part like this will be represented as an instance of L<Catalyst::Request::PartData>.
+Patches and review of this part of the code welcomed.
+
=head2 $req->body_params
Shortcut for body_parameters.
# If anything in @_ is undef, carp about that, and remove it from
# the list;
-
+
my @params = grep { defined($_) ? 1 : do {carp "You called ->params with an undefined value"; 0} } @_;
if ( @params == 1 ) {
=head2 $self->env
-Access to the raw PSGI env.
+Access to the raw PSGI env.
=head2 meta