view release on metacpan or search on metacpan
lib/Apache/Session/CacheAny.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = Apache::Session::Store::CacheAny->new($self);
$self->{lock_manager} = Apache::Session::Lock::Null->new($self);
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Storable::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Storable::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/DBMS.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = new Apache::Session::Store::DBMS $self;
$self->{lock_manager} = new Apache::Session::Lock::Null $self;
$self->{generate} = \&Apache::Session::Generate::DBMS::generate;
$self->{validate} = \&Apache::Session::Generate::DBMS::validate;
if( exists $self->{args}->{Serialize} ) {
my $ser = "Apache::Session::Serialize::$self->{args}->{Serialize}";
if (!exists $incl->{$ser}) {
view release on metacpan or search on metacpan
AutoIncrement.pm view on Meta::CPAN
$session->{data}->{_session_id} = substr($cntstr, length($cntstr)-$length);
}
sub validate {
#This routine checks to ensure that the session ID is in the form
#we expect. This must be called before we start diddling around
#in the database or the disk.
my $session = shift;
view release on metacpan or search on metacpan
lib/Apache/Session/Generate/Random.pm view on Meta::CPAN
sub generate {
my ($session) = @_;
return $session->{'data'}->{'_session_id'} = unpack( 'H*', Crypt::SysRandom::random_bytes(20) );
}
sub validate {
my ($session) = @_;
if ( $session->{data}->{_session_id} =~ /^[0-9a-f]{40}$/ ) {
return $session->{data}->{_session_id};
}
die "Invalid session ID: " . $session->{data}->{_session_id};
lib/Apache/Session/Generate/Random.pm view on Meta::CPAN
This module extends L<Apache::Session> to create secure random session ids using the system's source of randomness.
=for Pod::Coverage generate
=for Pod::Coverage validate
=head1 SEE ALSO
L<Apache::Session>
view release on metacpan or search on metacpan
lib/Apache/Session/Generate/UUID.pm view on Meta::CPAN
sub generate {
my ($session) = @_;
return $session->{'data'}->{'_session_id'} = Data::UUID->new->create_str();
}
sub validate {
my ($session) = @_;
if ($session->{'data'}->{'_session_id'} !~ /^[a-fA-F0-9\-]+$/xm) { die; }
return 1;
}
lib/Apache/Session/Generate/UUID.pm view on Meta::CPAN
=head1 FUNCTIONS
=head2 generate
=head2 validate
=head1 AUTHOR
Nick Gerakines, C<< <nick at socklabs.com> >>
view release on metacpan or search on metacpan
lib/Apache/Session/LDAP.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = new Apache::Session::Store::LDAP $self;
$self->{lock_manager} = new Apache::Session::Lock::Null $self;
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Base64::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Base64::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/MariaDB.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = new Apache::Session::Store::MariaDB $self;
$self->{lock_manager} = new Apache::Session::Lock::MariaDB $self;
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Storable::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Storable::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/Memcached.pm view on Meta::CPAN
sub populate {
my $self = shift;
$self->{object_store} = Apache::Session::Store::Memcached->new($self);
$self->{lock_manager} = Apache::Session::Lock::Null->new($self);
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Storable::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Storable::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/Memorycached.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = new Apache::Session::Store::Memorycached $self;
$self->{lock_manager} = new Apache::Session::Lock::Memorycached $self;
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Memorycached::none;
$self->{unserialize} = \&Apache::Session::Memorycached::none;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/MongoDB.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = Apache::Session::Store::MongoDB->new($self);
$self->{lock_manager} = Apache::Session::Lock::Null->new($self);
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::MongoDB::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::MongoDB::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/NoSQL.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = new Apache::Session::Store::NoSQL $self;
$self->{lock_manager} = new Apache::Session::Lock::Null $self;
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Base64::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Base64::unserialize;
#$self->{serialize} = \&Apache::Session::Serialize::Storable::serialize;
#$self->{unserialize} = \&Apache::Session::Serialize::Storable::unserialize;
view release on metacpan or search on metacpan
lib/Apache/Session/PHP.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = Apache::Session::Store::PHP->new($self);
$self->{lock_manager} = Apache::Session::Lock::Null->new($self);
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::PHP::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::PHP::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/SQLite.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = Apache::Session::Store::MySQL->new($self);
$self->{lock_manager} = Apache::Session::Lock::Null->new($self);
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Base64::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Base64::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/SQLite3.pm view on Meta::CPAN
my $self = shift;
$self->{object_store} = Apache::Session::Store::SQLite3->new($self);
$self->{lock_manager} = Apache::Session::Lock::Null->new($self);
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Storable::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Storable::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/SharedMem.pm view on Meta::CPAN
$self->{object_store} = new Apache::Session::Store::SharedMem $self;
$self->{lock_manager} = new Apache::Session::Lock::Null $self;
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Storable::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Storable::unserialize;
return $self;
}
view release on metacpan or search on metacpan
lib/Apache/Session/Wrapper.pm view on Meta::CPAN
{ description => 'An invalid parameter or set of parameters was given',
alias => 'param_error' },
);
use Params::Validate 0.70;
use Params::Validate qw( validate SCALAR UNDEF BOOLEAN ARRAYREF OBJECT );
Params::Validate::validation_options( on_fail => sub { param_error( join '', @_ ) } );
use Scalar::Util ();
lib/Apache/Session/Wrapper.pm view on Meta::CPAN
return $string;
}
sub RegisterClass {
my $class = shift;
my %p = validate( @_, { name => { type => SCALAR },
required => { type => SCALAR | ARRAYREF, default => [ [ ] ] },
optional => { type => SCALAR | ARRAYREF, default => [ ] },
},
);
lib/Apache/Session/Wrapper.pm view on Meta::CPAN
$class->_SetValidParams();
}
sub RegisterFlexClass {
my $class = shift;
my %p = validate( @_, { type => { type => SCALAR,
regex => qr/^(?:store|lock|generate|serialize)/,
},
name => { type => SCALAR },
required => { type => SCALAR | ARRAYREF, default => [ [ ] ] },
optional => { type => SCALAR | ARRAYREF, default => [ ] },
lib/Apache/Session/Wrapper.pm view on Meta::CPAN
}
sub session
{
my $self = shift;
my %p = validate( @_,
{ session_id =>
{ type => SCALAR,
optional => 1,
},
} );
view release on metacpan or search on metacpan
lib/Apache/Session/libmemcached.pm view on Meta::CPAN
my ($self) = @_;
$self->{object_store} = Apache::Session::Store::libmemcached->new($self);
$self->{lock_manager} = Apache::Session::Lock::Null->new($self);
$self->{generate} = \&Apache::Session::Generate::MD5::generate;
$self->{validate} = \&Apache::Session::Generate::MD5::validate;
$self->{serialize} = \&Apache::Session::Serialize::Storable::serialize;
$self->{unserialize} = \&Apache::Session::Serialize::Storable::unserialize;
return $self;
}
view release on metacpan or search on metacpan
SessionX.pm view on Meta::CPAN
if (defined $session_id && $session_id)
{
#check the session ID for remote exploitation attempts
#this will die() on suspicious session IDs.
#eval { &{$self->{validate}}($self); } ;
&{$self->{validate}}($self);
#if (!$@)
{ # session id is ok
$self->{status} &= ($self->{status} ^ NEW);
SessionX.pm view on Meta::CPAN
return new {$self -> {'args'}{'lock_manager'}} $self;
}
#
# Default validate for Apache::Session < 1.53
#
sub validate {
#This routine checks to ensure that the session ID is in the form
#we expect. This must be called before we start diddling around
#in the database or the disk.
my $session = shift;
SessionX.pm view on Meta::CPAN
$self->{object_store} = new $store $self if ($store) ;
$self->{lock_manager} = new $lock $self if ($lock);
$self->{generate} = \&{$gen . '::generate'} if ($gen);
$self->{'validate'} = \&{$gen . '::validate'} if ($gen && defined (&{$gen . '::validate'}));
$self->{serialize} = \&{$ser . '::serialize'} if ($ser);
$self->{unserialize} = \&{$ser . '::unserialize'} if ($ser) ;
if (!defined ($self->{'validate'}))
{
$self->{'validate'} = \&validate ;
}
$self->{populated} = 1 ;
}
else
{ # recreate only store & lock classes as far as necessary
view release on metacpan or search on metacpan
lib/Apache/SiteControl/User.pm view on Meta::CPAN
my $r = shift;
if(!defined($this) || !defined($r)) {
croak "INVALID CALL TO LOGOUT. You forgot to use OO syntax, or you forgot to pass the request object.";
}
eval("$this->{manager}" . '->invalidate($r, $this)');
if($@) {
$r->log_error("Logout failed: $@");
}
}
view release on metacpan or search on metacpan
lib/Apache/TS/AdminClient.pm view on Meta::CPAN
proxy.config.http.cache.required_headers
proxy.config.http.cache.vary_default_images
proxy.config.http.cache.vary_default_other
proxy.config.http.cache.vary_default_text
proxy.config.http.cache.when_to_add_no_cache_to_msie_requests
proxy.config.http.cache.when_to_revalidate
proxy.config.http.chunking_enabled
proxy.config.http.congestion_control.default.client_wait_interval
proxy.config.http.congestion_control.default.congestion_scheme
proxy.config.http.congestion_control.default.dead_os_conn_retries
proxy.config.http.congestion_control.default.dead_os_conn_timeout
view release on metacpan or search on metacpan
Template.xs view on Meta::CPAN
create_srv_config_sv, /* server config creator */
perl_perl_merge_srv_config, /* server config merger */
mod_cmds, /* command table */
NULL, /* [7] list of handlers */
NULL, /* [2] filename-to-URI translation */
NULL, /* [5] check/validate user_id */
NULL, /* [6] check user_id is valid *here* */
NULL, /* [4] check access by host address */
NULL, /* [7] MIME type checker/setter */
NULL, /* [8] fixups */
NULL, /* [10] logger */
view release on metacpan or search on metacpan
lib/Apache/TestConfig.pm view on Meta::CPAN
-e $vars->{t_conf_file} &&
-M $exe < -M $vars->{t_conf_file};
# any .in files are newer than their derived versions?
if (my @files = $self->extra_conf_files_needing_update) {
# invalidate the vhosts cache, since a different port could be
# assigned on reparse
$self->{vhosts} = {};
for my $file (@files) {
push @reasons, "$file.in is newer than $file";
}
view release on metacpan or search on metacpan
lib/Apache/Voodoo.pm view on Meta::CPAN
# If we got here we were sucessful
return 1;
}
# Function: validate_date
# Purpose: Check to make sure a date follows the MM/DD/YYYY format and checks the sanity of the numbers passed in
sub validate_date {
my $self = shift;
my $date = shift;
my $check_future = shift;
#Number of days in each month
view release on metacpan or search on metacpan
conf/server.xml.PL view on Meta::CPAN
SessionManager unless it is overridden. Note that the SessionManager
is not persistent and that a different session will be used for each
Application (single signon is not supported).
The maxInactiveInterval attribute specifies the number of seconds
after which an idle session is timed out (invalidated).
The cacheClass attribute specifies the name of the Cache::Cache implementation
class to use for the session cache.
-->
<SessionManager maxInactiveInterval="300"
view release on metacpan or search on metacpan
lib/HTML/FormValidator.pm view on Meta::CPAN
#
# FormValidator.pm - Object that validates form input data.
#
# This file is part of FormValidator.
#
# Author: Francis J. Lacoste <francis.lacoste@iNsu.COM>
#
lib/HTML/FormValidator.pm view on Meta::CPAN
In an HTML::Empberl page:
use HTML::FormValidator;
my $validator = new HTML::FormValidator( "/home/user/input_profiles.pl" );
my ( $valid, $missing, $invalid, $unknown ) = $validator->validate( \%fdat, "customer_infos" );
=head1 DESCRIPTION
HTML::FormValidator's main aim is to make the tedious coding of input
validation expressible in a simple format and to let the programmer focus
on more interesting task.
When you are coding web application one of the most tedious though
crucial task is to validate user's input (usually submitted by way of
an HTML form). You have to check that each required fields is present
and that some feed have valid data. (Does the phone input looks like a
phone number ? Is that a plausible email address ? Is the YY state
valid ? etc.) For simple form, this is not really a problem but as
forms get more complex and you code more of them this task became
really boring and tedious.
HTML::FormValidator lets you defines profiles which defines the
required fields and their format. When you are ready to validate the
user's input, you tell HTML::FormValidator the profile to apply to the
user data and you get the valid fields, the name of the fields which
are missing, the name of the fields that contains invalid input and
the name of the fields that are unknown to this profile.
lib/HTML/FormValidator.pm view on Meta::CPAN
will be used to check wheter or not the field contains valid data.
Constraint can be either the name of a builtin constraint function
(see below), a perl regexp or an anonymous subroutine which will check
the input and return true or false depending on the input's validity.
The constraint function takes one parameter, the input to be validated
and returns true or false. It is possible to specify the parameters
that will be passed to the subroutine. For that use an hash reference
which contains in the I<constraint> element, the anonymous subroutine
or the name of the builtin and in the I<params> element the name of
the fields to pass a parameter to the function. (Don't forget to
lib/HTML/FormValidator.pm view on Meta::CPAN
=pod
=head1 VALIDATING INPUT
my( $valids, $missings, $invalids, $unknowns ) =
$validator->validate( \%fdat, "customer_infos" );
To validate input you use the validate() method. This method takes two
parameters :
=over
=item data
Contains an hash which should correspond to the form input as
submitted by the user. This hash is not modified by the call to validate.
=item profile
Can be either a name which will be used to lookup the corresponding profile
in the input profiles specification, or it can be an hash reference to the
lib/HTML/FormValidator.pm view on Meta::CPAN
=back
=cut
sub validate {
my ( $self, $data, $name ) = @_;
my $profile;
if ( ref $name ) {
$profile = $name;
view release on metacpan or search on metacpan
lib/Apache2/API.pm view on Meta::CPAN
$resp->headers->set( 'Access-Control-Allow-Origin' => '*' );
}
# As an api, make sure there is no caching by default unless the field has already been set.
unless( $resp->headers->get( 'Cache-Control' ) )
{
$resp->headers->set( 'Cache-Control' => 'private, no-cache, no-store, must-revalidate' );
}
# If we have a locale set, we use it
my $locale;
if( $is_error )
lib/Apache2/API.pm view on Meta::CPAN
{
my $hash = $self->make( $pwd ) ||
return( $self->pass_error );
$self->hash( $hash );
}
# Existing hash path: validate by known prefixes, also extract salt into ->salt
elsif( $pwd =~ /\A$APR1_RE\z/ ||
$pwd =~ /\A$BCRYPT_RE\z/ ||
$pwd =~ /\A$SHA_RE\z/ )
{
$self->hash( $pwd );
view release on metacpan or search on metacpan
lib/Apache2/ASP/FormHandler.pm view on Meta::CPAN
use vars __PACKAGE__->VARS;
sub run {
my ($s, $context) = @_;
if( my $errors = $s->validate( $context ) ) {
$Session->{validation_errors} = $errors;
$Session->{__lastArgs} = $Form;
return $Response->Redirect( $ENV{HTTP_REFERER} );
}
lib/Apache2/ASP/FormHandler.pm view on Meta::CPAN
# Finally:
return $Response->Redirect( "/some/other/place.asp" );
}
sub validate {
my ($s, $context) = @_;
my $errors = { };
# Did they fill out the form?
view release on metacpan or search on metacpan
lib/Apache2/AuthCAS.pm view on Meta::CPAN
"PGT" => "CAS Proxy Service Error",
"PGT_RECEPTOR" => "Proxy Receptor Error",
"INVALID_RESPONSE" => "Invalid Service Response",
"INVALID_PGT" => "Invalid Proxy Granting Ticket",
"MISSING_PGT" => "Missing Proxy Granting Ticket",
"CAS_CONNECT" => "CAS couldn't validate service ticket",
);
my %DEFAULTS = (
"Host" => "localhost",
"Port" => "443",
lib/Apache2/AuthCAS.pm view on Meta::CPAN
}
# No session (or an expired one). Check for a ticket
if (my $ticket = $params{'ticket'})
{
# validate service ticket through CAS, since no valid cookie was found
my($error, $user, $pgtiou) = $self->validate_service_ticket($ticket);
if ($error)
{
return $self->redirect($self->casConfig("ErrorUrl"), $error);
}
lib/Apache2/AuthCAS.pm view on Meta::CPAN
}
}
# params
# apache request object
# ticket to be validated
# returns a hash with keys on success
# 'user', 'pgtiou'
# NULL on failure
sub validate_service_ticket($$$)
{
my($self, $ticket) = @_;
my $proxy = $self->casConfig("ProxyService") ? "1" : "0";
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
);
while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) {
$pattern =~ s{\s+}{\\s+}g;
if ( $license_text =~ /\b$pattern\b/i ) {
if ( $osi and $license_text =~ /All rights reserved/i ) {
print "WARNING: 'All rights reserved' in copyright may invalidate Open Source license.\n";
}
$self->license($license);
return 1;
}
}
view release on metacpan or search on metacpan
lib/Apache2/AuthCASpbh.pm view on Meta::CPAN
application directly accesses the unparsed URI it will still see the value.
=item C<AuthCAS_RequestPGT>
Whether or not to request a proxy granting ticket when a client service ticket
is validated; by default disabled.
=item C<AuthCAS_ServerURL>
The URL value to access the CAS authentication server; by default
"http://localhost/cas". For example: