Free sep software for linux

RWSecure application parses the /var/log/secure file for invalid usernames or failed passwords to help protect against brute force and similar attacks.
If there are more than three invalid or failed attempts by one IP, it will add that IP to your /etc/hosts.deny file.
Put this file in any directory of your choice and use the cron to run this program every
few minutes, hours, or days... adding this entry to your crontab will have it run every 5 minutes:
*/5 * * * * root /yourdirectory/rwsecure
This is just an example of a way to run it without user intervention.
Suggest you stop logging info level messages from auth, or log them in a seperate file, if you run this program every few minutes as misc cron messages can start to fill your logs.
Program will append to /etc/hosts.deny (however, this file can be changed by changing the variable in rwsecure, just vi rwsecure and make change the HostsDenypath to whatever you want)
Sample program output:
ALL: 82.140.81.26 # Added by rwsecure on Sep 17 18:18:01 2005
ALL: 67.15.20.58 # Added by rwsecure on Sep 18 04:42:01 2005
ALL: 211.78.142.116 # Added by rwsecure on Sep 18 06:22:01 2005
ALL: 130.215.226.185 # Added by rwsecure on Sep 19 04:26:01 2005
ALL: 70.85.221.46 # Added by rwsecure on Sep 21 09:26:01 2005
Enhancements:
- Improved handling of IPv6 and illegal users.

OSSP val is a flexible name to value mapping library for C variables. It is a companion library to OSSP var. It allows one to access C variables through name strings, although the C language does neThomas Lottererither provide such a dedicated facility nor an evaluation construct (which could be used to implement such a facility easily).
In general, this is used for accessing C variables without having to know the actual symbol/address/reference. The typical use cases are in combination with flexible configuration parsing and supporting loosly-coupled DSO-based module architectures.
Enhancements:
- Upgraded build environment to GNU libtool 1.5.20 and GNU shtool 2.0.3 [Ralf S. Engelschall]
- Bumped year in copyright messages for new year 2005. [Ralf S. Engelschall]
- Changes between 0.9.2 and 0.9.3 (04-Apr-2003 to 12-Sep-2004)
- Upgraded build environment to GNU libtool 1.5.8 and GNU shtool 2.0.1 [Ralf S. Engelschall]

Regexp::Common::net is a Perl module that provide regexes for IPv4 addresses.

SYNOPSIS

use Regexp::Common qw /net/;

while () {
/$RE{net}{IPv4}/ and print "Dotted decimal IP address";
/$RE{net}{IPv4}{hex}/ and print "Dotted hexadecimal IP address";
/$RE{net}{IPv4}{oct}{-sep => :}/ and
print "Colon separated octal IP address";
/$RE{net}{IPv4}{bin}/ and print "Dotted binary IP address";
/$RE{net}{MAC}/ and print "MAC address";
/$RE{net}{MAC}{oct}{-sep => " "}/ and
print "Space separated octal MAC address";
}

Please consult the manual of Regexp::Common for a general description of the works of this interface.

Do not use this module directly, but load it via Regexp::Common.

This modules gives you regular expressions for various style IPv4 and MAC (or ethernet) addresses.

$RE{net}{IPv4}

Returns a pattern that matches a valid IP address in "dotted decimal". Note that while 318.99.183.11 is not a valid IP address, it does match /$RE{net}{IPv4}/, but this is because 318.99.183.11 contains a valid IP address, namely 18.99.183.11. To prevent the unwanted matching, one needs to anchor the regexp: /^$RE{net}{IPv4}$/.
For this pattern and the next four, under -keep (See Regexp::Common):

$1

captures the entire match

$2

captures the first component of the address

$3

captures the second component of the address

$4

captures the third component of the address

$5

captures the final component of the address

Stanford Exploration Project Library (or SEP, for short) is an industry-funded academic consortium whose purpose is to improve the theory and practice of constructing 3-D and 4-D images of the earth from seismic echo soundings.
Although most of our research is targeted at improvements in the geophysical survey contracting industry, about half of our sponsors and alumni are in the petroleum industry because we focus on overcoming technological limitations of the geophysical survey industry.
SEP pioneered innovations in migration imaging, velocity estimation, dip moveout and slant stack. Today our focus is on 3-D seismic applications such as velocity estimation, wavefield-continuation prestack migration, multidimensional image estimation, and 4-D (time-lapse) reservoir monitoring.
Besides 3-D reflection seismic data, we undertake small 2-D imaging projects with geophysical data of all kinds. The diversity of applications exercises our judgment and skill at combining fundamentals of statistical signal theory, optimization theory, numerical analysis, and wave propagation theory, and this has led us to numerous improvements and some breakthroughs.
We organize our research to facilitate technology transfer by using a formal method of makefile rules. With these, most of our research results are verified by someone other than the original researcher. Research progress reports at least four years old and all PhD theses are made available to the public through our web site.
Enhancements:
- Numerous major new features and major bugfixes.

pyClamd library is a python interface to Clamd (Clamav daemon). By using pyClamd, you can add virus detection capabilities to your python software in an efficient and easy way.

Instead of pyClamav which uses libclamav, pyClamd may be used by a closed source product.

Usage:

From python :
Python 2.3.5 (#2, Sep 4 2005, 22:01:42)
[GCC 3.3.5 (Debian 1:3.3.5-13)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import pyclamd
>>> pyclamd.init_network_socket(localhost, 3310)
>>> print pyclamd.version()
ClamAV 0.88.3/1598/Thu Jul 13 13:38:16 2006
>>> ret = pyclamd.scan_file(/tmp/eicar.com)
>>> print ret
{/tmp/eicar.com: Eicar-Test-Signature}
>>> ret = pyclamd.scan_file(/tmp/no_virus.txt)
>>> print ret
None
>>> ret = pyclamd.scan_stream(open(/tmp/eicar.com).read())
>>> print ret
{stream: Eicar-Test-Signature FOUND}

Savage: The Battle for Newerth SEP 2 for Linux is a patch for Savage game.
Serverside Demos, with the possibility of multiple players watching the same replay on the same replay server at the same time!
Fixed ALL known bugs and exploits, including tons of non-public ones. Even more so than in the original SEP-2 release.
Improved clientside performance and loading speed, up to 25-50% each, depending on your configuration.
Lower pings, especially so on SEP-2 servers (only when on the field, to minimize bandwidth costs)
Enhancements:
- highly optimized rewritten network code
- two new Healer class units
- two new structures
- all new weapons effects
- new items
- new maps
- engine enhancements which increase frame rate by up to 40% on many computer systems
- numerous bug/exploit fixes
- new gameplay and balance tweaks
- introduces Demo Recording

SYNOPSIS

use Array::Compare;

my $comp1 = Array::Compare->new;
$comp->Sep(|);
$comp->Skip({3 => 1, 4 => 1});
$comp->WhiteSpace(0);
$comp->Case(1);

my $comp2 = Array::Compare->new(Sep => |,
WhiteSpace => 0,
Case => 1,
Skip => {3 => 1, 4 => 1});

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

$comp1->compare(@arr1, @arr2);
$comp2->compare(@arr1, @arr2);

If you have two arrays and you want to know if they are the same or different, then Array::Compare will be useful to you.
All comparisons are carried out via a comparator object. In the simplest usage, you can create and use a comparator object like this:

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

my $comp = Array::Compare->new;

if ($comp->compare(@arr1, @arr2)) {
print "Arrays are the samen";
} else {
print "Arrays are differentn";
}

Notice that you pass references to the two arrays to the comparison method.

Internally the comparator compares the two arrays by using join to turn both arrays into strings and comparing the strings using eq. In the joined strings, the elements of the original arrays are separated with the ^G character. This can cause problems if your array data contains ^G characters as it is possible that two different arrays can be converted to the same string.

To avoid this, it is possible to override the default separator character, either by passing and alternative to the new function

my $comp = Array::Compare->new(Sep => |);

or by changing the seperator for an existing comparator object

$comp->Sep(|);

In general you should choose a separator character that wont appear in your data.

You can also control whether or not whitespace within the elements of the arrays should be considered significant when making the comparison. The default is that all whitespace is significant. The alternative is for all consecutive white space characters to be converted to a single space for the pruposes of the comparison. Again, this can be turned on when creating a comparator object:

my $comp = Array::Compare->new(WhiteSpace => 0);

or by altering an existing object:

$comp->WhiteSpace(0);

You can also control whether or not the case of the data is significant in the comparison. The default is that the case of data is taken into account. This can be changed in the standard ways when creating a new comparator object:

my $comp = Array::Compare->new(Case => 0);

or by altering an existing object:

$comp->Case(0);

In addition to the simple comparison described above (which returns true if the arrays are the same and false if theyre different) there is also a full comparison which returns a list containing the indexes of elements which differ between the two arrays. If the arrays are the same it returns an empty list. In scalar context the full comparison returns the length of this list (i.e. the number of elements that differ). You can access the full comparision in two ways. Firstly, there is a DefFull attribute. If this is true then a full comparison if carried out whenever the compare method is called.

my $comp = Array::Compare->new(DefFull => 1);
$comp->compare(@arr1, @arr2); # Full comparison

$comp->DefFull(0);
$comp->compare(@arr1, @arr2); # Simple comparison

$comp->DefFull(1);
$comp->compare(@arr1, @arr2); # Full comparison again

Secondly, you can access the full comparison method directly

$comp->full_compare(@arr1, @arr2);

For symmetry, there is also a direct method to use to call the simple comparison.

$comp->simple_compare(@arr1, @arr2);

The final complication is the ability to skip elements in the comparison. If you know that two arrays will always differ in a particular element but want to compare the arrays ignoring this element, you can do it with Array::Compare without taking array slices. To do this, a comparator object has an optional attribute called Skip which is a reference to a hash. The keys in this hash are the indexes of the array elements and the values should be any true value for elements that should be skipped.

For example, if you want to compare two arrays, ignoring the values in elements two and four, you can do something like this:

my %skip = (2 => 1, 4 => 1);
my @a = (0, 1, 2, 3, 4, 5);
my @b = (0, 1, X, 3, X, 5);

my $comp = Array::Compare->new(Skip => %skip);

$comp->compare(@a, @b);

This should return true, as we are explicitly ignoring the columns which differ.

Of course, having created a comparator object with no skip hash, it is possible to add one later:

$comp->Skip({1 => 1, 2 => 1});

or:

my %skip = (1 => 1, 2 => 2);
$comp->Skip(%skip);

To reset the comparator so that no longer skips elements, set the skip hash to an empty hash.

$comp->Skip({});

You can also check to see if one array is a permutation of another, i.e. they contain the same elements but in a different order.

if ($comp->perm(@a, @b) {
print "Arrays are permsn";
else {
print "Nope. Arrays are completely differentn";
}

In this case the values of WhiteSpace and Case are still used, but Skip is ignored for, hopefully, obvious reasons.