Free session software for linux

Skeleton project is a secure framework for a PHP website. If you want to create a new website, Skeleton is a good start.
Download the package, unpack it and you can start adding content in an easy and secure way.
Enhancements:
- Improved session-timeout handling.
- Page header and footer files renamed.
- Page HTML-header file added.

PHP::Session is a Perl module to read / write PHP session files.

SYNOPSIS

use PHP::Session;

my $session = PHP::Session->new($id);

# session id
my $id = $session->id;

# get/set session data
my $foo = $session->get(foo);
$session->set(bar => $bar);

# remove session data
$session->unregister(foo);

# remove all session data
$session->unset;

# check if data is registered
$session->is_registered(bar);

# save session data
$session->save;

# destroy session
$session->destroy;

# create session file, if not existent
$session = PHP::Session->new($new_sid, { create => 1 });

PHP::Session provides a way to read / write PHP4 session files, with which you can make your Perl application session shared with PHP4.

If you like Apache::Session interface for session management, there is a glue for Apache::Session of this module, Apache::Session::PHP.

App::Session can represents a sequence of multiple events perhaps executed in separate processes.

SYNOPSIS

# ... official way to get a Session object ...
use App;
$session = App->context();
$context = $session->session(); # get the session

# any of the following named parameters may be specified
$session = $context->session(
);

# ... alternative way (used internally) ...
use App::Session;

A Session class models the sequence of events associated with a use of the system. These events may occur in different processes.

For instance, in a web environment, when a new user arrives at a web site, he is allocated a new Session, even though he may not even be authenticated. In subsequent requests, his actions are tied together by a Session ID that is transmitted from the browser to the server on each request. During the Session, he may log in, log out, and log in again. Finally, Sessions in the web environment generally time out if not accessed for a certain period of time.

Conceptually, the Session may span processes, so they generally have a way to persist themselves so that they may be reinstantiated wherever they are needed. This would certainly be true in CGI or Cmd Contexts where each CGI request or command execution relies on and contributes to the running state accumulated in the Session. Other execution Contexts (Curses, Gtk) only require trivial implementations of a Session because it stays in memory for the duration of the process. Nonetheless, even these Contexts use a Session object so that the programming model across multiple platforms is the same.

POE::Session is a Perl module for event driven abstract state machine.

SYNOPSIS

# Import POE::Session constants.
use POE::Session;

POE::Session->create(

# Inline or coderef states.
inline_states => {
state_one => &coderef_one,
state_two => sub { ... },
},

# Plain and mapped object states.
object_states => [
$object_one => [ state_three, state_four, state_five ],
$object_two => { state_nine => method_nine },
],

# Plain and mapped package states.
package_states => [
$package_one => [ state_six, state_seven, state_eight ],
$package_two => { state_ten => method_ten },
],

# Parameters for the sessions _start state.
args => [ argument_zero, argument_one, ... ],

# Initial options. See the option() method.
options => %options,

# Change the sessions heap representation.
heap => [ ],
);
Other methods:
# Retrieve a sessions unique identifier.
$session_id = $session->ID;

# Retrieve a reference to the sessions heap.
$session_heap = $session->get_heap();

# Set or clear session options.
$session->option( trace => 1, default => 1 );
$session->option( trace );

# Create a postback, then invoke it and pass back additional
# information.
$postback_coderef = $session->postback( $state_name, @state_args );
$postback_coderef->( @additional_args );

# Or do the same thing synchronously
$callback_coderef = $session->callback( $state_name, @state_args );
$retval = $callback_coderef->( @additional_args );

POE::Session combines a runtime context with an event driven state machine. Together they implement a simple cooperatively timesliced thread.
Sessions receive their timeslices as events from POE::Kernel. Each event has two fields, a state name and a session identifier. These fields describe the code to run and the context to run it in, respectively.

Events carry several other fields which will be discussed in the "Predefined Event Fields" section.

States are re-entrant since they are invoked with their runtime contexts. Although its not usually necessary, this re-entrancy allows a single function to be bound to several different sessions, under several different state names.
As sessions run, they post new events through the Kernel. These events may be for themselves or other sessions, in which case they act as a form of inter-session communications. The Kernel can also generate events based on external conditions such as file activity or the passage of time.

POE provides some convenient built-in states with special meanings. They will be covered later on in the "Predefined States" section.

Lemonldap::Portal::Session is a Perl extension for Lemonldap websso.

SYNOPSIS

use Lemonldap::Portal::Session;

my $paramxml = $test->{DefinitionSession} ; # $test is the result of XML parsing
my $obj = Lemonldap::Portal::Session->init ($paramxml,entry =>$entry) ;

Lemonldap::Portal::Session is a parser of XML description of session to keys,values of hash .

It is a piece of lemonldap websso framework . see eg directory for implementation .

POE::Session::Cascading is a Perl module with stack-like POE sessions.

SYNOPSIS

POE::Session::Cascading->new(
name => foo,
events => [
state1 => &state1,
state2 => &state2,
],
);

sub state1 {
my %args = @_;
$args{KERNEL}->post(somewhere,somestate);
# [ snip ]

}

sub state2 {
my %args = @_;
# [ snip ]

$args{SESSION}->stop;
}

POE::Session::Cascading provides a stack-like session for POE. Another way of saying it is that a Cascading session is like a big switch statement. In the above example, when state1 is called in session foo, &state1 gets executed. When it finishes, state2 gets fired and &state2 gets executed. If state2 is called in session foo, only state2 will get executed.

Catalyst::Plugin::Session::CGISession is a Perl module to use CGI::Session for persistent session data.

SYNOPSIS

use Catalyst qw{ ... Session::CGISession ... };

MyApp->config->{session} = {
expires => 3600,
rewrite => 1,
};

$c->session->{user_email} = quibble@dibble.edu;

# Later, in another following request:

$smtp->to( $c->session->{user_email} );

This plugin provides the same functionality as the original Session::FastMmap plugin but uses the CGI::Session module for the session data management.

The motivations to develop this plugin were:

provide better session data expiration handling, as is available through the CGI::Session module
provide an easier migration to Catalyst for applications that have been using CGI::Session and its param() and other methods
allow Windows users to avoid the workarounds needed to make Cache::FastMmap work

The difference in session expiration between this plugin and Session::FastMmap is small but important. CGI::Session resets the expiration time limit on every access to the session. A one day time limit means the session data disappears 24 hours after the last request using that session. With Session::FastMmap the limit would be 24 hours after the first request, when the session is created.

While this plugin adds some functions and methods beyond those available with Session::FastMmap, new development most likely should avoid using these features. Try to use only the common feature, session(), to stay compatible with Session::FastMmap and other future session plugins.