X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FRequest.pm;h=57b328c45b573dee94fcae9a9ab1e611107e55b6;hb=refs%2Fheads%2Fref-util;hp=c0d9fcaf2ecdc2ffcbaeddc2d82d756465467015;hpb=ac1cf8d417b2f21cfd997b8cc7756e2bb36dedc7;p=catagits%2FCatalyst-Runtime.git

diff --git a/lib/Catalyst/Request.pm b/lib/Catalyst/Request.pm
index c0d9fca..57b328c 100644
--- a/lib/Catalyst/Request.pm
+++ b/lib/Catalyst/Request.pm
@@ -12,7 +12,9 @@ use Hash::MultiValue;
 use Scalar::Util;
 use HTTP::Body;
 use Catalyst::Exception;
+use Catalyst::Request::PartData;
 use Moose;
+use Ref::Util qw(is_plain_arrayref is_plain_hashref);
 
 use namespace::clean -except => 'meta';
 
@@ -179,6 +181,7 @@ has body_parameters => (
   is => 'rw',
   required => 1,
   lazy => 1,
+  predicate => 'has_body_parameters',
   builder => 'prepare_body_parameters',
 );
 
@@ -222,15 +225,15 @@ sub _build_parameters {
     # We copy, no references
     foreach my $name (keys %$query_parameters) {
         my $param = $query_parameters->{$name};
-        $parameters->{$name} = ref $param eq 'ARRAY' ? [ @$param ] : $param;
+        $parameters->{$name} = is_plain_arrayref($param) ? [ @$param ] : $param;
     }
 
     # Merge query and body parameters
     foreach my $name (keys %$body_parameters) {
         my $param = $body_parameters->{$name};
-        my @values = ref $param eq 'ARRAY' ? @$param : ($param);
+        my @values = is_plain_arrayref($param) ? @$param : ($param);
         if ( my $existing = $parameters->{$name} ) {
-          unshift(@values, (ref $existing eq 'ARRAY' ? @$existing : $existing));
+          unshift(@values, (is_plain_arrayref($existing) ? @$existing : $existing));
         }
         $parameters->{$name} = @values > 1 ? \@values : $values[0];
     }
@@ -291,7 +294,10 @@ sub prepare_body {
     # 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
@@ -318,36 +324,59 @@ sub prepare_body_chunk {
 
 sub prepare_body_parameters {
     my ( $self, $c ) = @_;
-
+    return $self->body_parameters if $self->has_body_parameters;
     $self->prepare_body if ! $self->_has_body;
 
     unless($self->_body) {
-      return $self->_use_hash_multivalue ? Hash::MultiValue->new : {};
+      my $return = $self->_use_hash_multivalue ? Hash::MultiValue->new : {};
+      $self->body_parameters($return);
+      return $return;
     }
 
-    my $params = $self->_body->param;
+    my $params;
+    my %part_data = %{$self->_body->part_data};
+    if(scalar %part_data && !$c->config->{skip_complex_post_part_handling}) {
+      foreach my $key (keys %part_data) {
+        my $proto_value = $part_data{$key};
+        my ($val, @extra) = is_plain_arrayref($proto_value) ? @$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($c, $_) } ($val,@extra)];
+        } else {
+          $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) {
+      if($c and $c->encoding and !$c->config->{skip_body_param_unicode_decoding}) {
         $params = $c->_handle_unicode_decoding($params);
+      }
     }
 
-    return $self->_use_hash_multivalue ?
+    my $return = $self->_use_hash_multivalue ?
         Hash::MultiValue->from_mixed($params) :
         $params;
+
+    $self->body_parameters($return) unless $self->has_body_parameters;
+    return $return;
 }
 
 sub prepare_connection {
@@ -531,7 +560,7 @@ If the POST is malformed in some way (such as undefined or not content that
 matches the content-type) we raise a L<Catalyst::Exception> with the error
 text as the message.
 
-If the POSTed content type does not match an availabled data handler, this
+If the POSTed content type does not match an available data handler, this
 will also raise an exception.
 
 =head2 $req->body_parameters
@@ -544,6 +573,16 @@ be either a scalar or an arrayref containing scalars.
 
 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 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.
@@ -683,7 +722,7 @@ Basically this is an exploit that takes advantage of how L<\param> will do one t
 in scalar context and another thing in list context.  This is combined with how Perl
 chooses to deal with duplicate keys in a hash definition by overwriting the value of
 existing keys with a new value if the same key shows up again.  Generally you will be
-vulnerale to this exploit if you are using this method in a direct assignment in a
+vulnerable to this exploit if you are using this method in a direct assignment in a
 hash, such as with a L<DBIx::Class> create statement.  For example, if you have
 parameters like:
 
@@ -745,7 +784,7 @@ sub param {
             return wantarray ? () : undef;
         }
 
-        if ( ref $self->parameters->{$param} eq 'ARRAY' ) {
+        if ( is_plain_arrayref($self->parameters->{$param}) ) {
             return (wantarray)
               ? @{ $self->parameters->{$param} }
               : $self->parameters->{$param}->[0];
@@ -887,7 +926,7 @@ sub upload {
             return wantarray ? () : undef;
         }
 
-        if ( ref $self->uploads->{$upload} eq 'ARRAY' ) {
+        if ( is_plain_arrayref($self->uploads->{$upload}) ) {
             return (wantarray)
               ? @{ $self->uploads->{$upload} }
               : $self->uploads->{$upload}->[0];
@@ -905,7 +944,7 @@ sub upload {
 
             if ( exists $self->uploads->{$field} ) {
                 for ( $self->uploads->{$field} ) {
-                    $_ = [$_] unless ref($_) eq "ARRAY";
+                    $_ = [$_] unless is_plain_arrayref($_);
                     push( @$_, $upload );
                 }
             }
@@ -961,7 +1000,7 @@ sub mangle_params {
 
     foreach my $value ( values %$args ) {
         next unless defined $value;
-        for ( ref $value eq 'ARRAY' ? @$value : $value ) {
+        for ( is_plain_arrayref($value) ? @$value : $value ) {
             $_ = "$_";
             #      utf8::encode($_);
         }
@@ -978,8 +1017,8 @@ sub mangle_params {
                 # an existing one regardless if the existing value is an array
                 # or not, and regardless if the new value is an array or not
                 $params{$key} = [
-                    ref($params{$key}) eq 'ARRAY' ? @{ $params{$key} } : $params{$key},
-                    ref($val) eq 'ARRAY' ? @{ $val } : $val
+                    is_plain_arrayref($params{$key}) ? @{ $params{$key} } : $params{$key},
+                    is_plain_arrayref($val) ? @{ $val } : $val
                 ];
 
             } else {
@@ -1018,7 +1057,7 @@ sub uri_with {
     carp( 'No arguments passed to uri_with()' ) unless $args;
 
     my $append = 0;
-    if((ref($behavior) eq 'HASH') && defined($behavior->{mode}) && ($behavior->{mode} eq 'append')) {
+    if(is_plain_hashref($behavior) && defined($behavior->{mode}) && ($behavior->{mode} eq 'append')) {
         $append = 1;
     }