Free 1.05 software for linux

Peng project consists of an AOL Linux dialer.

Peng is a free program for Linux that sets up a PPP, cable, or DSL connection for AOL or other providers by using a reverse engineered version of the AOL protocol.

It can be used from the command line and is known to work in several countries.

TxSig project is a small signature rotator.
It can randomly pick from a directory of files containing fortunes or quotes. It offers a variety of features such as compatibility with files from fortune. Users can generate their own quote files.
Main features:
- Quotes chosen based on length
- Quotes chosen based on rating
- Multiple configuration files
- Multiple quote/fortune files
- 100% Compatability with standard fortune files
- Drop-in compatability with pine V 4.44
- Optional apending of .signature (or any other file)
- Uses only standard perl modules
- Tastes Good
- Possibly Sexy
Enhancements:
- fixed a problem with creating and updating the data.cnt file

Plosxom is a blogsoftware written in PHP by Pali Dhar. The project is a rewrite of phposxom. Blogposts are stored in textfiles, categories are simple directories. Plosxom has a comprehensive plugin api, which allows to add almost any functionality or to replace existing functionality.
Phposxom were itself a php rewrite of blosxom, but the developer has abandoned the project. I am using it, because I cannot run perl where my site is hosted and because it is small. However, the sourcecode of phposxom were nearly unmaintanable, inefficient and bad styled (sorry Robert). Since I use it on an every day basis, I decided to completely rewrite it. Plosxom was born.
Many of the blosxom forks out there have been abandoned too, especially the php ports (there are lots of it). None of them seemed to be a usefull base for me. Most of them justify their decision that if it were developed further it would become too far to existing projects like wordpress and they didnt want to re-invent the wheel.
While I share this view in general, I also see a lot of disadvantages with wordpress: its storage backend cant be replaced. It depends on MySQL, which is the worst database system on the planet. With plosxom you could write a sqlite backend or whatever you like, even a mysql backend. Wordpress is also a "large biest", it contains a lot of source code and thus a lot of problems, especially from the security point of view.
Speaking of security - plosxom were developed with strong security in mind. Since there is almost no cgi input being used in the software, this goal were not difficult to achive. Everything which gets into the script will be filtered for bogus characters. Future attacks are hopefully prevented using this technique.
There is no administration backend delivered with plosxom, because you write textfiles (or upload them) - thats all. Without admin backend, the blog cant be hijacked like most other blogs could be.
The plosxom core engine is very small. In fact, I wrote it in just two days. This sounds like a hell of a crap, but it isnt. Much functionality is provided by plugins, even core functions, such as text file management, is coded as a plugin. Since we are using smarty as our template engine there are endless possibilities to enhance plosxom. You can write a simple plugin along with a simple smarty function and thats it.
For now, plosxom doesnt provide built-in comment support due to security reasons. Instead comments can be outsourced to Haloscan. However, perhaps someone will write a comment plugin some day, who knows.
Enhancements:
- This release comes with two new templates (blog.txt and crystalx) and a couple of some new plugins.
- Several bugs were fixed.
- Templates and plugins can be downloaded separately too.

Pod::TOC is a Perl module to extract a table of contents from a Pod file.

SYNOPSIS

This is a Pod::Simple subclass, so it can do the same things.
use Pod::TOC;

my $parser = Pod::TOC->new;

my $toc;
open my($output_fh), ">", $toc;

$parser->output_fh( $output_fh );

$parser->parse_file( $input_file );

This is a Pod::Simple subclass to extract a table of contents from a pod file. It has the same interface as Pod::Simple, and only changes the internal bits.

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.

Five Chess is a connect-five board game. Five Chess is released under the terms of GNU General Public License version 2.
It was initially developed from a qt Tic-Tac-Toe example.
Main features:
- 4 ways to play -- Human vs Human, AI vs Human, Human vs AI, AI vs AI
- 6 board sizes available -- 9X9 to 19X19
- Save Played games
- View played games
- Not so smart AI

NetCARD Config project helps linux users to configure network cards for two ip one for DSL network one for Local Network.

Cache::Cache Perl module contains the Cache interface.

The Cache modules are designed to assist a developer in persisting data for a specified period of time. Often these modules are used in web applications to store data locally to save repeated and redundant expensive calls to remote machines or databases. People have also been known to use Cache::Cache for its straightforward interface in sharing data between runs of an application or invocations of a CGI-style script or simply as an easy to use abstraction of the filesystem or shared memory.

The Cache::Cache interface is implemented by classes that support the get, set, remove, size, purge, and clear instance methods and their corresponding static methods for persisting data across method calls.

USAGE

First, choose the best type of cache implementation for your needs. The simplest cache is the MemoryCache, which is suitable for applications that are serving multiple sequential requests, and wish to avoid making redundant expensive queries, such as an Apache/mod_perl application talking to a database. If you wish to share that data between processes, then perhaps the SharedMemoryCache is appropriate, although its behavior is tightly bound to the underlying IPC mechanism, which varies from system to system, and is unsuitable for large objects or large numbers of objects.

When the SharedMemoryCache is not acceptable, then FileCache offers all of the same functionality with similar performance metrics, and it is not limited in terms of the number of objects or their size. If you wish to maintain a strict limit on the size of a file system based cache, then the SizeAwareFileCache is the way to go. Similarly, the SizeAwareMemoryCache and the SizeAwareSharedMemoryCache add size management functionality to the MemoryCache and SharedMemoryCache classes respectively.

Using a cache is simple. Here is some sample code for instantiating and using a file system based cache.

use Cache::FileCache;

my $cache = new Cache::FileCache( );

my $customer = $cache->get( $name );

if ( not defined $customer )
{
$customer = get_customer_from_db( $name );
$cache->set( $name, $customer, "10 minutes" );
}

return $customer;