Free returned software for linux

Return-RST is a firewalling tool for Linux 2.2.xx systems using IPCHAINS. It uses the netlink device to capture packets and sends TCP RST packets in response to TCP connection requests.

Normal IPCHAINS only allows you to drop packets, or reject packets with an ICMP error message. With Return-RST, you can make it look like there is no server listening, rather than giving away that theyre being filtered to the attacker.

Return-RST was written to overcome the lack of an ipchains policy that can return a RESET packet when denying a TCP connection. The DENY policy just drops the packet, and the REJECT policy sends back an ICMP message. Either policy will pull an attacker off to the fact theyre being filtered.

On the other hand, an RST in response to a TCP SYN packet is what happens when there is no server listening on a port - this program allows you to return this error, so attackers will think that there is no server available.

Contextual::Return is a Perl module to create context-senstive return values.

SYNOPSIS

use Contextual::Return;
use Carp;

sub foo {
return
SCALAR { thirty-twelve }
BOOL { 1 }
NUM { 7*6 }
STR { forty-two }

LIST { 1,2,3 }

HASHREF { {name => foo, value => 99} }
ARRAYREF { [3,2,1] }

GLOBREF { *STDOUT }
CODEREF { croak "Dont use this result as code!"; }
;
}

# and later...

if (my $foo = foo()) {
for my $count (1..$foo) {
print "$count: $foo is:n"
. " array: @{$foo}n"
. " hash: $foo->{name} => $foo->{value}n"
;
}
print {$foo} $foo->();
}

Usually, when you need to create a subroutine that returns different values in different contexts (list, scalar, or void), you write something like:

sub get_server_status {
my ($server_ID) = @_;

# Acquire server data somehow...
my %server_data = _ascertain_server_status($server_ID);

# Return different components of that data,
# depending on call context...
if (wantarray()) {
return @server_data{ qw(name uptime load users) };
}
if (defined wantarray()) {
return $server_data{load};
}
if (!defined wantarray()) {
carp Useless use of get_server_status() in void context;
return;
}
else {
croak q{Bad context! No biscuit!};
}
}

That works okay, but the code could certainly be more readable. In its simplest usage, this module makes that code more readable by providing three subroutines--LIST(), SCALAR(), VOID()--that are true only when the current subroutine is called in the corresponding context:

use Contextual::Return;

sub get_server_status {
my ($server_ID) = @_;

# Acquire server data somehow...
my %server_data = _ascertain_server_status($server_ID);

# Return different components of that data
# depending on call context...
if (LIST) { return @server_data{ qw(name uptime load users) } }
if (SCALAR) { return $server_data{load} }
if (VOID) { print "$server_data{load}n" }
else { croak q{Bad context! No biscuit!} }
}

Contextual returns

Those three subroutines can also be used in another way: as labels on a series of contextual return blocks (collectively known as a context sequence). When a context sequence is returned, it automatically selects the appropriate contextual return block for the calling context. So the previous example could be written even more cleanly as:

use Contextual::Return;

sub get_server_status {
my ($server_ID) = @_;

# Acquire server data somehow...
my %server_data = _ascertain_server_status($server_ID);

# Return different components of that data
# depending on call context...
return (
LIST { return @server_data{ qw(name uptime load users) } }
SCALAR { return $server_data{load} }
VOID { print "$server_data{load}n" }
DEFAULT { croak q{Bad context! No biscuit!} }
);
}

The context sequence automatically selects the appropriate block for each call context.

Proxy Detector is a PHP class that can detect HTTP requests via proxy. This class can detect if a visitor uses a proxy server by scanning the headers returned by the user client.
When the user uses a proxy server, most of the proxy servers alter the header. The header is returned to PHP in the array $_SERVER.
Enhancements:
- This is the first release of the class and implementation example.

Remote MySQL Query is a PHP class that can easily execute queries on a remote MySQL server using only HTTP.

It works by accessing a PHP script on the remote web server that executes queries based on passed in URL parameters.

The client passes a secret key to the remote script to prevent unauthorized access.

The remote script passes back the results to the requesting client using XML to marshal the data.

The class parses the results XML data returned by the server script and returns an array.

It, also, retrieves (into class variables) the number of records returned by the query and the time the query took to execute.

The server script may be used to execute MySQL queries that can be retrieved by programs written in other languages besides PHP.

DCE::Status is a Perl interface of DCE status codes.

SYNOPSIS

use DCE::Status;

$errstr = error_inq_text($status);

tie $status => DCE::Status;

When a $scalar is tied to the DCE::Status class, it has a different value depending on the context it is evaluated in, similar to the magic $! variable. When evaluated in a numeric context, the numeric value is returns, otherwise, the string value obtained from dce_error_inq_text is returned.

EXPORTS

error_inq_text

Equivalent to the dce_error_inq_text function.

$errstr = error_inq_text($status);

Set::IntSpan::Island is a Perl extension for Set::IntSpan to handle islands and covers.

SYNOPSIS

use Set::IntSpan::Island

# inherits normal behaviour from Set::IntSpan
$set = Set::IntSpan::Island->new( $set_spec );
# special two-value input creates a range a-b
$set = Set::IntSpan::Island->new( $a,$b );

# equivalent to $set->cardinality($another_set)->size;
if ($set->overlap( $another_set )) { ... }

# negative if overlap, positive if no overlap
$distance = $set->distance( $another_set );

# remove islands shorter than $minlength
$set = $set->remove_short( $minlength );

# fill holes up to $maxholesize
$set = $set->fill( $maxholesize );

# return a set composed of islands of $set that overlap $another_set
$set = $set->find_island( $another_set );

# return a set comopsed of the nearest non-overlapping island(s) to $another_set
$set = $set->nearest_island( $another_set );

# construct a list of covers by exhaustively intersecting all sets
@covers = Set::IntSpan::Island->extract_cover( { id1=>$set1, id2=>set2, ... } );
for $cover (@covers) {
($coverset,@ids) = ($cover->[0], @{$cover->[1]});
print "cover",$coverset->run_list,"contains sets",join(",",@ids);
}

This module extends the Set::IntSpan module by Steve McDougall. It implementing methods that are specific to islands and covers. Set::IntSpan::Island inherits from Set::IntSpan.

Terminology

An integer set, as represented by Set::IntSpan, is a collection of islands (or spans) on the integer line

...-----xxxx----xxxxxxxx---xxxxxxxx---xx---x----....

Islands are disjoint and contiguous, by definition, and may be represented by their own Set::IntSpan object. Regions not in the set that fall between adjacent spans are termed holes. For example, the integer set above is composed of 5 islands and 4 holes. The two infinite regions on either side of the set are not counted as holes within the context of this module.

METHODS

$set = Set::IntSpan::Island->new( $set_spec )

Constructs a set using the set specification as supported by Set::IntSpan.

$set = Set::IntSpan::Island->new( $a, $b )

Extension to Set::IntSpan new method, this double-argument version creates a set formed by the range a-b. This is equivalent to

$set = Set::IntSpan::Island->new("$a-$b")

but permits initialization from a list instead of a string.

$set_copy = $set->duplicate()

Creates a copy of $set.

$overlap_amount = $set->overlap( $another_set );

Returns the size of intersection of two sets. Equivalent to

$set->intersect( $another_set )->size;

$d = $set->distance( $another_set )

Returns the distance between sets, measured as follows. If the sets overlap, then the distance is negative and given by

$d = - $set->overlap( $another_set )

If the sets do not overlap, $d is positive and given by the distance on the integer line between the two closest islands of the sets.

$d = $set->sets()

Returns all spans in $set as Set::IntSpan::Island objects. This method overrides the sets method in Set::IntSpan in order to return sets as Set::IntSpan::Island objects.

$set = $set->excise( $minlength )

Removes all islands within $set smaller than $minlength.

$set = $set->fill( $maxlength )

Fills in all holes in $set smaller than $maxlength.

$set = $set->find_islands( $integer )

Returns a set containing the island in $set containing $integer. If $integer is not in $set, an empty set is returned.

$set = $set->find_islands( $another_set )

Returns a set containing all islands in $set intersecting $another_set. If $set and $another_set have an empty intersection, an empty set is returned.

$set = $set->nearest_island( $integer )

Returns the nearest island(s) in $set that contains, but does not overlap with, $integer. If $integer lies exactly between two islands, then the returned set contains these two islands.

$set = $set->nearest_island( $another_set );

Returns the nearest island(s) in $set that intersects, but does not overlap with, $another_set. If $another_set lies exactly between two islands, then the returned set contains these two islands.

$cover_data = Set::IntSpan::Island->extract_covers( $set_hash_ref )

Given a $set_hash reference

{ id1=>$set1, id2=>$set2, ..., idn=>$setn}

where $setj is a finite Set::IntSpan::Island object and idj is a unique key, extract_covers performs an exhaustive intersection of all sets and returns a list of all covers and set memberships. For example, given the id/runlist combination

a 10-15
b 12
c 14-20
d 25

The covers are

10-11 a
12 a b
13 a
14-15 a c
16-20 c
21-24 -
25 d

The cover data is returned as an array reference and its structure is

[ [ $cover_set1, [ id11, id12, id13, ... ] ],
[ $cover_set2, [ id21, id22, id23, ... ] ],
...
]

If a cover contains no elements, then its entry is

[ $cover_set, [ ] ]

$island = $set->num_islands

Returns the number of islands in the set.

$island = $set->at_island( $island_index )

Returns the island indexed by $island_index. Islands are 0-indexed. For a set with N islands, the first island (ordered left-to-right) has index 0 and the last island has index N-1.

If $island_index is negative, counting is done back from the last island (c.f. negative indexes of Perl arrays).

$island = $set->first_island

Returns the first island of the set as a Set::IntSpan::Island object. As a side-effect, sets the iterator to the first island.

If the set is empty, returns undef.

$island = $set->last_island

Returns the last island of the set as a Set::IntSpan::Island object. As a side-effect, sets the iterator to the last island.
If the set is empty, returns undef.

$island = $set->next_island

Advances the iterator forward by one island, and returns the next island. If the iterator is undefined (e.g. not previously set by first()), the first island is returned.
Returns undef if the set is empty or if no more islands are available.

$island = $set->prev_island

Reverses the iterator backward by one island, and returns the previous island. If the iterator is undefined (e.g. not previously set by last()), the last island is returned.

Returns undef if the set is empty or if no more islands are available.

$island = $set->current_island

Returns the island at the current iterator position.

Returns undef if the set is empty or if the iterator is not defined.

Ruby/Google offers a higher-level abstraction of Googles SOAP-driven Web API. Ruby/Google module allows the user to programatically query the Google search engine from Ruby.

The aim of the library is to shield the programmer from the details of the raw data structures returned by the Web API, and in the process make the API more accessible for everyday use.

Twisted Mail project provides client and server implementations of SMTP, POP3, and IMAP4.
These differentiate themselves from the Python standard library implementations both by presenting a much higher-level, easy-to-use interface and in their server components, which allow the implementation of custom servers for each protocol without dealing with protocol-level issues.
Twisted Mail includes a simple demonstration email server which accepts messages over SMTP, stores them in a Maildir arrangement, and can serve them to clients over POP3.
Enhancements:
- The IMAP4 client now properly quotes usernames and passwords when necessary.
- It also handles unsolicited FLAGS responses.
- The IMAP4 server can now parse multiple literals in a single command and to FETCH requests with multiple BODY parts.
- A bug where Deferreds returned from IMAP4 client methods would not receive connection lost notification has been fixed.
- Startup time on OS X has been improved.
- The SMTP server has been sped up.
- The POP3 mailbox API has been expanded to allow Deferreds to be returned in some cases.