Free ucla summer session software for linux

ROX-Session is a simple session manager. It loads, runs any programs you asked it to, and then quits when you run it a second time (thus ending your session). ROX-Session does not display any windows until you ask it to quit.
The first time you run it it will offer to make itself your session manager, so that youll get a ROX desktop when you log in (see screenshots below).
ROX-Session will automatically run any programs in your Auto Start directory when you log in. You can open this directory by bringing up the menu over ROX-Sessions icon and choosing Auto Start...
Enhancements:
- A large number of small bugs were fixed.
- New settings for the Gamma, Screensaver, and Keyboard configlets were added.
- The freedesktop.org configuration directories are now used instead of the old CHOICESPATH ones.

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 .

DB_eSession provides a class that securely stores PHP sessions in a MySQL database.
DB_eSession is a feature-packed PHP class that stores session data in a MySQL database rather than files. It is powerful, designed with security in mind, and is easy to utilize.
The code contains lots of comments, and it comes with full documentation and examples of how to use the class including a basic authentication login/logout process.
It includes member functions useful (to webmasters) for monitoring or viewing, deleting, and altering sessions validity for the case of locking one or more sessions upon detection of unauthorized use.
Main features:
- General features:
- Stores session data in a MySQL table using PHPs built-in session handler.
- Built-in handling of session expiration and cleanup.
- Supports the changes of session related configuration settings (inc. PHP5).
- Allows for normal or persistent MySQL database connections.
- Access to opened MySQL resource connection to use in your script.
- Accepts a passed database resource link to use as the DB connection.
- Supports session IDs between 12 and 32 characters long.
- Custom or changeable database, table and column names.
- An option to create new session IDs (you supply, class or PHP builds).
- Can initiate buffered output (using ob_start) within the class.
- A session_start() automatically initiated within the class.
- Can send Cache-Control: header output within the class (fixes IE6 bug).
- Ability to retrieve a specific sessions expiration date and time.
- Retrieve current session life setting in seconds or minutes.
- Retrieve a numeric total of the number of active and inactive sessions in table.
- Facility to make assignment and retrieval of session variables easier.
- Ability to create manual URIs and links that includes session name and ID.
- The ability to retrieve what the MySQL server version number is.
- An adequate form of encode/decode member functions are included and used automatically when libmcrypt is not installed.
- Security features:
- Standard user inactivity time-out handled automatically.
- Absolute user logoff time-out capability (session will be terminated no matter what after a number of designated minutes/seconds have elapsed).
- Ability to lock and unlock a particular session or all sessions. When a session is made locked it is immediately not available for use.
- User to session verification using IP address and browser information.
- Security level (code) clearance for each session/web page.
- Encrypt/decrypt as desired each session field.
- Encrypt/decrypt an extra session field to compare against original (to detect against possible tampering).
- Encrypt/decrypt the whole session data in the table (essentially obscuring session variable names in table). Can be used in combination with per session field encryption, resulting in double encryption security.
- A new encryption Initialization Vector is created every time values change.
- Ability to manually delete a particular session or all sessions.
- The users IP address and web browser is recorded as part of the session for tracing information.
- Other features:
- Support for multiple language error and warning messages.
- Support of a default language as well as current active language settings.
- Basic or detailed (with SQL syntax) error/warning reporting.
- Buffered error and warning messages.
- Option for class to stop execution or not upon encountering an error/warning. Class can display errors/warnings automatically or control in your script.
- Can select font color and size separately for error and warning messages.
- Code has lots of comments and formatted within 82 characters wide.
- Full documentation (only provided in English) is included.
- Code use examples provided, including a basic authentication (login/logout) process.
- SQL text file provided for creating the MySQL session table.

gnome-session package is free software and is part of the GNOME project.
Contained here are
- the GNOME session manager
- the GNOME session manager configuration program
- and several other session management related utilities.

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.