NAME

Authen::Simple::Adapter - Adapter class for implementations

SYNOPSIS

            

              
              
package Authenticate::Simple::Larry;
use strict;
use base 'Authen::Simple::Adapter';
__PACKAGE__->options({
    secret => {
        type     => Params::Validate::SCALAR,
        default  => 'wall',
        optional => 1
    }
});
sub check {
    my ( $self, $username, $password ) = @_;
     
    if ( $username eq 'larry' && $password eq $self->secret ) {
         
        $self->log->debug( qq/Successfully authenticated user '$username'./ )
          if $self->log;
         
        return 1;
    }
     
    $self->log->debug( qq/Failed to authenticate user '$username'. Reason: 'Invalid credentials'/ )
      if $self->log;
     
    return 0;
}
1;
            
          

DESCRIPTION

Adapter class for implementations.

METHODS

• new ( %parameters )

  If overloaded, this method should take a hash of parameters. The following options should be valid:

  • cache ( $ )

    Any object that supports get, set. Only successful authentications are cached.

    
                
    
                  
                  
    cache => Cache::FastMmap->new
                
              

  • callback ( \& )

    A subref that gets called with two scalar references, username and password.

    
                
    
                  
                  
    callback = sub {
        my ( $username, $password ) = @_;
         
        if ( length($$password) < 6 ) {
            return 0; # abort, invalid credintials
        }
         
        if ( $$password eq 'secret' ) {
            return 1; # abort, successful authentication
        }
         
        return; # proceed;
    }
                
              

  • log ( $ )

    Any object that supports debug, info, error and warn.

    
                
    
                  
                  
    log => Log::Log4perl->get_logger('Authen::Simple')
    log => $r->log
    log => $r->server->log
                
              

• init ( \%parameters )

  This method is called after construction. It should assign parameters and return the instance.

  
              
  
                
                
  sub init {
      my ( $self, $parameters ) = @_;
       
      # mock with parameters
       
      return $self->SUPER::init($parameters);
  }
              
            

• authenticate ( $username, $password )

  End user method. Applies callback, checks cache and calls check unless aborted by callback or a cache hit.

• check ( $username, $password )

  Must be implemented in sublcass, should return true on success and false on failure.

• check_password( $password, $encrypted )

• options ( \%options )

  Must be set in subclass, should be a valid Params::Validate specification. Accessors for options will be created unless defined in sublcass.

  
              
  
                
                
  __PACKAGE__->options({
      host => {
          type     => Params::Validate::SCALAR,
          optional => 0
      },
      port => {
          type     => Params::Validate::SCALAR,
          default  => 80,
          optional => 1
      }
  });
              
            

SEE ALSO

Authen::Simple

Authen::Simple::Password

Params::Validate

AUTHOR

Christian Hansen chansen@cpan.org

COPYRIGHT

This program is free software, you can redistribute it and/or modify it under the same terms as Perl itself.