view release on metacpan or  search on metacpan

lib/Business/eWAY/RapidAPI.pm  view on Meta::CPAN

    else {
        $content_type = "application/json";
    }

    my $ua = $self->ua;
    $ua->credentials( $self->username, $self->password );
    my $resp;
    if ($is_post) {
        $resp = $ua->post(
            $url,
            Content        => $request,

 view release on metacpan or  search on metacpan

t/samples/slashdot.rss  view on Meta::CPAN

      <slash:section>hardware</slash:section>
      <slash:hit_parade>6,6,4,2,0,0,0</slash:hit_parade>
      <feedburner:origLink>http://slashdot.feedsportal.com/c/35028/f/647410/s/3c35f940/sc/38/l/0Lhardware0Bslashdot0Borg0Cstory0C140C0A70C0A60C0A0A392340Cby0E20A450Ethe0Etop0Especies0Ewill0Eno0Elonger0Ebe0Ehumans0Eand0Ethat0Ecould0Ebe0Ea0Eproblem0Dut...
    </item>
    
    <item><title>Two Earth-Like Exoplanets Don't Actually Exist</title><link>http://rss.slashdot.org/~r/Slashdot/slashdot/~3/NcsdVQtQOQQ/story01.htm</link><description>Two suspected exoplanets, Gliese 581g and 581d, have been shown to not exist, and ...

 view release on metacpan or  search on metacpan

docs/database.html  view on Meta::CPAN

   my @events = $schema->resultset('Event')->search( { hostname => 'foo' } );
</pre>

    <p>More typically you will not want to specify the user
    credentials in the script itself so the better approach is to use
    a configuration file. That can be done like this:</p>

<pre>
   use BuzzSaw::DB;

 view release on metacpan or  search on metacpan

lib/Buzznet/API.pm  view on Meta::CPAN

sub getXMLRPC
{
  my $self = shift;
  my $cli = RPC::XML::Client->new($self->url);
  $cli->credentials("Buzznet",$self->{"username"},$self->{"password"});
  my $request = $cli->request;
  return $cli;
}

sub sendRequest

 view release on metacpan or  search on metacpan

lib/CAM/App.pm  view on Meta::CPAN

=item authenticate

Test the login information, if any.  Currently no tests are performed
-- this is a no-op.  Subclasses may override this method to test login
credentials.  Even though it's currently trivial, subclass methods
should alway include the line:

    return undef if (!$self->SUPER::authenticate());

In case the parent authenticate() method adds a test in the future.

 view release on metacpan or  search on metacpan

lib/CDS.pm  view on Meta::CPAN

	my $protocol = lc($1);
	my $host = $2;
	my $path = $3;

	# Strip off user and password, if any
	my $credentials;
	if ($host =~ /^(.*)\@([^\@]*)$/) {
		$credentials = $1;
		$host = lc($2);
	} else {
		$host = lc($host);
	}

 view release on metacpan or  search on metacpan

lib/CGI/Application/Plugin/Authentication/Driver/CDBI.pm  view on Meta::CPAN

FIELD_METHODS supports filters as specified by 
CGI::Application::Plugin::Authentication::Driver

=head1 METHODS

=head2 verify_credentials

This method will test the provided credentials against the values found in 
the database, according to the Driver configuration.

=cut

sub verify_credentials {
  my $self = shift;
  my @creds = @_;

  my @_options=$self->options;
  die "The Class::DBI driver requires a hash of options" if @_options % 2;

lib/CGI/Application/Plugin/Authentication/Driver/CDBI.pm  view on Meta::CPAN

  my $cdbiclass=$options{CLASS};
  die "CLASS option must be set." unless($cdbiclass);

  return unless(scalar(@creds) eq scalar(@{$options{FIELD_METHODS}}));

  my @crednames=@{$self->authen->credentials};

  my %search;
  my %compare;
  my $i=0;

 view release on metacpan or  search on metacpan

lib/CGI/Application/Plugin/Authentication/Driver/DBIC.pm  view on Meta::CPAN

=back
    
=head1 METHODS

=head2 verify_credentials

This method will test the provided credentials against the values found in 
the database, according to the Driver configuration.

=cut

sub verify_credentials {
    my $self = shift;
    my @creds = @_;

    my @_options = $self->options;
    die "The Class::DBIx driver requires a hash of options" if @_options % 2;

lib/CGI/Application/Plugin/Authentication/Driver/DBIC.pm  view on Meta::CPAN

    my $class = $options{CLASS};
    die "CLASS option must be set." unless($class);

    return unless(scalar(@creds) eq scalar(@{$options{FIELD_METHODS}}));

    my @crednames=@{$self->authen->credentials};

    my %search;
    my %compare;
    my $i=0;

 view release on metacpan or  search on metacpan

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

the CGI::Application::Plugin::Authentication plugin.

There are two main decisions that you need to make when using this module.  How will
the usernames and password be verified (i.e. from a database, LDAP, etc...), and how
can we keep the knowledge that a user has already logged in persistent, so that they
will not have to enter their credentials again on the next request (i.e. how do we 'Store'
the authentication information across requests).

=head2 Choosing a Driver

There are three drivers that are included with the distribution.  Also, there

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

Authen::Simple for more information).  This should be enough to cover
everyone's needs.  

If you need to authenticate against a source that is not provided, you can use
the Generic driver which will accept either a hash of username/password pairs,
or an array of arrays of credentials, or a subroutine reference that can verify
the credentials.  So through the Generic driver you should be able to write
your own verification system.  There is also a Dummy driver, which blindly
accepts any credentials (useful for testing).  See the
L<CGI::Application::Plugin::Authentication::Driver::Generic>,
L<CGI::Application::Plugin::Authentication::Driver::DBI> and,
L<CGI::Application::Plugin::Authentication::Driver::Dummy> docs for more
information on how to use these drivers.  And see the L<Authen::Simple> suite
of modules for information on those drivers.

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

This Authentication plugin can handle ticket based authentication systems as well.  All that
is required of you is to write a Store module that can understand the contents of the ticket.
The Authentication plugin will require at least the 'username' to be retrieved from the
ticket.  A Ticket based authentication scheme will not need a Driver module at all, since the
actual verification of credentials is done by an external authentication system, possibly
even on a different host.  You will need to specify the location of the login page using
the LOGIN_URL configuration variable, and unauthenticated users will automatically
be redirected to your ticket authentication login page.

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

Here you can choose which authentication module(s) you want to use to perform the authentication.
For simplicity, you can leave off the CGI::Application::Plugin::Authentication::Driver:: part
when specifying the DRIVER name  If this module requires extra parameters, you
can pass an array reference that contains as the first parameter the name of the module,
and the rest of the values in the array will be considered options for the driver.  You can provide
multiple drivers which will be used, in order, to check the credentials until
a valid response is received.

     DRIVER => 'Dummy' # let anyone in regardless of the password

  - or -

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

        # Check for CREDENTIALS
        if ( defined $props->{CREDENTIALS} ) {
            croak "authen config error:  parameter CREDENTIALS is not a string or arrayref"
              if ref $props->{CREDENTIALS} && Scalar::Util::reftype( $props->{CREDENTIALS} ) ne 'ARRAY';
            $config->{CREDENTIALS} = delete $props->{CREDENTIALS};
            # We will accept a string, but what we really want is an arrayref of the credentials
            no warnings qw(uninitialized);
            $config->{CREDENTIALS} = [ $config->{CREDENTIALS} ] if Scalar::Util::reftype( $config->{CREDENTIALS} ) ne 'ARRAY';
        }

        # Check for LOGIN_SESSION_TIMEOUT

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

    $self->initialize;

    return $self->{is_new_login};
}

=head2 credentials

This method will return the names of the form parameters that will be
looked for during a login.  By default they are authen_username and authen_password,
but these values can be changed by supplying the CREDENTIALS parameters in the
configuration. Calling this function, will not itself generate cookies or session ids.

=cut

sub credentials {
    my $self = shift;
    my $config = $self->_config;
    return $config->{CREDENTIALS} || [qw(authen_username authen_password)];
}

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

}

=head2 drivers

This method will return a list of driver objects that are used for
verifying the login credentials. Calling this function, will not itself generate cookies or session ids.

=cut

sub drivers {
    my $self = shift;

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

    #  We do this before checking to see if the user is already logged in, since
    #  a logged in user may want to log in as a different user.
    my $field_names = $config->{CREDENTIALS} || [qw(authen_username authen_password)];

    my $query = $self->_cgiapp->query;
    my @credentials = map { scalar $query->param($_) } @$field_names;
    if ($credentials[0]) {
        # The user is trying to login
        # make sure if they are already logged in, that we log them out first
        my $store = $self->store;
        $store->clear if $store->fetch('username');
        foreach my $driver ($self->drivers) {
            if (my $username = $driver->verify_credentials(@credentials)) {
                # This user provided the correct credentials
                # so save this new login in the store
                my $now = time();
                $store->save( username => $username,  login_attempts => 0, last_login => $now, last_access => $now );
                $self->{is_new_login} = 1;
                # See if we are remembering the username for this user

lib/CGI/Application/Plugin/Authentication.pm  view on Meta::CPAN

sub authen_login_runmode {
    my $self   = shift;
    my $authen = $self->authen;

    my $credentials = $authen->credentials;
    my $username    = $credentials->[0];
    my $password    = $credentials->[1];

    my $html;
    if ( my $sub = $authen->_config->{RENDER_LOGIN} ) {
        $html = $sub->($self);
    }

 view release on metacpan or  search on metacpan

lib/CGI/Authen/Simple.pm  view on Meta::CPAN

 my $auth = CGI::Authen::Simple->new();
 $auth->logged_in() || $auth->auth();

 # do stuff here

 # if you need it, you can access the user's credentials like so:
 my $username = $auth->{'profile'}->{'username'};

 # assume your account table had other attributes, like full_name char(64)
 my $fullname = $auth->{'profile'}->{'full_name'};

 view release on metacpan or  search on metacpan

Authent.pm  view on Meta::CPAN

=head2 REMINDER

CGI::Authent doesn't validate the passwords. It cannot even see them. It
just does a few tests and if the tests fail it sends to the user a
request for authentication. But it's the server's task to validate the
credentials passed by the browser.

If you want for example to validate passwords against a database,
consult your servers documentation. You will probably have to install some filter or plugin.
It should be relatively easy to find such beasts on the net. I've written an ISAPI filter for this,
you may get it at http://jenda.krynicky.cz/authfilter.1.0.zip . Take it as an example, not as a solution!

 view release on metacpan or  search on metacpan

lib/CGI/Ex/Auth.pm  view on Meta::CPAN

            $self->no_cookies_print;
            return;
        }
    }

    # oh - you're still here - well then - ask for login credentials
    my $key_r = $self->key_redirect;
    local $form->{$key_r} = $form->{$key_r} || $self->script_name . $self->path_info . (scalar(keys %$form) ? "?".$self->cgix->make_form($form) : '');
    local $form->{'had_form_data'} = $args->{'had_form_data'} || 0;
    $self->login_print;
    my $data = $self->last_auth_data;
    eval { die defined($data) ? $data : "Requesting credentials" };

    # allow for a sleep to help prevent brute force
    sleep($self->failed_sleep) if defined($data) && $data->error ne 'Login expired' && $self->failed_sleep;
    $self->failure_hook;

 view release on metacpan or  search on metacpan

Auth.pm  view on Meta::CPAN

###########################################################

sub _login {
    
    ##
    ## check login credentials and load user profile
    ##
    
    my $self = shift;
    my ($username, $password) = @_;
    

 view release on metacpan or  search on metacpan

lib/CGI/Tiny/Cookbook.pod  view on Meta::CPAN

    }
  };

=head2 Sessions

Regardless of the session mechanism, login credentials should only be sent over
HTTPS, and passwords should be stored on the server using a secure one-way
hash, such as with L<Crypt::Passphrase>.

L<Basic authentication|https://en.wikipedia.org/wiki/Basic_access_authentication>
has historically been used to provide a simplistic login session mechanism
which relies on the client to send the credentials with every subsequent
request in that browser session. However, it does not have a reliable logout or
session expiration mechanism.

Basic authentication can be handled by the CGI server itself (e.g.
L<Apache|https://httpd.apache.org/docs/2.4/howto/auth.html>), which restricts

lib/CGI/Tiny/Cookbook.pod  view on Meta::CPAN

    $cgi->render(text => "Welcome, $authed_user!");
  };

A more sophisticated and modern login session mechanism is to store a session
cookie in the client, associated with a server-side session stored in a file or
database. Login credentials only need to be validated once per session, and
subsequently the session ID stored in the cookie will be sent by the client
with each request. This type of session can be ended by expiring the session
cookie and invalidating the session data on the server.

Some HTTP session management modules exist on CPAN, but the author has not yet

 view release on metacpan or  search on metacpan

t/20_valid_drupal.t  view on Meta::CPAN

if ( exists $ENV{'DRUPAL_TEST_CREDS'} ) { 
  %params = ( split ',', $ENV{'DRUPAL_TEST_CREDS'} );
} else {
  print  <<EOT;

   No database credentials found in ENV. 
   Skipping Drupal database tests.

   If you want to run these tests in the future,
   set the value of DRUPAL_TEST_CREDS in your ENV as
   documented in the source of this file,

t/20_valid_drupal.t  view on Meta::CPAN

  $skip++;
}

SKIP: {
  skip 'No database credentials supplied', 3, if $skip;

  my $drupal;
  my $dbh;

  subtest 'Object instantiation', sub {

 view release on metacpan or  search on metacpan

lib/CMS/Drupal.pm  view on Meta::CPAN

This module provides a Perl interface to a Drupal CMS website.

Since you can't do anything with Drupal until you can talk to the database,
this module doesn't do anything with the constructor but return a new object.
You can get a database handle to your Drupal by calling ->dbh() with your
database credentials as parameters.

You will need the appropriate DBI driver installed to connect to your
database. The DBI will hint at what you need if you don't have it, so
long as you set the 'driver' parameter correctly.

lib/CMS/Drupal.pm  view on Meta::CPAN

=back

B<End Quote>

If you leave the environment variable set, in future you won't have to supply
any credentials when calling this module's ->dbh() method:

  my $drupal = CMS::Drupal->new;
  my $dbh    = $drupal->dbh; # fatal error usually

It is not recommended to keep your credentials for a production database in
your environment as it's pretty easy to read it ...

=head1 SEE ALSO

=over 4

 view release on metacpan or  search on metacpan

corpus/dists/Ubic.changes  view on Meta::CPAN

1.43    2012-06-16
    * actually merge the fix

1.42    2012-06-15
    * critical bugfix: fix credentials application order
    (all non-root services were broken when operated from root, 1.39-1.41 releases were affected)

1.41    2012-06-11
    * pid2cmd doesn't die on errors
    * Ubic::Run supports the explicit service names

corpus/dists/Ubic.changes  view on Meta::CPAN

1.39    2012-05-23
    * new SimpleDaemon options:
     - reload_signal
     - daemon_user/daemon_group
    * 'credentials' option in start_daemon()
    * various doc improvements

1.38_01 2012-04-23
    * freebsd credentials fix - set real uid first and effective uid after that

1.38    2012-04-14
    * stable release

1.37_03 2012-04-13

corpus/dists/Ubic.changes  view on Meta::CPAN

1.29    2011-06-07
        * ubic-admin script: fix crontab install when user doesn't have previous crontab
        * ubic script: fix 'ubic unknown-cmd' error reporting
        * watchdog improvements:
         - don't ask for status twice if service works
         - permanently set credentials instead of using forks for non-root services
         - log status obtained by status check, instead of just logging 'service is broken'
        * POD improvements:
         - Ubic::Manual::Intro
         - Ubic::Manual::Multiservices
         - various POD fixes

 view release on metacpan or  search on metacpan

lib/CPAN/Maker.pm  view on Meta::CPAN

Example:

  version: 1.5.46
  project:
    git: https://github.com/rlauer6/perl-Amazon-Credentials
    description: "AWS credentials discoverer"
    author:
      name: Rob Lauer
      mailto: rlauer6@comcast.net
  pm_module: Amazon::Credentials
  include-version: no

 view release on metacpan or  search on metacpan

share/v3.json  view on Meta::CPAN

          "303": {
            "description": "duplicate report",
            "schema": { "$ref": "#/definitions/Error" }
          },
          "401": {
            "description": "invalid credentials",
            "schema": { "$ref": "#/definitions/Error" }
          },
          "400": {
            "description": "report contains errors",
            "schema": { "$ref": "#/definitions/Error" }

 view release on metacpan or  search on metacpan

lib/CPAN/Testers/Metabase/AWS.pm  view on Meta::CPAN

         namespace: prod

=head1 DESCRIPTION

This class instantiates a Metabase backend on the S3 and SimpleDB Amazon 
Web Services (AWS).  It uses L<Net::Amazon::Config> to provide user credentials
and the L<Metabase::Gateway> Role to provide actual functionality.  As such,
it is mostly glue to get the right credentials to setup AWS clients and provide
them with standard resource names.

For example, given the C<<< bucket >>> "example" and the C<<< namespace >>> "alpha",
the following resource names would be used:

lib/CPAN/Testers/Metabase/AWS.pm  view on Meta::CPAN

domain for indexing.

=item *

C<<< amazon_config >>> -- optional -- a L<Net::Amazon::Config> object containing
Amazon Web Service credentials.  If not provided, one will be created using
the default location for the config file.

=item *

C<<< profile_name >>> -- optional -- the name of a profile for use with 

 view release on metacpan or  search on metacpan

vhost/cgi-bin/templates/users/user-login-author.html  view on Meta::CPAN

<p>I'm sorry but that login was not recognised. Please try again, ensuring you 
enter the correct email address and password. Thank you.
[% ELSE %]<p>[% errmess %]</p>
[% END %]

<p>If you are an author, please login using your standard PAUSE credentials.
You will then be able to browse your distributions and mark the appropriate
reports, which you believe to have been made in error.</p>

<p>In the interests of security, your PAUSE credentials will be used to 
dynamically verify you are an author by PAUSE directly. Once successfully 
verified, your PAUSE ID only is then held for the duration of the current
session, and deleted when the current session times out.<p>

<p>Please note that for those authors who are testers as well as authors, 

 view release on metacpan or  search on metacpan

vhost/cgi-bin/templates/users/user-login-author.html  view on Meta::CPAN

<p>I'm sorry but that login was not recognised. Please try again, ensuring you 
enter the correct email address and password. Thank you.
[% ELSE %]<p>[% errmess %]</p>
[% END %]

<p>If you are an author, please login using your standard PAUSE credentials.
You will then be able to browse your distributions and mark the appropriate
reports, which you believe to have been made in error.</p>

<p>In the interests of security, your PAUSE credentials will be used to 
dynamically verify you are an author by PAUSE directly. Once successfully 
verified, your PAUSE ID only is then held for the duration of the current
session, and deleted when the current session times out.<p>

<p>Please note that for those authors who are testers as well as authors, 

 view release on metacpan or  search on metacpan

t/data/61daily.eml  view on Meta::CPAN

If you have an issue with a particular report, or wish to gain further information from the tester, please use the 'Find A Tester' tool at http://stats.cpantesters.org/cpanmail.html, using the ID or GUID of the report, as listed above, to locate the ...

You can also adjust the frequency and nature of these notifications or unsubscribe from the notifications entirely, by going to the CPAN Testers Preferences website (https://prefs.cpantesters.org) and login with your PAUSE credentials. You can disabl...

Thanks,
The CPAN Testers
-- 
Reports:     http://www.cpantesters.org

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.010     2023-01-24 17:14:30+01:00 Europe/Amsterdam
          - Assume Term::ReadKey is always present
          - Add missing documentation for new_from_config_or_stdin

0.009     2018-12-16 16:31:13+01:00 Europe/Amsterdam
          - Add fallback to ask for credentials on command line

0.008     2018-05-02 20:28:36+02:00 Europe/Amsterdam
          - Add ?ACTION=add_uri to PAUSE upload URI

0.007     2018-04-23 13:12:48+02:00 Europe/Amsterdam

Changes  view on Meta::CPAN

0.006     2018-04-23 11:55:10+02:00 Europe/Amsterdam
          - Re-add ExecDir to the dzil configuration

0.005     2018-04-19 16:58:28+02:00 Europe/Amsterdam
          - Support reserved characters in credentials
          - Improve error messages for internal errors

0.004     2017-05-14 12:30:44+02:00 Europe/Paris
          - Fix user attribute name

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.103006  2013-12-13 08:18:36 America/New_York
          update bugtracker and repo metadata

0.103005  2013-07-01 19:01:17 America/New_York
          Use Config::Identity to permit GPG-encrypting on-disk credentials
          (thanks, Mike Doherty)

0.103004  2013-03-12 15:51:43 America/New_York
          like 0.103003, but a production release

 view release on metacpan or  search on metacpan

lib/CPAN/FTP.pm  view on Meta::CPAN

        } else {
            $CPAN::Frontend->mywarn("  Could not determine host from http_proxy '$http_proxy'\n");
        }
        if ($want_proxy) {
            my($user, $pass) =
                CPAN::HTTP::Credentials->get_proxy_credentials();
            $ret = {
                    proxy_user => $user,
                    proxy_pass => $pass,
                    http_proxy => $http_proxy
                  };

 view release on metacpan or  search on metacpan

cpan-security-advisory.json  view on Meta::CPAN

{"meta":{"generator":"util/generate","repo":"https://github.com/briandfoy/cpan-security-advisory.git","date":"Tue Jun 17 23:20:10 2025","commit":"c4ad860d9c66a9f741fa520a4472eac57693609c","epoch":1750202410},"dists":{"App-Context":{"versions":[{"date...

 view release on metacpan or  search on metacpan

lib/CPM.pm  view on Meta::CPAN

The CPM functionality is completely defined by its configuration file (config.xml) that acts also, as firmware of the module.

=head1 Configuration sample

The CPM needs a default configuration file that must be adjusted by the user, at least, including his credentials (valid user in MyPrinterCloud).

<?xml version="1.0" encoding="UTF-8"?>
  <opt call="http://myprintercloud.nubeprint.com/np/selector.pl" proxy="" >
    <id comm="call" 
        date="2010-09-10"

 view release on metacpan or  search on metacpan

lib/Cal/DAV.pm  view on Meta::CPAN

    for (qw(user pass url)) {
        die "You must pass in a $_ param\n" unless defined $args{$_};
        $opts{"-${_}"} = $args{$_};
    }
    my $dav  = HTTP::DAV->new;
    $dav->credentials(%opts);
    return bless { _dav => $dav, url => $args{url}, _auto_commit => $args{auto_commit} }, $class;
}

=head2 parse <arg[s]>

 view release on metacpan or  search on metacpan

lib/Captive/Portal/Role/AuthenSimple.pm  view on Meta::CPAN

    return 1;
}

=item $capo->authenticate($username, $password)

Call the authenticator object with credentials. Returns true on success and false on failure.

=cut

sub authenticate {
    my $self = shift;