This module is an authentication handler that uses the basic mechanism
provided by Apache2::AuthCookie with a DBI database for ticket-based
protection. It is based on two tokens being provided, a username and
password, which can be any strings (there are no illegal characters for
either). The username is used to set the remote user as if Basic
Authentication was used.

CGI::Application is intended to make it easier to create sophisticated,
reusable web-based applications.

This module implements a methodology which, if followed, will make your
web software easier to design, easier to document, easier to write, and
easier to evolve.

CGI::Application builds on standard, non-proprietary technologies and
techniques, such as the Common Gateway Interface and Lincoln D. Stein's
excellent CGI.pm module. CGI::Application judiciously avoids employing
technologies and techniques which would bind a developer to any one set
of tools, operating system or web server.

"Class::Spiffy" is a framework and methodology for doing object oriented
(OO) programming in Perl. Class::Spiffy combines the best parts of
Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation
class. It attempts to fix all the nits and warts of traditional Perl OO, in
a clean, straightforward and (perhaps someday) standard way.

This module manages a set of Log::Dispatch::* output objects that can be
logged to via a unified interface.

The idea is that you create a Log::Dispatch object and then add various
logging objects to it (such as a file logger or screen logger). Then you
call the 'log' method of the dispatch object, which passes the message to
each of the objects, which in turn decide whether or not to accept the
message and what to do with it.

This makes it possible to call single method and send a message to a log
file, via email, to the screen, and anywhere else, all with very little
code needed on your part, once the dispatching object has been created.

Module::Info gives you information about Perl modules *without actually
loading the module*. It actually isn't specific to modules and should work
on any perl code.

This module makes the functionality of the perltidy utility available to
perl scripts. Any or all of the input parameters may be omitted, in which
case the @ARGV array will be used to provide input parameters as described
in the perltidy(1) man page.

PostScript::Simple allows you to have a simple method of writing
PostScript files from Perl. It has several graphics primitives that
allow lines, circles, polygons and boxes to be drawn. Text can be added
to the page using standard PostScript fonts.

By default, this module exports a single hash ('%RE') that stores or
generates commonly needed regular expressions (see the "List of available
patterns" manpage).

There is an alternative, subroutine-based syntax described in the
"Subroutine-based interface" manpage.

"Spiffy" is a framework and methodology for doing object oriented (OO)
programming in Perl. Spiffy combines the best parts of Exporter.pm,
base.pm, mixin.pm and SUPER.pm into one magic foundation class. It
attempts to fix all the nits and warts of traditional Perl OO, in a
clean, straightforward and (perhaps someday) standard way. Spiffy
borrows ideas from other OO languages like Python, Ruby, Java and Perl
6. It also adds a few tricks of its own.

Testing is usually the ugly part of Perl module authoring. Perl gives you a
standard way to run tests with Test::Harness, and basic testing primitives
with Test::More. After that you are pretty much on your own to develop a
testing framework and philosophy. Test::More encourages you to make your
own framework by subclassing Test::Builder, but that is not trivial.

Test::Base gives you a way to write your own test framework base class that
_is_ trivial. In fact it is as simple as two lines:

package MyTestFramework;
use Test::Base -Base;

A module called 'MyTestFramework.pm' containing those two lines, will give
all the power of Test::More and all the power of Test::Base to every test
file that uses it. As you build up the capabilities of 'MyTestFramework',
your tests will have all of that power as well.

'MyTestFramework' becomes a place for you to put all of your reusable
testing bits. As you write tests, you will see patterns and duplication,
and you can "upstream" them into 'MyTestFramework'. Of course, you don't
have to subclass Test::Base at all. You can use it directly in many
applications, including everywhere you would use Test::More.

Test::Base concentrates on offering reusable data driven patterns, so that
you can write tests with a minimum of code. At the heart of all testing you
have inputs, processes and expected outputs. Test::Base provides some clean
ways for you to express your input and expected output data, so you can
spend your time focusing on that rather than your code scaffolding.

The YAML.pm module implements a YAML Loader and Dumper based on the YAML
1.0 specification. the http://www.yaml.org/spec/ manpage

YAML is a generic data serialization language that is optimized for human
readability. It can be used to express the data structures of most modern
programming languages. (Including Perl!!!)

For information on the YAML syntax, please refer to the YAML specification.

Psi is the premiere Instant Messaging application designed for
GNU/Linux, Microsoft Windows, Apple Mac OS X. Built upon an open
protocol named Jabber, Psi is a fast and lightweight messaging client
that utilises the best in open source technologies. Psi contains all
the features necessary to chat, with no bloated extras that slow your
computer down.

This package contains a plugin for "off the record" encryption (OTR).

A Bittorrent client using C++ / libtorrent and a Qt4 Graphical User Interface.
It aims to be as fast as possible and to provide multi-OS, unicode support.

Another frontend for the smpppd. With this frontend you can start and
stop a dialup network connection via your web browser.

An http-server such as Apache is required. The usage of mod-perl is not
a must, but recommended, because the speed improvement is significant.

Udhcp is a small dhcp client / server mainly used to support Xen
para-virtualized PXE booting.

Yafc is an OpenSource console mode FTP client. It has support for
Kerberos 4/5 authentication and sftp (ssh2). Other features include tab
completion, directory cache, powerful aliases, recursive file commands
and bookmarks with autologin.

Program for playing and analysing backgammon positions, games and matches. It's based on a neural network. It currently plays at about the level of a championship flight tournament player. Depending on its parameters and its luck in recent games, it rates from around 1900 to 2000 on FIBS, the First Internet Backgammon Server -- at its strongest, it ranks in the top 5 of over 6000 rated players there and is gradually improving.

Haserl is a small cgi wrapper that allows "PHP" style cgi programming,
but uses a UNIX bash-like shell or lua as the programming language. It
is very small, so it can be used in embedded environments, or where
something like PHP is too big.

It combines three features into a small cgi engine: * It parses
POST and GET requests, placing form-elements as name=value
pairs into the environment for the CGI script to use. This is
somewhat like the uncgi wrapper.

* It opens a shell, and translates all text into printable
statements. All text within ... ?> constructs are passed
verbatim to the shell. This is somewhat like writing PHP
scripts.

* It can optionally be installed to drop its permissions to the
owner of the script, giving it some of the security features of suexec
or cgiwrapper.

QXmpp is a cross-platform C++ XMPP client library. It is based on Qt and C++.

QXmpp is pretty intuitive and easy to use. It uses Qt extensively. Qt is the only
third party library it is dependent on. Users need to a have working knowledge of
C++ and Qt basics (Signals and Slots and Qt data types). The underlying TCP socket
and the XMPP RFCs (RFC3920 and RFC3921) have been encapsulated into classes and
functions. Therefore the user would not be bothered with these details. But it is
always recommended to the advanced users to read and enjoy the low level details.

mytop is a console-based (non-GUI) tool for monitoring the threads and
overall performance of MySQL 3.22.x, 3.23.x, and 4.x servers.

- With Term::ANSIColor installed you even get color.

- If you install Time::HiRes, get good real-time queries/second stats.

Nfswatch is a command-line tool for monitoring NFS traffic.
Nfswatch can capture and analyze the NFS packets on a particular
network interface or on all interfaces.

Apache::AuthCookie allows you to intercept a user's first
unauthenticated access to a protected document. The user will be
presented with a custom form where they can enter authentication
credentials. The credentials are posted to the server where AuthCookie
verifies them and returns a session key.

The session key is returned to the user's browser as a cookie. As a
cookie, the browser will pass the session key on every subsequent
accesses. AuthCookie will verify the session key and re-authenticate
the user.

All you have to do is write a custom module that inherits from
AuthCookie.

This module is an authentication handler that uses the basic mechanism
provided by Apache2::AuthCookie with a DBI database for ticket-based
protection. It is based on two tokens being provided, a username and
password, which can be any strings (there are no illegal characters for
either). The username is used to set the remote user as if Basic
Authentication was used.

CGI::Application is intended to make it easier to create sophisticated,
reusable web-based applications.

This module implements a methodology which, if followed, will make your
web software easier to design, easier to document, easier to write, and
easier to evolve.

CGI::Application builds on standard, non-proprietary technologies and
techniques, such as the Common Gateway Interface and Lincoln D. Stein's
excellent CGI.pm module. CGI::Application judiciously avoids employing
technologies and techniques which would bind a developer to any one set
of tools, operating system or web server.

"Class::Spiffy" is a framework and methodology for doing object oriented
(OO) programming in Perl. Class::Spiffy combines the best parts of
Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation
class. It attempts to fix all the nits and warts of traditional Perl OO, in
a clean, straightforward and (perhaps someday) standard way.