use namespace::clean -except => 'meta';
-our $VERSION = '0.24';
+our $VERSION = '0.33';
+$VERSION = eval $VERSION;
my @session_data_accessors; # used in delete_session
/
);
+sub _session_plugin_config {
+ my $c = shift;
+ # FIXME - Start warning once all the state/store modules have also been updated.
+ #$c->log->warn("Deprecated 'session' config key used, please use the key 'Plugin::Session' instead")
+ # if exists $c->config->{session}
+ #$c->config->{'Plugin::Session'} ||= delete($c->config->{session}) || {};
+ $c->config->{'Plugin::Session'} ||= $c->config->{session} || {};
+}
sub setup {
my $c = shift;
sub setup_session {
my $c = shift;
- my $cfg = ( $c->config->{session} ||= {} );
+ my $cfg = $c->_session_plugin_config;
%$cfg = (
expires => 7200,
sub prepare_action {
my $c = shift;
- if ( $c->config->{session}{flash_to_stash}
+ $c->maybe::next::method(@_);
+
+ if ( $c->_session_plugin_config->{flash_to_stash}
and $c->sessionid
and my $flash_data = $c->flash )
{
@{ $c->stash }{ keys %$flash_data } = values %$flash_data;
}
-
- $c->maybe::next::method(@_);
}
sub finalize_headers {
my $c = shift;
- # fix cookie before we send headers
- $c->_save_session_expires;
+ # Force extension of session_expires before finalizing headers, so a possible cookie will be
+ # up to date. First call to session_expires will extend the expiry, subsequent calls will
+ # just return the previously extended value.
+ $c->session_expires;
return $c->maybe::next::method(@_);
}
$c->maybe::next::method(@_);
+ $c->_save_session_expires;
$c->_save_session_id;
$c->_save_session;
$c->_save_flash;
delete $flash_data->{$key};
}
}
-
+
my $sid = $c->sessionid;
my $session_data = $c->_session;
$c->_session($session_data);
no warnings 'uninitialized'; # ne __address
- if ( $c->config->{session}{verify_address}
+ if ( $c->_session_plugin_config->{verify_address}
+ && exists $session_data->{__address}
&& $session_data->{__address} ne $c->request->address )
{
$c->log->warn(
$c->delete_session("address mismatch");
return;
}
- if ( $c->config->{session}{verify_user_agent}
+ if ( $c->_session_plugin_config->{verify_user_agent}
&& $session_data->{__user_agent} ne $c->request->user_agent )
{
$c->log->warn(
if ( my $flash_data = $c->_flash )
{
$c->_flash_key_hashes({ map { $_ => Object::Signature::signature( \$flash_data->{$_} ) } keys %$flash_data });
-
+
return $flash_data;
}
}
my $sessiondata = $c->session;
my $oldsid = $c->sessionid;
my $newsid = $c->create_session_id;
-
+
if ($oldsid) {
$c->log->debug(qq/change_sessid: deleting session data from "$oldsid"/) if $c->debug;
$c->delete_session_data("${_}:${oldsid}") for qw/session expires flash/;
$c->log->debug(qq/change_sessid: storing session data to "$newsid"/) if $c->debug;
$c->store_session_data( "session:$newsid" => $sessiondata );
- return $newsid;
+ return $newsid;
}
sub delete_session {
sub calculate_initial_session_expires {
my $c = shift;
- return ( time() + $c->config->{session}{expires} );
+ return ( time() + $c->_session_plugin_config->{expires} );
}
sub calculate_extended_session_expires {
sub reset_session_expires {
my ( $c, $sid ) = @_;
-
+
my $exp = $c->calculate_initial_session_expires;
$c->_session_expires( $exp );
+ #
+ # since we're setting _session_expires directly, make load_session_expires
+ # actually use that value.
+ #
+ $c->_tried_loading_session_expires(1);
$c->_extended_session_expires( $exp );
$exp;
}
sub sessionid {
my $c = shift;
-
+
return $c->_sessionid || $c->_load_sessionid;
}
sub session {
my $c = shift;
- $c->_session || $c->_load_session || do {
+ my $session = $c->_session || $c->_load_session || do {
$c->create_session_id_if_needed;
$c->initialize_session_data;
};
+
+ if (@_) {
+ my $new_values = @_ > 1 ? { @_ } : $_[0];
+ croak('session takes a hash or hashref') unless ref $new_values;
+
+ for my $key (keys %$new_values) {
+ $session->{$key} = $new_values->{$key};
+ }
+ }
+
+ $session;
}
sub keep_flash {
(@{$href}{@keys}) = ((undef) x @keys);
}
-sub _flash_data {
+sub _flash_data {
my $c = shift;
$c->_flash || $c->_load_flash || do {
$c->create_session_id_if_needed;
sub clear_flash {
my $c = shift;
-
+
#$c->delete_session_data("flash:" . $c->sessionid); # should this be in here? or delayed till finalization?
$c->_flash_key_hashes({});
$c->_flash_keep_keys({});
__updated => $now,
(
- $c->config->{session}{verify_address}
+ $c->_session_plugin_config->{verify_address}
? ( __address => $c->request->address||'' )
: ()
),
(
- $c->config->{session}{verify_user_agent}
+ $c->_session_plugin_config->{verify_user_agent}
? ( __user_agent => $c->request->user_agent||'' )
: ()
),
sub create_session_id {
my $c = shift;
-
+
my $sid = $c->generate_session_id;
$c->log->debug(qq/Created session "$sid"/) if $c->debug;
(
$c->maybe::next::method(),
- $c->sessionid
+ $c->_sessionid
? ( [ "Session ID" => $c->sessionid ], [ Session => $c->session ], )
: ()
);
This method will automatically create a new session and session ID if none
exists.
+You can also set session keys by passing a list of key/value pairs or a
+hashref.
+
+ $c->session->{foo} = "bar"; # This works.
+ $c->session(one => 1, two => 2); # And this.
+ $c->session({ answer => 42 }); # And this.
+
=item session_expires
=item session_expires $reset
all the keys which haven't changed since the flash data was loaded at the end
of every request.
+Note that use of the flash is an easy way to get data across requests, but
+it's also strongly disrecommended, due it it being inherently plagued with
+race conditions. This means that it's unlikely to work well if your
+users have multiple tabs open at once, or if your site does a lot of AJAX
+requests.
+
+L<Catalyst::Plugin::StatusMessage> is the recommended alternative solution,
+as this doesn't suffer from these issues.
+
sub moose : Local {
my ( $self, $c ) = @_;
my ( $self, $c ) = @_;
if ( exists $c->flash->{beans} ) { # false
-
+
}
}
For example:
- __PACKAGE__->config->{session}{expires} = 1000000000000; # forever
+ __PACKAGE__->config('Plugin::Session' => { expires => 10000000000 }); # "forever"
+ (NB If this number is too large, Y2K38 breakage could result.)
# later
If you want to prevent this session fixation scenario:
0) let us have WebApp with anonymous and authenticated parts
- 1) a hacker goes to vulnerable WebApp and gets a real sessionid,
+ 1) a hacker goes to vulnerable WebApp and gets a real sessionid,
just by browsing anonymous part of WebApp
2) the hacker inserts (somehow) this values into a cookie in victim's browser
3) after the victim logs into WebApp the hacker can enter his/her session
=item setup_session
-This method populates C<< $c->config->{session} >> with the default values
+This method populates C<< $c->config('Plugin::Session') >> with the default values
listed in L</CONFIGURATION>.
=item prepare_action
=head1 CONFIGURATION
- $c->config->{session} = {
+ $c->config('Plugin::Session' => {
expires => 1234,
- };
+ });
All configuation parameters are provided in a hash reference under the
-C<session> key in the configuration hash.
+C<Plugin::Session> key in the configuration hash.
=over 4
=item verify_user_agent
When true, C<<$c->request->user_agent>> will be checked at prepare time. If it
-is not the same as the user agent that initiated the session, the session is
+is not the same as the user agent that initiated the session, the session is
deleted.
Defaults to false.
=back
-If this is a concern in your application, a soon-to-be-developed locking
-solution is the only safe way to go. This will have a bigger overhead.
-
-For applications where any given user is only making one request at a time this
-plugin should be safe enough.
+For applications where any given user's session is only making one request
+at a time this plugin should be safe enough.
=head1 AUTHORS
Sergio Salvi
+kmx C<kmx@volny.cz>
+
+Florian Ragwitz (rafl) C<rafl@debian.org>
+
+Kent Fredric (kentnl)
+
And countless other contributers from #catalyst. Thanks guys!
+=head1 Contributors
+
+Devin Austin (dhoss) <dhoss@cpan.org>
+
=head1 COPYRIGHT & LICENSE
Copyright (c) 2005 the aforementioned authors. All rights
projects / catagits/Catalyst-Plugin-Session.git / blobdiff