Free filter software for linux

POE::Filter::LZW::Progressive is a POE filter wrapped around Compress::LZW::Progressive.

Filter::cpp is a cpp source filter.

SYNOPSIS

use Filter::cpp ;

This source filter pipes the current source file through the C pre-processor (cpp) if it is available.

As with all source filters its scope is limited to the current source file only. Every file you want to be processed by the filter must have a

use Filter::cpp ;

near the top.

Here is an example script which uses the filter:

use Filter::cpp ;

#define FRED 1
$a = 2 + FRED ;
print "a = $an" ;
#ifdef FRED
print "Hello FREDn" ;
#else
print "Where is FREDn" ;
#endif

And here is what it will output:

a = 3
Hello FRED

This example below, provided by Michael G Schwern, shows a clever way to get Perl to use a C pre-processor macro when the Filter::cpp module is available, or to use a Perl sub when it is not.

# use Filter::cpp if we can.
BEGIN { eval use Filter::cpp }

sub PRINT {
my($string) = shift;

#define PRINT($string)
(print $string."n")
}

PRINT("Mu");

Look at Michaels Tie::VecArray module for a practical use.

bilateral filter is a denoising filter using the same technique as the selective gaussian blur, but with speedups and other enhancements.

The filter is slow when the blur radius is small but speeds up when the radius gets larger, which is the opposite behavior of the selective gaussian blur. Theres also an option for improved denoising of image gradients.

XML::Filter::Sort is a SAX filter for sorting elements in XML.

SYNOPSIS

use XML::Filter::Sort;
use XML::SAX::Machines qw( :all );

my $sorter = XML::Filter::Sort->new(
Record => person,
Keys => [
[ lastname, alpha, asc ],
[ firstname, alpha, asc ],
[ @age, num, desc]
],
);

my $filter = Pipeline( $sorter => *STDOUT );

$filter->parse_file(*STDIN);
Or from the command line:
xmlsort

This module is a SAX filter for sorting records in XML documents (including documents larger than available memory). The xmlsort utility which is included with this distribution can be used to sort an XML file from the command line without writing Perl code (see perldoc xmlsort).

SYNOPSIS

use POE::Filter::ErrorProof;
my $wheel = POE::Wheel::ReadWrite->new(
Filter => POE::Filter::ErrorProof->new(POE::Filter::Something->new()),
);

This module is a wrapper around other POE::Filters. I made this module when I noticed POE::Filter::XML would die() when non-XML input was given to it. The author of the module wasnt there, so I had to bring up a solution. You can use this module if you use a POE::Filter that might die if something bad happens. This Filter does nothing more than giving through the input in eval blocks.

THE NEW METHOD

POE::Filter::ErrorProof->new(); # Create a POE::Filter::ErrorProof with a POE::Filter::Stream in it
POE::Filter::ErrorProof->new(POE::Filter::XML->new()); # Do the same but with a POE::Filter::XML
POE::Filter::ErrorProof->new(POE::Filter::XML->new(), 1); # Do the same, but output errors on STDERR
POE::Filter::ErrorProof->new(POE::Filter::XML->new(), $socket); # Do the same, but output errors on this socket
$wheel = POE::Wheel::ReadWrite->new( .... );
POE::Filter::ErrorProof->new(POE::Filter::XML->new(), $wheel); # Output errors to this wheel

Filter::Simple::Compile is a drop-in replacement to Filter::Simple.

SYNOPSIS

Drop-in replacement for Filter::Simple:
package MyFilter;
use Filter::Simple::Compile;
FILTER { ... };

This way also works:
use Filter::Simple::Compile sub { ... };

This module lets you write Module::Compile extensions that are compatible with Filter::Simples API.

Additionally, no Filter::Simple::Compile does the same thing as use Filter::Simple::Compile, except the meaning for use and no will be reversed for your filter:

package MyFilter;
no Filter::Simple::Compile sub { ... }

# "no MyFilter" begins filtering
# "use MyFilter" terminates it

Compact Filter is a network packet filter for Linux. It features an easy-to-use compact filter representation and high performance.
The main features are: easy to use interface, compact filter representation (memory efficient), and very high performance.
A difference between CF and other firewalls, such as Netfilter, is its representation of the ruleset. In CF the user writes a filter which is then compiled and optimized in user-space. The optimized filter is then loaded into the kernel (using netlink). Consequently the in kernel packet filtering code only needs funtionality for setting up a filter and filtering packets, while the more complex code of optimizing the filter remains in user-space.
Because of the continuous increase of the bandwidth and the security threats, firewalls have to evolve towards more efficient filtering schemes. The truth is that the existing scheme does not scale so well with the combined growth of bandwidth and rulesets.
Our aim is to try another approach to perform packet filtering where we minimize the complexity of the filtering process. This result in, both, a reduction of the required CPU power to filter packets and a simpler (and smaller) kernel code. Of course, we are pushing all the smart and complex part out to the user-space, but, developing in user-space is much simpler and safer.
Enhancements:
- changed -d option to delete all filters
- added -D option to delete a specific filter
- changed default policy to permit rather than deny
- added -l option on flex to support --yylineno on older versions of flex
- new and improved install guide