Mail::SPF is an object-oriented implementation of Sender Policy Framework
(SPF). See http://www.openspf.org for more information about SPF.

This class collection aims to fully conform to the SPF specification (RFC 4408)
so as to serve both as a production quality SPF implementation and as a
reference for other developers of SPF implementations.

a set of perl modules related to mail applications

MIME::Charset provides informations about character sets used for MIME messages
on Internet.

modules for parsing (and creating!) MIME entities

`Module::Build' is a system for building, testing, and installing Perl modules. It is meant to be an alternative to `ExtUtils::MakeMaker'. Developers may alter the behavior of the module through subclassing in a much more straightforward way than with `MakeMaker'. It also does not require a `make' on your system - most of the `Module::Build' code is
pure-perl and written in a very cross-platform way. In fact, you don`t even need a shell, so even platforms like MacOS (traditional) can use it fairly easily. Its only prerequisites are modules that are included with perl 5.6.0, and it works fine on perl 5.005 if you can install a few additional modules.

Module::Find lets you find and use modules in categories. This can be very useful for auto-detecting driver or plugin modules. You can differentiate between looking in the category itself or in all subcategories.

If you want Module::Find to search in a certain directory on your harddisk (such as the plugins directory of your software installation), make sure you modify @INC before you call the Module::Find functions.

This module deals with the examination of the namespace of Perl modules.
The contents of the module namespace is split across several physical
directory trees, but this module hides that detail, providing instead
a view of the abstract namespace.

Faster alternative to Net::CIDR when merging a large number of CIDR
address ranges. Works for IPv4 and IPv6 addresses.

Authors:
--------
Douglas Wilson

Net::DNS is a Perl interface to the DNS resolver. It allows the programmer to perform any type of DNS query from a Perl script. For details and examples, please read the Net::DNS manual page.

The 'Net::HTTP' class is a low-level HTTP client. An instance of the
'Net::HTTP' class represents a connection to an HTTP server. The HTTP
protocol is described in RFC 2616. The 'Net::HTTP' class supports
'HTTP/1.0' and 'HTTP/1.1'.

'Net::HTTP' is a sub-class of 'IO::Socket::INET'. You can mix the methods
described below with reading and writing from the socket directly. This is
not necessary a good idea, unless you know what you are doing.

You can either use the simple interface, which does one ident lookup at a
time, or use the asynchronous interface to perform (possibly) many
simultaneous lookups, or simply continue serving other things while the
lookup is proceeding.

NOTE: Automatically created during Factory devel project migration by admin.

Net::Server is an extensible, generic Perl server engine. Net::Server combines the good properties from Net::Daemon (0.34), NetServer::Generic (1.03), and Net::FTPServer (1.0), and also from various concepts in the Apache Webserver.

The Net::SNMP module implements an object oriented interface to the
Simple Network Management Protocol.

NOTE: Automatically created during Factory devel project migration by admin.

Net::Telnet allows you to make client connections to a TCP port and do
network I/O, especially to a port using the TELNET protocol. Simple
I/O methods such as print, get, and getline are provided. More
sophisticated interactive features are provided because connecting to a
TELNET port ultimately means communicating with a program designed for
human interaction. These interactive features include the ability to
specify a time-out and to wait for patterns to appear in the input
stream, such as the prompt from a shell.

Number::Compare compiles a simple comparison to an anonymous subroutine, which you can call with a value to be tested again.
Now this would be very pointless, if Number::Compare didn't understand magnitudes.
The target value may use magnitudes of kilobytes (k, ki), megabytes (m, mi), or gigabytes (g, gi). Those suffixed with an i use the appropriate 2**n version in accordance with the IEC standard: http://physics.nist.gov/cuu/Units/binary.html

Manipulating stashes (Perl's symbol tables) is occasionally necessary, but
incredibly messy, and easy to get wrong. This module hides all of that
behind a simple API.

NOTE: Most methods in this class require a variable specification that
includes a sigil. If this sigil is absent, it is assumed to represent the
IO slot.

Due to limitations in the typeglob API available to perl code, and to
typeglob manipulation in perl being quite slow, this module provides two
implementations - one in pure perl, and one using XS. The XS implementation
is to be preferred for most usages; the pure perl one is provided for cases
where XS modules are not a possibility. The current implementation in use
can be set by setting '$ENV{PACKAGE_STASH_IMPLEMENTATION}' or
'$Package::Stash::IMPLEMENTATION' before loading Package::Stash (with the
environment variable taking precedence), otherwise, it will use the XS
implementation if possible, falling back to the pure perl one.

The Params::Validate module allows you to validate method or function
call parameters to an arbitrary level of specificity. At the simplest
level, it is capable of validating the required parameters were given
and that no unspecified additional parameters were passed in.

It is also capable of determining that a parameter is of a specific
type, that it is an object of a certain class hierarchy, that it
possesses certain methods, or applying validation callbacks to
arguments.

RecDescent incrementally generates top-down recursive-descent text
parsers from simple yacc-like grammar specifications.

Authors:
--------
Damian Conway

Parse::Yapp (Yet Another Perl Parser compiler) is a collection of
modules that let you generate and use yacc like thread safe (reentrant)
parsers with perl object oriented interface.

This is a companion module to Readonly.pm. You do not use
Readonly::XS directly. Instead, once it is installed, Readonly.pm
will detect this and will use it for creating read-only scalars. This
results in a significant speed improvement. This does not speed up
read-only arrays or hashes.

Authors:
--------
Eric Roode,