Class::ErrorHandler provides an error-handling mechanism that's generic enough
to be used as the base class for a variety of OO classes. Subclasses inherit
its two error-handling methods, error and errstr, to communicate error messages
back to the calling program.

This package is based on the package 'perl-Class-Inspector' from project 'openSUSE:Factory'.

Class::Inspector allows you to get information about a loaded class.
Most or all of this information can be found in other ways, but they
are not always very conveniet, and usually involve a relatively high
level of Perl wizardry, or strange and unusual looking code.
Class-Inspector attempts to provide an easier, more friendly interface
to this information.

Certain applications like to defer the decision to use a particular module till
runtime. This is possible in perl, and is a useful trick in situations where
the type of data is not known at compile time and the application doesn't wish
to pre-compile modules to handle all types of data it can work with. Loading
modules at runtime can also provide flexible interfaces for perl modules.
Modules can let the programmer decide what modules will be used by it instead
of hard-coding their names.

Class::Loader is an inheritable class that provides a method, _load(), to load
a module from disk and construct an object by calling its constructor. It also
provides a way to map modules names and associated metadata with symbolic names
that can be used in place of module names at _load().

This module converts hashes of binary octets into ASCII messages suitable for
transfer over 6-bit clean transport channels. The encoded ASCII resembles PGP's
armoured messages, but are in no way compatible with PGP.

Convert::PEM reads and writes PEM files containing ASN.1-encoded objects. The files can optionally be encrypted using a symmetric cipher algorithm, such as 3DES.

Crypt::DES_EDE3 implements DES-EDE3 encryption. This is triple-DES encryption
where an encrypt operation is encrypt-decrypt-encrypt, and decrypt is decrypt-
encrypt-decrypt. This implementation uses Crypt::DES to do its dirty DES work,
and simply provides a wrapper around that module: setting up the individual DES
ciphers, initializing the keys, and performing the encryption/decryption steps.

Crypt::DH is a Perl implementation of the Diffie-Hellman key exchange system.
Diffie-Hellman is an algorithm by which two parties can agree on a shared
secret key, known only to them. The secret is negotiated over an insecure
network without the two parties ever passing the actual shared secret, or their
private keys, between them.

Crypt::DSA is an implementation of the DSA (Digital Signature Algorithm)
signature verification system. The implementation itself is pure Perl, although
the heavy-duty mathematics underneath are provided by the Math::Pari library.

This package provides DSA signing, signature verification, and key generation.

This perl extension is an implementation of the IDEA block cipher algorithm.
The module implements the Crypt::BlockCipher interface.

Crypt::Random is an interface module to the /dev/random device found on most
modern Unix systems. The /dev/random driver gathers environmental noise from
various non-deterministic sources including inter-keyboard timings and inter-
interrupt timings that occur within the operating system environment.

The /dev/random driver maintains an estimate of true randomness in the pool and
decreases it every time random strings are requested for use. When the estimate
goes down to zero, the routine blocks and waits for the occurrence of non-
deterministic events to refresh the pool.

The /dev/random kernel module also provides another interface, /dev/urandom,
that does not wait for the entropy-pool to recharge and returns as many bytes
as requested. /dev/urandom is considerably faster at generation compared to
/dev/random, which should be used only when very high quality randomness is
desired.

Crypt::RSA is a pure-perl, cleanroom implementation of the RSA public-key
cryptosystem. It uses Math::Pari(3), a perl interface to the blazingly fast
PARI library, for big integer arithmetic and number theoretic computations.

Crypt::RSA provides arbitrary size key-pair generation, plaintext-aware
encryption (OAEP) and digital signatures with appendix (PSS). For
compatibility with SSLv3, RSAREF2, PGP and other applications that follow the
PKCS #1 v1.5 standard, it also provides PKCS #1 v1.5 encryption and signatures.

Data::Buffer implements a low-level binary buffer in which you can get and put
integers, strings, and other data. Internally the implementation is based on
pack and unpack, such that Data::Buffer is really a layer on top of those
built-in functions.

This module provide a single function called dump() that takes a list of
values as argument and produce a string as result. The string contains perl
code that when evaled will produce a deep copy of the original arguments. The
string is formatted for easy reading.

The Devel::StackTrace module contains two classes, Devel::StackTrace and
Devel::StackTraceFrame. The goal of this object is to encapsulate the
information that can found through using the caller() function, as well
as providing a simple interface to this data.

The Devel::StackTrace object contains a set of Devel::StackTraceFrame
objects, one for each level of the stack. The frames contain all the
data available from "caller()".

This code was created to support my Exception::Class::Base class (part
of Exception::Class) but may be useful in other contexts.

Authors: Dave Rolsky,

Digest::BubbleBabble takes a message digest (generated by either of the MD5 or
SHA-1 message digest algorithms) and creates a fingerprint of that digest in
"bubble babble" format. Bubble babble is a method of representing a message
digest as a string of "real" words, to make the fingerprint easier to remember.
The "words" are not necessarily real words, but they look more like words than
a string of hex characters.

Bubble babble fingerprinting is used by the SSH2 suite (and, consequently, by
Net::SSH::Perl, the Perl SSH implementation) to display easy-to-remember key
fingerprints. The key (a DSA or RSA key) is converted into a textual form,
digested using Digest::SHA1, and run through bubblebabble to create the key
fingerprint.

The Digest::MD5 module allows you to use the RSA Data Security Inc. MD5 Message Digest algorithm from within Perl programs. The algorithm takes as input a message of arbitrary length and produces as output a 128-bit "fingerprint" or "message digest" of the input.

Email::Abstract provides module writers with the ability to write representation-independent mail handling code. For instance, in the cases of Mail::Thread or Mail::ListDetector, a key part of the code involves reading the headers from a mail object. Where previously one would either have to specify the mail class required, or to build a new object from scratch, Email::Abstract can be used to perform certain simple operations on an object regardless of its underlying representation.
Email::Abstract currently supports Mail::Internet, MIME::Entity, Mail::Message, Email::Simple and Email::MIME. Other representations are encouraged to create their own Email::Abstract::* class by copying Email::Abstract::EmailSimple. All modules installed under the Email::Abstract hierarchy will be automatically picked up and used.

RFC 2822 defines the Date: header. It declares the header a required part of an email message. The syntax for date headers is clearly laid out. Stil, even a perfectly planned world has storms. The truth is, many programs get it wrong. Very wrong. Or, they don't include a Date: header at all. This often forces you to look elsewhere for the date, and hoping to find something.
For this reason, the tedious process of looking for a valid date has been encapsulated in this software. Further, the process of creating RFC compliant date strings is also found in this software.

Email::Find is a module for finding a *subset* of RFC 822 email addresses in
arbitrary text. The addresses it finds are not guaranteed to exist or even
actually be email addresses at all, but they will be valid RFC 822 syntax.

Email::Find will perform some heuristics to avoid some of the more obvious red
herrings and false addresses, but there's only so much which can be done
without a human.

Message-ids are optional, but highly recommended, headers that identify a message uniquely. This software generates a unique message-id.

This is an extension of the Email::Simple module, to handle MIME encoded messages. It takes a message as a string, splits it up into its constituent parts, and allows you access to various parts of the message. Headers are decoded from MIME encoding.

Given a Email::MIME object, detach all attachments from the message. These are then available separately.

This routine parses email content type headers according to section 5.1 of RFC 2045. It returns a hash as above, with entries for the discrete type, the composite type, and a hash of attributes.

This module simply wraps MIME::Base64 and MIME::QuotedPrint so that you can throw the contents of a Content-Transfer-Encoding header at some text and have the right thing happen.

This software takes the hard out of generating replies to email messages.