This module provides single sign-on behavior. The user types a
passphrase when logging in and is allowed in if it decrypts the user s
SSH private key. An ssh-agent is started and keys are added. For the
entire session, the user types no more passwords.

lspci: This program displays detailed information about all PCI busses
and devices in the system, replacing the original /proc/pci interface.

setpci: This program allows reading from and writing to PCI device
configuration registers. For example, you can adjust the latency timers
with it.

update-pciids: This program downloads the current version of the
pci.ids file.

Alien::SDL can be used to detect and get configuration settings from an installed SDL and related libraries. Based on the platform it offers the possibility to download and install prebuilt binaries or to build SDL and co. from source codes.

The important facts: The module does not modify in any way the already existing SDL installation on your system. If you reinstall SDL libs on your system you do not need to reinstall Alien::SDL (providing that you use the same directory for the new installation).

Apache::AuthNetLDAP - mod_perl module that uses the Net::LDAP module
for user authentication for Apache. This module authenticates users
via LDAP using the Net::LDAP module. This module is Graham Barr's
"pure" Perl LDAP API. It also uses all of the same parameters as the
Apache::AuthPerLDAP, but I have added two extra parameters.

These modules are supposed to be used with the Apache server together
with an embedded perl interpreter like mod_perl. They provide support
for basic authentication and authorization as well as support for
persistent database connections via Perl's Database Independent
Interface (DBI).

In basic operation, each of the handlers Filter1, Filter2, and Filter3
will make a call to $r->filter_input(), which will return a filehandle.
For Filter1, the filehandle points to the requested file. For Filter2,
the filehandle contains whatever Filter1 wrote to STDOUT. For Filter3,
it contains whatever Filter3 wrote to STDOUT. The output of Filter3
goes directly to the browser.

Note that the modules Filter1, Filter2, and Filter3 are listed in
forward order, in contrast to the reverse-order listing of
Apache::OutputChain.

When you've got this module, you can use the same handler both as a
stand-alone handler, and as an element in a chain. Just make sure that
whenever you're chaining, all the handlers in the chain are "Filter-
aware," i.e. they each call $r->filter_register() exactly once, before
they start printing to STDOUT. There should be almost no overhead for
doing this when there's only one element in the chain.

These modules provide persistent storage for arbitrary data, in
arbitrary backing stores. The details of interacting with the backing
store are abstracted to make all backing stores behave alike. The
programmer simply interacts with a tied hash.

Apache::SessionX extends Apache::Session. It was initially written to
use Apache::Session from inside of HTML::Embperl, but is seems to be
useful outside of Embperl as well, so here is it as standalone module.

Pastebins (also known as nopaste sites) let you post text, usually code,
for public viewing. They're used a lot in IRC channels to show code that
would normally be too long to give directly in the channel (hence the name
nopaste).

Each pastebin is slightly different. When one pastebin goes down (I'm
looking at you, ), then you have to find a new one.
And if you usually use a script to publish text, then it's too much
hassle.

This module aims to smooth out the differences between pastebins, and
provides redundancy: if one site doesn't work, it just tries a different
one.

It's also modular: you only need to put on CPAN a
App::Nopaste::Service::Foo module and anyone can begin using it.

AppConfig is a Perl module for managing application configuration
information. It maintains the state of any number of variables and
provides methods for parsing configuration files and command line
arguments.

The Archive::Zip module allows a Perl program to create, manipulate, read,
and write Zip archive files.

Zip archives can be created, or you can read from existing zip files.

Once created, they can be written to files, streams, or strings. Members
can be added, removed, extracted, replaced, rearranged, and enumerated.
They can also be renamed or have their dates, comments, or other attributes
queried or modified. Their data can be compressed or uncompressed as
needed.

Members can be created from members in existing Zip files, or from existing
directories, files, or strings.

This module uses the the Compress::Raw::Zlib manpage library to read and
write the compressed streams inside the files.

One can use the Archive::Zip::MemberRead manpage to read the zip file
archive members as if they were files.

SASL is a generic mechanism for authentication used by several network
protocols. Authen::SASL provides an implementation framework that all
protocols should be able to share.

The framework allows different implementations of the connection class
to be plugged in. At the time of writing there were two such plugins.

This module allows you to execute code when perl finished compiling the
surrounding scope.

This Perl module provides an interface to most of the functionality available
in Berkeley DB versions 2, 3 and 4. In general it is safe to assume that the
interface provided here to be identical to the Berkeley DB interface. The main
changes have been to make the Berkeley DB API work in a Perl way. Note that if
you are using Berkeley DB 2.x, the new features available in
Berkeley DB 3.x or DB 4.x are not available via this module.

This module implements a virtual base class for parsing BIND server
version 8 configuration files (named.conf).

Bit::Vector is an efficient C library which allows you to handle
bit vectors, sets (of integers), "big integer arithmetic" and
boolean matrices, all of arbitrary sizes.

The library is efficient (in terms of algorithmical complexity)
and therefore fast (in terms of execution speed) for instance
through the widespread use of divide-and-conquer algorithms.

The package also includes an object-oriented Perl module for
accessing the C library from Perl, and optionally features
overloaded operators for maximum ease of use.

The C library can nevertheless be used stand-alone, without Perl.

BSD::Resource is a class implementing access to process resource limit
and priority functions (e.g. getrusage, setrlimit, etc).

Cairo provides Perl bindings for the vector graphics library cairo.
It supports multiple output targets, including PNG, PDF and SVG.
Cairo produces identical output on all those targets.

A very simple perl module that models a calendar month.

This function returns a data structure representing the dates in a month. The
data structure returned is an array of array references. The first level array
represents the weeks in the month. The second level array contains the actual
days. By default, each week starts on a Sunday and the value in the array is
the date of that day. Any days at the beginning of the first week or the end of
the last week that are from the previous or next month have the value undef.

Carp::Assert is intended for a purpose like the ANSI C library assert.h

This module is based on "'Carp.pm'" from Perl 5.005_03. It has been
modified to skip all package names matching the pattern given in the "use"
statement inside the "'qw()'" term (or argument list).

Suppose you have a family of modules or classes named "Pack::A", "Pack::B"
and so on, and each of them uses "'Carp::Clan qw(^Pack::);'" (or at least
the one in which the error or warning gets raised).

Thus when for example your script "tool.pl" calls module "Pack::A", and
module "Pack::A" calls module "Pack::B", an exception raised in module
"Pack::B" will appear to have originated in "tool.pl" where "Pack::A" was
called, and not in "Pack::A" where "Pack::B" was called, as the unmodified
"'Carp.pm'" would try to make you believe ':-)'.

This works similarly if "Pack::B" calls "Pack::C" where the exception is
raised, etcetera.

In other words, this blames all errors in the "'Pack::*'" modules on the
user of these modules, i.e., on you. ';-)'

The skipping of a clan (or family) of packages according to a pattern
describing its members is necessary in cases where these modules are not
classes derived from each other (and thus when examining '@ISA' - as in the
original "'Carp.pm'" module - doesn't help).

The purpose and advantage of this is that a "clan" of modules can work
together (and call each other) and throw exceptions at various depths down
the calling hierarchy and still appear as a monolithic block (as though
they were a single module) from the perspective of the caller.

In case you just want to ward off all error messages from the module in
which you "'use Carp::Clan'", i.e., if you want to make all error messages
or warnings to appear to originate from where your module was called (this
is what you usually used to "'use Carp;'" for ';-)'), instead of in your
module itself (which is what you can do with a "die" or "warn" anyway), you
do not need to provide a pattern, the module will automatically provide the
correct one for you.

I.e., just "'use Carp::Clan;'" without any arguments and call "carp" or
"croak" as appropriate, and they will automatically defend your module
against all blames!

In other words, a pattern is only necessary if you want to make several
modules (more than one) work together and appear as though they were only
one.

Forcing a Stack Trace
As a debugging aid, you can force "'Carp::Clan'" to treat a "croak" as
a "confess" and a "carp" as a "cluck". In other words, force a detailed
stack trace to be given. This can be very helpful when trying to
understand why, or from where, a warning or error is being generated.

This feature is enabled either by "importing" the non-existent symbol
'verbose', or by setting the global variable "'$Carp::Clan::Verbose'"
to a true value.

You would typically enable it by saying

use Carp::Clan qw(verbose);

Note that you can both specify a "family pattern" and the string
"verbose" inside the "'qw()'" term (or argument list) of the "use"
statement, but consider that a pattern of packages to skip is pointless
when "verbose" causes a full stack trace anyway.

CGI::Ajax is an object-oriented module that provides a unique mechanism for
using perl code asynchronously from javascript- enhanced HTML pages.
CGI::Ajax unburdens the user from having to write extensive javascript,
except for associating an exported method with a document-defined event
(such as onClick, onKeyUp, etc). CGI::Ajax also mixes well with HTML
containing more complex javascript.

CGI::Ajax supports methods that return single results or multiple results
to the web page, and supports returning values to multiple DIV elements on
the HTML page.

Using CGI::Ajax, the URL for the HTTP GET/POST request is automatically
generated based on HTML layout and events, and the page is then dynamically
updated with the output from the perl function. Additionally, CGI::Ajax
supports mapping URL's to a CGI::Ajax function name, so you can separate
your code processing over multiple scripts.

Other than using the Class::Accessor module to generate CGI::Ajax' accessor
methods, CGI::Ajax is completely self-contained - it does not require you
to install a larger package or a full Content Management System, etc.

We have added _support_ for other CGI handler/decoder modules, like the
CGI::Simple manpage or the CGI::Minimal manpage, but we can't test these
since we run mod_perl2 only here. CGI::Ajax checks to see if a header()
method is available to the CGI object, and then uses it. If method() isn't
available, it creates it's own minimal header.

A primary goal of CGI::Ajax is to keep the module streamlined and maximally
flexible. We are trying to keep the generated javascript code to a minimum,
but still provide users with a variety of methods for deploying CGI::Ajax.
And VERY little user javascript.