sourCEntral - mobile manpages




Plack::Request − Portable HTTP request object from PSGI env hash


  use Plack::Request;
  my $app_or_middleware = sub {
      my $env = shift; # PSGI env
      my $req = Plack::Request−>new($env);
      my $path_info = $req−>path_info;
      my $query     = $req−>param('query');
      my $res = $req−>new_response(200); # new Plack::Response





Writing your web application directly using Plack::Request is certainly possible but not recommended: it’s like doing so with mod_perl’s Apache::Request: yet too low level.

If you’re writing a web application, not a framework, then you’re encouraged to use one of the web application frameworks that support PSGI (<>), or see modules like HTTP::Engine to provide higher level Request and Response API on top of PSGI .



Unless otherwise noted, all methods and attributes are read-only, and passing values to the method like an accessor doesn’t work like you expect it to.


    Plack::Request−>new( $env );

Creates a new request object.





Returns the IP address of the client ("REMOTE_ADDR").


Returns the remote host ("REMOTE_HOST") of the client. It may be empty, in which case you have to get the IP address using "address" method and resolve on your own.


Contains the request method ("GET", "POST", "HEAD", etc).


Returns the protocol ( HTTP/1 .0 or HTTP/1 .1) used for the current request.






Similar to "path_info" but returns "/" in case it is empty. In other words, it returns the virtual path of the request URI after "$req−>base". See " DISPATCHING " for details.




Returns the scheme ("http" or "https") of the request.



body, input

Returns "psgi.input" handle.


Returns (optional) "psgix.session" hash. When it exists, you can retrieve and store per-session data from and to this hash.


Returns (optional) "psgix.session.options" hash.


Returns (optional) "psgix.logger" code reference. When it exists, your application is supposed to send the log message to this logger, using:

  $req−>logger−>({ level => 'debug', message => "This is a debug message" });






Returns a reference to a hash containing posted parameters in the request body ( POST ). As with "query_parameters", the hash reference is a Hash::MultiValue object.



content, raw_body



Returns an URI object for the current request. The URI is constructed using various environment values such as "SCRIPT_NAME", "PATH_INFO", "QUERY_STRING", "HTTP_HOST", "SERVER_NAME" and "SERVER_PORT".



Returns an URI object for the base path of current request. This is like "uri" but only contains up to "SCRIPT_NAME" where your application is hosted at.



Returns "REMOTE_USER" if it’s set.






Shortcut to $req−>headers−>content_encoding.


Shortcut to $req−>headers−>content_length.


Shortcut to $req−>headers−>content_type.


Shortcut to $req−>headers−>header.


Shortcut to $req−>headers−>referer.


Shortcut to $req−>headers−>user_agent.


Returns GET and POST parameters with a CGI .pm−compatible param method. This is an alternative method for accessing parameters in $req−>parameters. Unlike CGI .pm, it does not allow setting or modifying query parameters.

    $value  = $req−>param( 'foo' );
    @values = $req−>param( 'foo' );
    @params = $req−>param;


A convenient method to access $req−>uploads.

    $upload  = $req−>upload('field');
    @uploads = $req−>upload('field');
    @fields  = $req−>upload;
    for my $upload ( $req−>upload('field') ) {
        print $upload−>filename;


  my $res = $req−>new_response;


Hash::MultiValue parameters
Parameters that can take one or multiple values (i.e. "parameters", "query_parameters", "body_parameters" and "uploads") store the hash reference as a Hash::MultiValue object. This means you can use the hash reference as a plain hash where values are always scalars ( NOT array references), so you don’t need to code ugly and unsafe "ref ... eq 'ARRAY'" anymore.

And if you explicitly want to get multiple values of the same key, you can call the "get_all" method on it, such as:

  my @foo = $req−>query_parameters−>get_all('foo');

You can also call "get_one" to always get one parameter independent of the context (unlike "param"), and even call "mixed" (with Hash::MultiValue 0.05 or later) to get the traditional hash reference,

  my $params = $req−>parameters−>mixed;


The methods to parse request body ("content", "body_parameters" and "uploads") are carefully coded to save the parsed body in the environment hash as well as in the temporary buffer, so you can call them multiple times and create Plack::Request objects multiple times in a request and they should work safely, and won’t parse request body more than twice for the efficiency.


If your application or framework wants to dispatch (or route) actions based on request paths, be sure to use "$req−>path_info" not "$req−>uri−>path".

This is because "path_info" gives you the virtual path of the request, regardless of how your application is mounted. If your application is hosted with mod_perl or CGI scripts, or even multiplexed with tools like Plack::App::URLMap, request’s "path_info" always gives you the action path.

Note that "path_info" might give you an empty string, in which case you should assume that the path is "/".

You will also want to use "$req−>base" as a base prefix when building URLs in your templates or in redirections. It’s a good idea for you to subclass Plack::Request and define methods such as:

  sub uri_for {
      my $uri = $self−>base;
      $uri−>path($uri−>path . $path);
      $uri−>query_form(@$args) if $args;

So you can say:

  my $link = $req−>uri_for('/logout', [ signoff => 1 ]);

and if "$req−>base" is "/app" you’ll get the full URI for "/app/logout?signoff=1".



All parameter-related methods such as "parameters", "body_parameters", "query_parameters" and "uploads" now contains Hash::MultiValue objects, rather than scalar or an array reference depending on the user input which is insecure. See Hash::MultiValue for more about this change.

"$req−>path" method had a bug, where the code and the document was mismatching. The document was suggesting it returns the sub request path after "$req−>base" but the code was always returning the absolute URI path. The code is now updated to be an alias of "$req−>path_info" but returns "/" in case it’s empty. If you need the older behavior, just call "$req−>uri−>path" instead.

Cookie handling is simplified, and doesn’t use CGI::Simple::Cookie anymore, which means you CAN NOT set array reference or hash reference as a cookie value and expect it be serialized. You’re always required to set string value, and encoding or decoding them is totally up to your application or framework. Also, "cookies" hash reference now returns strings for the cookies rather than CGI::Simple::Cookie objects, which means you no longer have to write a wacky code such as:

  $v = $req−>cookie−>{foo} ? $req−>cookie−>{foo}−>value : undef;

and instead, simply do:

  $v = $req−>cookie−>{foo};


Tatsuhiko Miyagawa

Kazuhiro Osawa

Tokuhiro Matsuno



