Free matches fashion software for linux

THREDDS (short from Thematic Realtime Environmental Distributed Data Services) project is developing middleware to bridge the gap between data providers and data users. The goal is to simplify the discovery and use of scientific data and to allow scientific publications and educational materials to reference scientific data.

The mission of THREDDS is for students, educators and researchers to publish, contribute, find, and interact with data relating to the Earth system in a convenient, effective, and integrated fashion.

Just as the World Wide Web and digital library technologies have simplified the process of publishing and accessing multimedia documents, THREDDS is building infrastructure needed for publishing and accessing scientific data in a similarly convenient fashion.

ttywatch is a project based on monitoring logs and multiplexes terminal I/O.
It has full log rotation built in, and can use telnet as well as local TTY ports.
Main features:
- Handles log rotation correctly.
- Can be configured in both a configuration file and on the command line (mix-and-match command-line and config file). The config file language is the same as the command-line language; learn one and you know both. Any configuration that can be specified on the command line can be specified in exactly the same way in a configuration file, and vice versa.
- Supports arbitrary data logging methods via dynamically loaded modules.
- Can optionally connect any monitored port to a network socket, and it can support arbitrarily many telnet connections to each port. The connections work together in "whiteboard" fashion; all output is shown to every connection and input is accepted from all connections.
- Can connect to network ports speaking the telnet protocol as well as to serial ports; this allows ttywatch instances to be cascaded. For example, in a room full of servers, each with two serial ports, you could run ttywatch on computer in pairs, each logging output from the other, and then use ttywatch on a master computer to log all the output from each ttywatch instance on the individual computers in one master set of logfiles.
- Includes a fairly complete man page.
- Is packaged with all the pieces necessary for use, including config files, init script, and so forth.
- Depends on lockdev, popt, and glib.

Regexp::MatchContext is Perl module to replace (and improve) $MATCH, $PREMATCH, and $POSTMATCH

SYNOPSIS

use Regexp::MatchContext -vars;

$str = m/(?p) d+ /;

print "Before: $PREMATCHn";
print "Matched: $MATCHn";
print "After: $POSTMATCHn";

$MATCH = 2 * $MATCH; # substitute into original $str

The English.pm module provides named aliases for Perls built-in $`, $& and $ variables: $PREMATCH, $MATCH, and $POSTMATCH. Unfortunately, those aliases suffer the same problems as their originals: they degrade the performance of every single regex in your program, even if youre only using them to get information about a single match.

This module also provides $PREMATCH, $MATCH, and $POSTMATCH, but in a way that only impacts the performance of matches that you specify. That is, these three variables are only set if the most recently matched regex contained the special (non-standard) meta- flag: (?p).

That is:

use Regexp::MatchContext -vars;

$str = foobarbaz;

$str =~ /(?p) foo /x;

# $PREMATCH contains foo
# $MATCH contains bar
# $POSTMATCH contains baz

$str =~ / foo /x;

# $PREMATCH, $MATCH, and $POSTMATCH all undef

The (?p) marker can be placed anywhere within the regex and, except for setting the three context variables on a successful match, is otherwise totally ignored.

regular expression parser is a C++ regexp parser that accomplishes The Open Group specification Issue 6, IEEE Std 1003.1, 2004 Edition.

regular expression parser allows you to parse input using regular expressions, and to retrieve parsed sub-expression matches in a few steps.

Net::ACL::Match::IP is a class matching IP addresses against an IP or network.

SYNOPSIS

use Net::ACL::Match::IP;
# Constructor
$match = new Net::ACL::Match::IP(1,10.0.0.0/8);
# Accessor Methods
$netmaskobj = $match->net($netmaskobj);
$netmaskobj = $match->net($net);
$index = $match->index($index);
$rc = $match->match($ip);
__top

This module is just a wrapper of the Net::Netmask module to allow it to operate automatically with Net::ACL::Rule.

C::Scan is a Perl module that can scan C language files for easily recognized constructs.

SYNOPSIS

$c = new C::Scan filename => $filename, filename_filter => $filter,
add_cppflags => $addflags;
$c->set(includeDirs => [$Config::Config{shrpdir}]);

my $fdec = $c->get(parsed_fdecls);

This description is VERY incomplete.

This module uses Data::Flow interface, thus one uses it in the following fashion:

$c = new C::Scan(attr1 => $value1, attr2 => $value2);
$c->set( attr3 => $value3 );

$value4 = $c->get(attr4);

Attributes are depending on some other attributes. The only required attribute, i.e., the attribute which should be set, is filename, which denotes which file to parse.

All other attributes are either optional, or would be calculated basing on values of required and optional attributes.

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.

maRBL project is a policy daemon for Postfix that lets you trigger any Postfix action as a result of an RBL match.

There are only a couple good, practical options for spam filtering, but none of them are 100% effective. Statistical filters can come very close to perfection, but at the cost of CPU time -- you cant filter something until youve received it and spent some time analyzing it -- and there are few good options for blocking hosts outright.

What about RBLs?
RBLs are simple, fast and efficient but they frequently have false positives. Theres an implicit level of trust required: you have to trust RBL administrators to add and remove hosts in a timely and accurate fashion from their lists. The problem is that only a fraction of lists are entirely automated, mosts have humans involved in the process, and humans are fallible. Worse, humans are vindictive, many lists go for collateral damage by blocking large ranges of IP addresses in an effort to arm-twist ISPs into being more responsive about their spam problem.

What about Greylisting?
Greylisting relies on the fact that most spam is no longer sent through real mail servers, and instead is sent from subpar SMTP engines. Greylisting forces senders to wait for a period of time and retry, something many of these engines are incapable of. The problems are that it fares poorly when handling mail from large ISPs that have SMTP clusters (theres no guarantee that the retry will come from the same IP address), that it introduces more delay to the process of receiving an email, and that occasionally you will run across non-RFC compliant mailservers that treat a temporary delivery failure as a permanent one.