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.