X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst%2FEngine.pm;h=150c269f78eba183c19a8f3dd1599d9888391f1e;hp=56e5b1d259676a7fd0c132d7b1abb0c8b17e17b1;hb=103f2d968b5a1a732c19c39ae03cdd9a44a96a4b;hpb=08680694151d666fc2f69c54065e2aa09e175742 diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm index 56e5b1d..150c269 100644 --- a/lib/Catalyst/Engine.pm +++ b/lib/Catalyst/Engine.pm @@ -7,21 +7,37 @@ use CGI::Simple::Cookie; use Data::Dump qw/dump/; use Errno 'EWOULDBLOCK'; use HTML::Entities; -use HTTP::Body; use HTTP::Headers; -use URI::QueryParam; use Plack::Loader; use Catalyst::EngineLoader; -use Encode (); +use Encode 2.21 'decode_utf8', 'encode', 'decode'; use Plack::Request::Upload; use Hash::MultiValue; -use utf8; - use namespace::clean -except => 'meta'; +use utf8; # Amount of data to read from input on each pass our $CHUNKSIZE = 64 * 1024; +# XXX - this is only here for compat, do not use! +has env => ( is => 'rw', writer => '_set_env' , weak_ref=>1); +my $WARN_ABOUT_ENV = 0; +around env => sub { + my ($orig, $self, @args) = @_; + if(@args) { + warn "env as a writer is deprecated, you probably need to upgrade Catalyst::Engine::PSGI" + unless $WARN_ABOUT_ENV++; + return $self->_set_env(@args); + } + return $self->$orig; +}; + +# XXX - Only here for Engine::PSGI compat +sub prepare_connection { + my ($self, $ctx) = @_; + $ctx->request->prepare_connection; +} + =head1 NAME Catalyst::Engine - The Catalyst Engine @@ -114,7 +130,6 @@ sub finalize_body { # There's no body... $body = []; } - $res->_response_cb->([ $res->status, \@headers, $body]); $res->_clear_response_cb; @@ -144,11 +159,11 @@ sub finalize_body { } else { - # Case where body was set afgter calling ->write. We'd prefer not to + # Case where body was set after calling ->write. We'd prefer not to # support this, but I can see some use cases with the way most of the - # views work. - - $self->write($c, $body ); + # views work. Since body has already been encoded, we need to do + # an 'unencoded_write' here. + $self->unencoded_write( $c, $body ); } } @@ -558,15 +573,21 @@ process the query string and extract query parameters. sub prepare_query_parameters { my ($self, $c) = @_; my $env = $c->request->env; + my $do_not_decode_query = $c->config->{do_not_decode_query}; - if(my $query_obj = $env->{'plack.request.query'}) { - $c->request->query_parameters( - $c->request->_use_hash_multivalue ? - $query_obj->clone : - $query_obj->as_hashref_mixed); - return; + my $old_encoding; + if(my $new = $c->config->{default_query_encoding}) { + $old_encoding = $c->encoding; + $c->encoding($new); } + my $check = $c->config->{do_not_check_query_encoding} ? undef :$c->_encode_check; + my $decoder = sub { + my $str = shift; + return $str if $do_not_decode_query; + return $c->_handle_param_unicode_decoding($str, $check); + }; + my $query_string = exists $env->{QUERY_STRING} ? $env->{QUERY_STRING} : ''; @@ -574,42 +595,22 @@ sub prepare_query_parameters { # Check for keywords (no = signs) # (yes, index() is faster than a regex :)) if ( index( $query_string, '=' ) < 0 ) { - $c->request->query_keywords($self->unescape_uri($query_string)); + my $keywords = $self->unescape_uri($query_string); + $keywords = $decoder->($keywords); + $c->request->query_keywords($keywords); return; } - my %query; - - # replace semi-colons - $query_string =~ s/;/&/g; - - my @params = grep { length $_ } split /&/, $query_string; + $query_string =~ s/\A[&;]+//; - for my $item ( @params ) { + my $p = Hash::MultiValue->new( + map { defined $_ ? $decoder->($self->unescape_uri($_)) : $_ } + map { ( split /=/, $_, 2 )[0,1] } # slice forces two elements + split /[&;]+/, $query_string + ); - my ($param, $value) - = map { $self->unescape_uri($_) } - split( /=/, $item, 2 ); - - $param = $self->unescape_uri($item) unless defined $param; - - if ( exists $query{$param} ) { - if ( ref $query{$param} ) { - push @{ $query{$param} }, $value; - } - else { - $query{$param} = [ $query{$param}, $value ]; - } - } - else { - $query{$param} = $value; - } - } - - $c->request->query_parameters( - $c->request->_use_hash_multivalue ? - Hash::MultiValue->from_mixed(\%query) : - \%query); + $c->encoding($old_encoding) if $old_encoding; + $c->request->query_parameters( $c->request->_use_hash_multivalue ? $p : $p->mixed ); } =head2 $self->prepare_read($c) @@ -635,6 +636,7 @@ sub prepare_request { my ($self, $ctx, %args) = @_; $ctx->log->psgienv($args{env}) if $ctx->log->can('psgienv'); $ctx->request->_set_env($args{env}); + $self->_set_env($args{env}); # Nasty back compat! $ctx->response->_set_response_cb($args{response_cb}); } @@ -648,20 +650,26 @@ sub prepare_uploads { my $request = $c->request; return unless $request->_body; + my $enc = $c->encoding; my $uploads = $request->_body->upload; my $parameters = $request->parameters; foreach my $name (keys %$uploads) { my $files = $uploads->{$name}; + $name = $c->_handle_unicode_decoding($name) if $enc; my @uploads; for my $upload (ref $files eq 'ARRAY' ? @$files : ($files)) { my $headers = HTTP::Headers->new( %{ $upload->{headers} } ); + my $filename = $upload->{filename}; + $filename = $c->_handle_unicode_decoding($filename) if $enc; + my $u = Catalyst::Request::Upload->new ( size => $upload->{size}, type => scalar $headers->content_type, + charset => scalar $headers->content_type_charset, headers => $headers, tempname => $upload->{tempname}, - filename => $upload->{filename}, + filename => $filename, ); push @uploads, $u; } @@ -696,6 +704,20 @@ sub write { $c->response->write($buffer); } +=head2 $self->unencoded_write($c, $buffer) + +Writes the buffer to the client without encoding. Necessary for +already encoded buffers. Used when a $c->write has been done +followed by $c->res->body. + +=cut + +sub unencoded_write { + my ( $self, $c, $buffer ) = @_; + + $c->response->unencoded_write($buffer); +} + =head2 $self->read($c, [$maxlength]) Reads from the input stream by calling C<< $self->read_chunk >>.