CGISession
view release on metacpan or search on metacpan
Session/CVS/Base/LDAPSession.pm view on Meta::CPAN
# Generalized by Jeff Younker
# jyounker@inktomi.com (or jeff@math.uh.edu)
#
# Many thanks for the basic code and idea go to Luke
# Sheneman (sheneman@inktomi.com).
#
####################################################################
package CGI::LDAPSession;
use strict;
use vars qw($VERSION);
$VERSION = '0.9b';
use Mozilla::LDAP::Conn; # Main "OO" layer for LDAP
use Mozilla::LDAP::Utils; # LULU, utilities.
use CGI::Carp;
use CGI;
use Date::Format;
use DBI;
=pod
=head1 NAME
CGI::LDAPSession - CGI cookie authentication against an LDAP database
=head1 ABSTRACT
Provides a simple API authenticate users against an LDAP server, and then
to cache this authentication information between invokations of CGI scripts
without sending passwords subsequent to login.
The state information is maintained in a combination of a cookie, a database,
and a magic passkey which is sent in the contents of the web page. Acquiring
the login thus requires stealing both the cookie and a current copy of the
web page.
CGI::LDAPSession also contains a subclass of CGI which transparently injects
the passkey into forms. It is strongly suggested that you use this class.
=head1 SYNOPSIS
=head2 Setting Things Up
use CGI::LDAPSession;
use CGI;
my $cgi = new CGI::LDAPSession::CGI;
my $session = new CGI::LDAPSession( $cgi );
$cgi->session( $session );
$session->auth_servers(
[ new CGI::LDAPSession::LDAPServer(
'ldap.server.my.domain', # host
389, # port
'ou=my,ou=domain', # root
'ou=people,ou=my,ou=domain' # base
'uid=$username,ou=people,ou=my,ou=domain' # bind
) ] );
$session->cookie_table( 'myCookieTable' );
=head2 Performing the Initial Login
my $action = $cgi->param('action');
my $passkey = $cgi->param('passkey');
if ( defined $action and $action eq 'Log In' )
{
my $username = $cgi->param('username');
my $password = $cgi->param('password');
if ( $session->authenticated( $username, $password ) )
{
$session->set_passkey( $user );
$session->set_login_cookie( $user );
# Notice that we use $session->header and not $cgi->header
#
print $session->header();
print $cgi->start_html( 'Login Succeeded' );
...
# The passkey is sent via the cgi wrapper.
#
my $passkey = $session->passkey;
print $cgi->start_form( -action=>'http://my.stupid/script.cgi' );
print ...your form here...
print $cgi->end_form;
...
print $cgi->end_html;
exit 0;
}
else
{
...
Login Failed
...
exit 0;
}
}
=head2 Confirming an Existing Session
my $passkey = $cgi->param('passkey');
if ( defined $passkey and !$session->confirm_userlogin( $passkey ) )
{
print $session->header();
print $cgi->start_html( 'Open Session' );
...
my $passkey = $session->passkey;
print $cgi->start_form( -action=>'http://my.stupid/script.cgi' );
print ...your form here...
print $cgi->end_form;
...
print $cgi->end_html;
exit 0;
Session/CVS/Base/LDAPSession.pm view on Meta::CPAN
my $session = new CGI::LDAPSession( $cgi );
$cgi->session( $cgi );
Now you have to tell the CGIviaLDAP several things. You have to tell it
which LDAP servers it should use for authentication. You need to tell it
how to connect to the database. You need to describe the database table
in which it will store its information. You need to describe the cookie
that it will send to the client's web browser. Finally, you need to
describe various aspects of the login behavior.
=head2 Setting the Authentication Servers
$session->auth_servers( new CGI::LDAPSession::LDAPServer( -host=>'my.host.my.domain',
-port=>389,
-bind=>'uid=$username,ou=people,dc=my,dc=domain' ) );
The string '$username' within the -bind argument will be replaced with
the username when authentication occurrs.
You can also supply more than one ldap server by passing an array of
servers. The servers will be checked from first to last in the array.
my $server1 = new CGI::LDAPSession::LDAPServer( -host=>'ldap1.my.domain',
-port=>389,
-bind=>'uid=$username,ou=people,dc=my,dc=domain' );
my $server2 = new CGI::LDAPSession::LDAPServer( -host=>'ldap2.your.domain',
-port=>389,
-bind=>'uid=$username,ou=people,dc=your,dc=domain' );
$session->auth_servers( [ $server1, $server2 ] );
=head2 Describing the Database Connection
CGIviaLDAP uses perl DBI modules to access the database. There are
three items of major importance. These are the connection DN, the
the database user, and their associated password.
$session->dbi_dn( 'dbi:mysql:my_apps_database' );
$session->dbi_username( 'my_apps_user' );
$session->dbi_password( '!CENSORED' );
=head2 Describing the Database Table
You've now told the object how to connect to the database. Now you need
to tell it what the table it stores the information in will look like.
The most important is the name of the table in which the information
will be stored.
$session->cookie_table( 'login_cookies' );
There are three columns it expects. The first is the name of the
user; the second is the contents of the cookie; and the third is the
passkey. By default these are called, respectively, 'user_id',
'cookie', and 'cookie', and 'passkey'. You may never need to change
these. If you do need to change them then you would write:
$session->user_column('username');
$session->cookie_column('login_cookie');
$session->passkey_column('login_passkey');
=head2 Setting Cookie Parameters
When your program sends back a cookie, the cookie needs to have several
parameters set. These include the name of the cookie, the path which it
covers, the domain for which it is good, and wether or not it should
be used without a secure connection.
$session->cookie_name( 'MySessionCookie123587098' ); # The name of the cookie
$session->cookie_path( '/' );
$session->cookie_domain( '.drinktomi.com' );
$session->secure( 1 ); # 1=requires secure transport
# 0=does not require secure transport
Most importantly you need describe how long the cookie should be valid
for. This is the expiration. It is given in seconds. If using the
refresh option (more on this later) then the expiration determines how
long the web browser can sit idle. If not using the refresh option
then it determines how long the user will remain logged in.
$session->cookie_expiration( 60*60*2 ); # Cookies will be good for two hours.
=head2 Setting Login Behavior
Setting the auto refresh cookie option to 1 will the cookie's expiration
time to be updated every time a page is sent to the client. As long as
the user keeps using the application they will never be logged out.
$session->auto_refresh_cookie(1) # 1=always refresh the session cookie
# 0=never automatically refresh the session cookie
In some instances you only want people to log in when they have a
pre-existing database entry. In this case there are two ways of
managing things. The first is to create an external file containing
the valid user IDs. This is kind of a hack.
$session->allowed_user_file( '/var/etc/allowed_users' );
$session->restricted_access( 1 ) # 1=use allowed user file
# 0=do not use allowed user file
The second way of managing things is a little more to my taste. Normally
the auth object will register the user (create an entry for them) in the
cookie table. You can change this so it will not log a person in unless
they already have an entry in the cookie table.
$session->register(1); # 1=automatically register users in the cookie table.
# 0=do not automatically register users in the cookie table.
Some day we may support check LDAP group memberships as a third mechanism.
=head2 Sending Back a Page
You have to do two things. The first is that you have to generate the HTTP header
using CGI::LDAPSession instead of CGI, and the second is that you have to make sure
that the passkey gets sent back with the results of the next page.
The call CGI::LDAPSession::header is used _exactly_ like CGI::header.
The only difference is that it automatically injects the session
cookie if it needs to.
print $session->header;
The best way to get the passkey back to the user is by using
CGI::LDAPSession::CGI instead of CGI, and using the start_form
and end_form functions. These will automatically inject the
necessary html. The code looks something like this:
print $cgi->start_form( -action=>$cgi->self_url );
print "YOUR FORM HERE";
print $cgi->end_form;
As long as you use CGI::LDAPSession::CGI then you don't have to do
anything else.
If you want to inject passkey into the document yourself then the
simplest way is to use a hidden text field. The current passcode is
contained in CGI::LDAPSession::passkey. The code to create the form
might look something like the next snippet.
print "<form...>"
Session/CVS/Base/LDAPSession.pm view on Meta::CPAN
If you don't send the passkey along then confirmation of the next
session login will fail.
=head2 Authenticating a New Session
Read the user name, and password from the incoming CGI form, and then
pass them to CGIviaLDAP::authenticated. If the user is authenticated
the we must generate a passkey and a session cookie.
my $username = $cgi->param('username');
my $password = $cgi->param('password');
if ( $session->authenticated( $username, $password ) )
{
$session->set_passkey( $username );
$session->set_login_cookie( $username );
...
Successfully authenticated, send response
...
}
else
{
...
Login Failed
...
}
=head2 Confirming an Existing Session
Read the passkey from the incoming CGI form, and then ask
CGIviaLDAP to confirm it.
my $key = $cgi->param('passkey');
if ( $session->confirmed($key) )
{
...
Session was confirmed and this is a valid session
...
}
else
{
...
Session was not confirmed, and this is not a valid session
...
}
Once a session has been confirmed you can do several things with it.
You can change the passcode; you can change the cookie identifier; or
you can refresh the cookie so that the expiration time will be reset.
=head2 Changing the Passcode
if ( $session->confirmed( $key ) )
{
$session->set_passcode;
...
Session was confirmed and this is a valid session
...
}
=head2 Changing the Cookie Identifier
if ( $session->confirmed( $key ) )
{
$session->set_login_cookie;
...
Session was confirmed and this is a valid session
...
}
=head2 Refreshing the Cookie Expiration
if ( $session->confirmed( $key ) )
{
$session->refresh_login_cookie;
...
Session was confirmed and this is a valid session
...
}
=head2 Logging Out
if ( $session->confirmed( $key ) and $logout )
{
$session->set_logout_cookie;
...
print $session->header() # You must send back a cookie using the $session
print $cgi->start_html( 'Logout Page' );
print "You have been logged out."; # Notice that the passkey does not
# need to be sent back.
print $cgi->end_html;
exit 0;
}
=head2 Creating the Cookie Table
Guess what? Once you have configured your CGIviaLDAP there is a function
which will create the table that you have described. It only works for
MySQL at the moment, but in the future it may work for other databases.
$session->create_cookie_table;
=head1 TO DO
=over 4
=item 1. Provide function to retreive username from the database using the cookie.
=item 2. Provide support for Net::LDAP
=item 3. Clean up DBI code. (DBI provides the independence that the old routines did.)
=item 4. Clean up DBI connection creation. (Makes way too many database connections.)
=item 5. Make an 'add_cookie_table' function to alter existing tables.
=item 6. Date tracking and garbage collection of expired cookie entries for auto-registered tables.
=back
=head1 REFERENCE
=cut
############################################
# #
# Some Constants, used only within Inktomi #
# #
############################################
# Toggle this to limit access to the application to a specific set of
# people. 1 = restricted, 0 = open
my $RESTRICTED_ACCESS = 0;
my $ALLOWED_USER_FILE = "/var/tmp/allowed_users";
#
# Settings for the LDAP server to authenticate against
#
my $AUTH_LDAP_SERVER = "gandalf.inktomi.com";
my $AUTH_LDAP_PORT = 389;
my $AUTH_LDAP_ROOT = "o=inktomi.com";
my $AUTH_LDAP_BASE = $AUTH_LDAP_ROOT;
my $AUTH_LDAP_BIND = "uid=\$username,ou=People,$AUTH_LDAP_BASE";
#
# Settings for the general-purpose LDAP server
#
my $GEN_LDAP_SERVER = "phonebook.inktomi.com";
my $GEN_LDAP_PORT = 389;
my $GEN_LDAP_ROOT = "dc=inktomi,dc=com";
my $GEN_LDAP_BASE = "ou=People,$GEN_LDAP_ROOT";
Session/CVS/Base/LDAPSession.pm view on Meta::CPAN
Accessor method. The value of the current cookie.
=cut
#################################
sub cookie($;$) { my $self=shift; @_ ? $self->{cookie}=shift : $self->{cookie}; }
=item CGI::LDAPSession::passkey
Accessor method. The value of the current passkey. Set by confirmed() and authenticated().
=cut
sub passkey($;$) { my $self=shift; @_ ? $self->{passkey}=shift : $self->{passkey}; }
#################################
=item CGI::LDAPSession::is_authenticated
Accessor method. Authentication state. True if the session has been successfully authenticated. False if it has not.
=cut
sub is_authenticated($;$) { my $self=shift; @_ ? $self->{is_authenticated}=shift : $self->{is_authenticated}; }
# Fast initialization routine.
#
sub set($@)
{
my ( $self ) = shift;
my %a = @_;
$self->cookie_logged_in( $a{'-cookie_logged_in'} ) if defined $a{'-cookie_logged_in'};
$self->cookie_logged_in( $a{'-cookie_name'} ) if defined $a{'-cookie_name'};
$self->cookie_expiration( $a{'-cookie_expiration'} ) if defined $a{'-cookie_expiration'};
$self->cookie_path( $a{'-cookie_path'} ) if defined $a{'-cookie_path'};
$self->cookie_domain( $a{'-cookie_domain'} ) if defined $a{'-cookie_domain'};
$self->cookie_secure( $a{'-cookie_secure'} ) if defined $a{'-cookie_secure'};
$self->auth_servers( $a{'-auth_servers'} ) if defined $a{'-auth_servers'};
$self->restricted_access( $a{'-restricted_access'} ) if defined $a{'-restricted_access'};
$self->allowed_user_file( $a{'-allowed_user_file'} ) if defined $a{'-allowed_user_file'};
$self->unikey( $a{'-unikey'} ) if defined $a{'-unikey'};
$self->register( $a{'-register'} ) if defined $a{'-register'};
$self->auto_refresh_cookie( $a{'-auto_refresh_cookie'} ) if defined $a{'-auto_refresh_cookie'};
$self->dbi_dn( $a{'-dbi_dn'} ) if defined $a{'-dbi_dn'};
$self->dbi_password( $a{'-dbi_password'} ) if defined $a{'-dbi_password'};
$self->dbi_username( $a{'-dbi_username'} ) if defined $a{'-dbi_username'};
$self->cookie_table( $a{'-cookie_table'} ) if defined $a{'-cookie_table'};
$self->user_column( $a{'-user_column'} ) if defined $a{'-user_column'};
$self->passkey_column( $a{'-passkey_column'} ) if defined $a{'-passkey_column'};
$self->cookie_column( $a{'-cookie_column'} ) if defined $a{'-cookie_column'};
$self->dbi_login_expiration_column( $a{'-dbi_login_expiration_column'} ) if defined $a{'-dbi_login_expiration_column'};
$self->passkey_name( $a{-passkey_name} ) if defined $a{-passkey_name};
$self->debug( $a{-debug} ) if defined $a{-debug};
}
# Cookie characteristics.
#
=item Cookie Characteristics
These accessor methods specify the details of the cookies which are generated.
=item CGI::LDAPSession::cookie_logged_in($;$)
Accessor method. The name of the login cookie. Use cookie_name instead.
=cut
sub cookie_logged_in($;$) { my $self=shift; @_ ? $self->{cookie_logged_in}=shift : $self->{cookie_logged_in}; }
=item CGI::LDAPSession::cookie_name($;$)
Accessor method. The name of the login cookie. Use this instead of cookie_logged_in.
=cut
sub cookie_name($;$) { my $self=shift; @_ ? $self->{cookie_logged_in}=shift : $self->{cookie_logged_in}; }
=item CGI::LDAPSession::cookie_logged_out($;$)
Accessor method. Vestigial logout cookie. Unused. Like the wings of an archeopertyx. But with no hairy feathers.
=cut
sub cookie_logged_out($;$) { my $self=shift; @_ ? $self->{cookie_logged_out}=shift : $self->{cookie_logged_out}; }
=item CGI::LDAPSession::cookie_expiration($;$)
Accessor method. The lifetime of the cookie specified in seconds.
=cut
sub cookie_expiration($;$) { my $self=shift; @_ ? $self->{cookie_expiration}=shift : $self->{cookie_expiration}; }
=item CGI::LDAPSession::cookie_path($;$)
Accessor method. The path of the cookie.
=cut
sub cookie_path($;$) { my $self=shift; @_ ? $self->{cookie_path}=shift : $self->{cookie_path}; }
=item CGI::LDAPSession::cookie_domain($;$)
Accessor method. The domain of the cookie.
=cut
sub cookie_domain($;$) { my $self=shift; @_ ? $self->{cookie_domain}=shift : $self->{cookie_domain}; }
=item CGI::LDAPSession::cookie_secure($;$)
Accessor method. True if the cookie requires SSL. False otherwise.
Session/CVS/Base/LDAPSession.pm view on Meta::CPAN
return qq(<input type=hidden name="$passkey_name" value="$passkey">);
}
# Confirm the existance of the session
#
# $session->confirmed( $passkey )
# -or-
# $session->confirmed;
#
# 1 is SUCCESS
# 0 is FAILURE
#
=item CGI::LDAPSession::confirmed
Confirms that the cookie and a passkey constitute a valid login. If
the session confirmation succeeds then it will return a true value.
If the session confirmation fails then it will return a false value.
Once this routine is called the variable of
CGI::LDAPSession::is_authenticated will contain the status of the
session.
The function may be called in one of two ways. You can either let
it extract the passkey value on its own, or you can hand it the
passkey value to be checked. It is much less work to let it extract
the passkey value.
if ( $session->confirmed )
{
Session was confirmed...
}
If you want to handle the extraction of the passkey on your own...
my $passkey = $cgi->param( 'passkey_name' );
if ( $session->confirmed( $passkey ) )
{
Session was confirmed...
}
=cut
sub confirmed($;$)
{
my ($self) = shift;
my $passkey = @_ ? shift : $self->cgi->param( $self->passkey_name );
carp "Passkey is $passkey";
my $client_cookie;
my $db_passkey;
$client_cookie = $self->check_cookie;
if(!defined $client_cookie or !$client_cookie)
{
# No client Cookie!
carp "No Cookie!" if $self->debug;
$self->is_authenticated(undef);
return 0;
}
my $cookie_table = $self->cookie_table;
my $user_column = $self->user_column;
my $cookie_column = $self->cookie_column;
my $passkey_column = $self->passkey_column;
$self->ConnectToDatabase;
$self->SendSQL("SELECT $passkey_column FROM $cookie_table WHERE $cookie_column='$client_cookie'");
($db_passkey) = $self->FetchSQLData();
$self->DisconnectDatabase;
# passkey doesn't match passkey in database
if (!defined $passkey)
{
carp "ERROR: Passkey is not found" if $self->debug;
$self->is_authenticated(undef);
return 0;
}
elsif ($passkey ne $db_passkey)
{
carp "ERROR: Passkeys don't match" if $self->debug;
$self->is_authenticated(undef);
return 0;
}
else
{
$self->passkey( $passkey );
}
# Refresh cookie automagically if the user wants us to.
#
$self->refresh_login_cookie if $self->auto_refresh_cookie;
# Everything matches, confirm login
#
$self->is_authenticated(1);
return 1;
}
# For testing at a separate point.
#
# $session->confirm;
# if ( $session->is_authenticated ) { ... }
#
=item CGI::LDAPSession::confirm
The preferred way of confirming a valid login session. It extracts
the cookie and session key from the CGI, checks their validity, and
then sets the variable CGI::LDAPSession::is_authenticated. Used as
follows:
$session->confirm;
if ( $session->is_authenticated )
{
Authentication Succeeded
Session/CVS/Base/LDAPSession.pm view on Meta::CPAN
$user_exists = $self->FetchOneColumn == 1;
}
$self->DisconnectDatabase;
return $user_exists;
}
=item CGI::LDAPSession::register_username($$)
Internal function. Creates an entry for the specified user within the cookie table.
if ( ! $self->user_exists( $username ) )
{
$self->register_username( $username );
}
=cut
sub register_username($$)
{
my ($self,$username) = @_;
return unless $self->register;
return if $self->user_exists($username);
my $cookie_table = $self->cookie_table;
my $user_column = $self->user_column;
my $cookie_column = $self->cookie_column;
my $passkey_column = $self->passkey_column;
$self->ConnectToDatabase;
$self->SendSQL("INSERT INTO $cookie_table ( $user_column ) VALUES ( '$username' )");
$self->DisconnectDatabase;
}
=item CGI::LDAPSession::login_cookie($$$)
Internal function. Returns the cookie string for the current session. The
expiration time is a unix timestamp as returned by the function time(). The
expiration time is not a lifetime in seconds.
my $cookie_string = $self->login_cookie( $cookie_name, $expiration_time );
=cut
sub login_cookie($$$)
{
my ($self,$cookie_value,$expiration_time) = @_;
my $datetimestr = time2str("%a, %e-%b-%Y %X GMT", $expiration_time, 'GMT');
my $cgi = $self->cgi;
my $cookie = $cgi->cookie( -name=>$self->cookie_logged_in,
-value=>$cookie_value,
-path=>$self->cookie_path,
-domain=>$self->cookie_domain,
-secure=>($self->cookie_secure ? 1 : 0 ),
-expires=>$datetimestr );
return $cookie;
}
#
# Set the Session Cookie (login)
#
=item CGI::LDAPSession::set_login_cookie($;$)
Sets the login cookie for an authenticated session. If a username
is not specified then it pulls the username corresponding to the
current cookie and passkey combination.
$self->set_login_cookie( $username );
..or..
$self->set_login_cookie();
=cut
sub set_login_cookie($;$)
{
my ($self) = shift;
my $cookie_table = $self->cookie_table;
my $user_column = $self->user_column;
my $cookie_column = $self->cookie_column;
my $passkey_column = $self->passkey_column;
$self->ConnectToDatabase;
# Get user ID. Either from the command line or from
# the cookie ID.
#
my $user_id;
if ( @_ )
{
$user_id = shift;
$user_id = defined $user_id ? $user_id : "";
}
else
{
my $current_cookie = $self->cgi->cookie( $self->cookie_logged_in );
$self->SendSQL("SELECT $user_column FROM $cookie_table WHERE $cookie_column='$current_cookie'");
if (!$self->MoreSQLData)
{
croak "Error: Could not read user name from cookie table.\n";
}
$user_id = $self->FetchOneColumn;
}
my $r = int(rand 999999)+1;
my $cookie_value = $user_id.$r;
$self->SendSQL("UPDATE $cookie_table SET $cookie_column='$cookie_value' WHERE $user_column='$user_id'");
$self->DisconnectDatabase;
# Create cookie.
#
my $expiration_time = time + $self->cookie_expiration;
my $cookie = $self->login_cookie( $cookie_value, $expiration_time );
$self->cookie( $cookie );
# SUCCESS
#
return 0;
Session/CVS/Base/LDAPSession.pm view on Meta::CPAN
else
{
my $cookie = $self->cgi->cookie( $self->cookie_logged_in );
$self->SendSQL("UPDATE $cookie_table SET $passkey_column='$pass' WHERE $cookie_column='$cookie'");
}
$self->DisconnectDatabase;
$self->passkey( $pass );
# SUCCESS
#
return 0;
}
=item CGI::LDAPSession::logout_cookie($)
Returns a login_cookie which has expired. (Expiration date
is set to epoch.)
my $cookie = $self->logout_cookie();
=cut
sub logout_cookie($)
{
my ($self) = @_;
my $datetimestr = "Thu, 01-Jan-2000 00:00:01 GMT";
my $cgi = $self->cgi;
my $cookie = $cgi->cookie( -name=>$self->cookie_logged_in,
-value=>{},
-path=>$self->cookie_path,
-domain=>$self->cookie_domain,
-secure=>($self->cookie_secure ? 1 : 0 ),
-expires=>$datetimestr );
return $cookie;
}
#
# logout here (as far as cookies are concerned)
#
=item CGI::LDAPSession::set_logout_cookie($)
Expires the cookie in the backing store.
my $cookie = $self->set_logout_cookie();
=cut
sub set_logout_cookie($)
{
my ($self) = @_;
my $logout_cookie = $self->logout_cookie;
$self->cookie( $logout_cookie );
# SUCCESS
return 0;
}
#
# Check Cookie
#
=item CGI::LDAPSession::check_cookie($)
Returns the cookie for this session if it exists. If a
cookie does not exist then it returns nothing.
my $login_cookie = $self->check_cookie();
=cut
sub check_cookie($)
{
my ($self) = @_;
return $self->cgi->cookie($self->cookie_logged_in);
}
#######################################################################################
#
# An LDAP server
#
package CGI::LDAPSession::LDAPServer;
use strict;
sub new($;@)
{
my ( $type ) = shift;
my %args = @_;
my $self = {};
bless $self, $type;
# set other parameters if needed.
#
$self->host( $args{'-host'} ) if $args{'-host'};
$self->port( $args{'-port'} ) if $args{'-port'};
$self->root( $args{'-root'} ) if $args{'-root'};
$self->base( $args{'-base'} ) if $args{'-base'};
$self->bind( $args{'-bind'} ) if $args{'-bind'};
return $self;
}
sub host($;$) { my $self=shift; @_ ? $self->{host}=shift : $self->{host}; }
sub port($;$) { my $self=shift; @_ ? $self->{port}=shift : $self->{port}; }
sub root($;$) { my $self=shift; @_ ? $self->{root}=shift : $self->{root}; }
sub base($;$) { my $self=shift; @_ ? $self->{base}=shift : $self->{base}; }
sub bind($;$) { my $self=shift; @_ ? $self->{bind}=shift : $self->{bind}; }
sub set_mozilla_LDAP_args_in($$)
{
my ( $self, $args ) = @_;
$args->{host} = $self->host;
$args->{port} = $self->port;
$args->{root} = $self->root;
$args->{base} = $self->base;
$args->{bind} = $self->bind;
( run in 1.934 second using v1.01-cache-2.11-cpan-6aa56a78535 )