Free summer session software for linux

PHP began as a quick Perl hack written by Rasmus Lerdorf in 1994.
Over the next two to three years, it evolved into what we today know as PHP/FI 2.0. PHP/FI started to get a lot of users, but things didn`t start flying until Zeev Suraski and Andi Gutmans suddenly came along with a new parser in the summer of 1997, leading to PHP 3.0. PHP 3.0 defined the syntax and semantics used in both versions 3 and 4.

SCMS project is a secure content management system. Some of its features are a role-based object-oriented design, conformance to XHTML 1.0 Transitional, strict I/O (input/output) validation, a custom session implementation, support for SSL and cookies (when run over SSL), session identifier regeneration, idle session expiration, account locking, account unlocking methods, encryption (with MD5, AES, SHA1, SHA256, SHA512, or WHIRLPOOL), and event logging.
Enhancements:
- The new permission system in users.php was implemented.
- The SCMS DB creation SQL was rewritten to include referential integrity for updates and deletes.

pam_script is a PAM (plugable authentication module) that runs a session open script and/or a session close script when a user logs into a service.
pam_script project works with any service that implements pam session management.
Enhancements:
- Improved Makefile and Debian packaging scripts.
- Options to set the home directory and PAM_USER token in the environment.

EasySession is a Perl session interface.

SYNOPSIS

use EasySession;

if(defined(&EasySession::foo)){
print "lib is included";
}else{
print "lib is not included";
}

#{"_sid" => "B43b648fd431aac32", "a" => 1, "b" => 2}

print EasyTool::dump(create($dba,{a=>1,b=>2,c=>undef},{expire=>300}));

$dba->execute(START TRANSACTION);
my $st=CORE::time();
for(1..10000){
create($dba,{a=>1,b=>2,c=>undef},{});
}
print CORE::time()-$st;
$dba->execute(COMMIT);

print EasyTool::dump(&delete($dba,{"_sid" => "43ba09e0abd5cf13", "a" => 1, "b" => 2}));
print EasyTool::dump(&delete($dba,"43ba08a74fbe7afa"));
print EasyTool::dump(&save($dba,{"_sid" => "43ba08a74fbe7afa", "a" => 1, "b" => 2,"c"=>3}));

Basic Variables and Functions

Variables

$dba: instance of EasyDBAccess
$rh : the hash_ref to store to database
$session: $rh with key _sid
$sid: session id ([0-9a-fA-F]{8})([0-9a-fA-F]{8})
$rc : affected rows 0 or 1
$rh_option:
now => unix timestamp of now
expire => expire time after last modify
ip => ip address (int)

Functions

$session=create($dba,$rh,$rh_option);

$session=load($dba,$sid,$rh_option);

$rc =save($dba,$session,$rh_option);
#if succ return 1,if fail(no row update) return 0
#if record exist, then update, else do nothing

$rc =delete($dba , $sid|$session [,$rh_option]);
#if succ return 1,if fail(no row delete) return 0
#if record exist, then delete, else do nothing

CGI::kSession is a sessions manager for CGI.
This module can be used anywhere you need sessions. As a session management module, it uses files with a configurable lifetime to handle your session data. For those of you familiar with PHP, you will notice that the session syntax is a little bit similar.
METHODS
The following public methods are availible:
$s = new CGI::kSession();
The constructor, this starts the ball rolling. It can take the following hash-style parameters:
lifetime - how long the session lasts, in seconds
path - the directory where you want to store your session files
id - if you want to give the session a non-random name, use this parameter as well
$s->start();
This creates a session or resumes an old one (could be used in conjunction with something like HTTP::Cookie). This will return 1 if this is a new session, and 0 if its resuming an old one. If you defined no values in the new() call, then the session will start with a default lifetime of 600 seconds, a path of /var/tmp, and a random string for an id.
$s->save_path();
Save the session path or, without an argument, return the current session path. Used with an argument, this performs the same thing as the path parameter in the constructor.
$s->id();
If the session id exists, this will return the current session id - useful if you want to maintain state with a cookie! If you pass a parameter, it acts the same as new( id => some_session_name), i.e., it creates a session with that id.
$s->register();
This takes a string as an arguement and basically tells the session object this: "Hey, this is a variable Im thinking about associating with some data down the road. Hang onto it for me, and Ill let you know what Im going to do with it". Once you register a variable name here, you can use it in set() and get().
$s->is_registered();
Check to see if the function is registered. Returns 1 for true, 0 for false.
$s->unregister();
Tell the session jinn that you no longer want to use this variable, and it can go back in the bottle (the variable, not the jinn... you still want the jinn around until you call destroy()).
$s->set();
This is where you actually define your variables (once you have "reserved" them using register()). This method takes two arguments: the first is the name of the variable that you registerd, and the second is the info you want to store in the variable.
$s->get();
This method allows you to access the data that you have saved in a session - just pass it the name of the variable that you set().
$s->unset();
Calling this method will wipe all the variables stored in your session.
$s->destroy();
This method deletes the session file, destroys all the evidence, and skips bail.
Enhancements:
- updated the documentation

gnome-terminal is the GNOME terminal emulator application. gnome-terminal is only the shell (menubar, prefs dialog); the terminal emulation ("stuff in the middle") comes from the VTE widget. Remember this when choosing a bugzilla component.

How it works:

Profiles:
all settings are stored in profiles. prefs dialog edits the current profile

Session:
just the number of open windows/tabs and their profile is stored per-session

Command line options:
do not overlap things that are preferences

phpDEV project provides a framework for any php development. It includes users, setting, session, elements and template management as a base to build upon. All base functionality has full web based management included, where you take it from there is up to you.
Enhancements:
- Bus fixes and large amount of polishing

KuFtp is a graphical FTP client for the K Desktop Environment. The project is written in C++ using the QT/KDE libraries.

It implements many features required for usable FTP interaction. Most notable features is Tab Sessions like Konqueror or Firefox, that is,you can have multiple simultaneous FTP session in separate tabs.

Other features like bookmark manager,history recording,queue manager and some small nifty features are currently available in the latest version.