Free return 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::Failure is a Perl module with a utility module for Contextual::Return.

NOTE

Contains no user serviceable parts. See Contextual::Return instead.

SuperBunguru is a 2d platform/arcade game.

SuperBunguru is a arcade game where your objective is jump from block to block to reach a goal at the top of a level.

To make this hard you cant return to a previous lower position. And to turn up the pace of the game blocks collapps when you stand on them too long.

SuperBunguru is inspired by Bunguru-Wa.

beware project is a distributed global server load balancing system.

beware is a small DNS server that can have nameserver responsibility delegated to it and that can return a set of authoritative "IN A" records to a client.

Given a list of hosts for a certain domain name, it also tests for services specified and will only return IP addresses for currently reachable services.

EXAMPLE

# This is a really long synopsis, but hopefully it will give you an idea...

package MyPackage;

use Class::Driver;
use base q(Class::Driver);

our %drivers;

return 1;

sub new {
my($class, %args) = @_;
die "mime_type is required" unless($args{mime_type});
die "no driver to handle type $args{mime_type}"
unless($drivers{$args{mime_type}});
return $class->driver_load($drivers{$args{mime_type}}, %args);
}

sub driver_new {
my($class, %args) = @_;
return bless %args, $class;
}

sub driver_required { 1; }
sub driver_requied_here { 0; }

package MyPackage::avi;

use MyPackage;
use base q(MyPackage);
use Video::Info;

$MyPackage::drivers{video/x-msvideo} = avi;

return 1;

sub driver { "avi"; }

sub driver_new {
my($class, %args) = @_;
die "file is a required parameter for $args{mime_type} files"
unless($args{file});
$args{info} = Video::Info->new(-file => $args{file})
or die "Failed to create a Video::Info object for $args{file}";
return $class->SUPER::driver_new(%args);
}

sub duration {
my $self = shift;
return $args{info}->duration;
}

package MyPackage::mp3;
use base q(MyPackage);
use MP3::Info;

$MyPackage::drivers{audio/mpeg} = mp3;

## (etc...)

package main;

my $foo = MyPackage->new(file => foobar.mp3, mime_type => audio/mpeg);
print "foobar.mp3 is ", $foo->duration, " seconds long.n";

Net::Delicious::Iterator is an iterator class for Net::Delicious thingies.

SYNOPSIS

use Net::Delicious::Iterator;

my @dates = ({...},{...});
my $it = Net::Delicious::Iterator->new("Date",@dates);

while (my $d = $it->next()) {

# Do stuff with $d here
}

NOTES

It isnt really expected that you will instantiate these objects outside of Net::Delicious itself.

PACKAGE METHODS

__PACKAGE__->new($foreign_class,@data)

Returns a Net::Delicious::Iterator object. Woot!

$it->count()

Return the number of available thingies.

$it->next()

Returns the next object in the list of available thingies. Woot!

Parrot::OpTrans is a Perl module that can transform Ops to C Code.

Parrot::OpTrans is the abstract superclass for the Parrot op to C transforms. Each transform contains various bits of information needed to generate the C code, and creates a different type of run loop. The methods defined here supply various default values and behaviour common to all transforms.

The subclass hierarchy is as follows:

OpTrans
|_________________________
| | |
C CGoto Compiled
| |
CPrederef |
| | |
| |_________|
| |
CSwitch CGP

Class Methods

new()

Returns a new instance.

Instance Methods

prefix()

Returns the default Parrot_ prefix.

Used by Parrot::Ops func_name() to individuate op function names.

suffix()

Implemented in subclasses to return a suffix with which to individuate variable names. This default implementation returns an empty string.

defines()

Implemented in subclasses to return the C #define macros required.

opsarraytype()

Returns the type for the array of opcodes. By default here its an array opcode_t, but the prederef runops core uses an array of void* to do its clever tricks.

core_type()

Implemented in subclasses to return the type of core created by the transform. This default implementation raises an exception indicating that the core type is missing. See the Parrot_Run_core_t enum in include/parrot/interpreter.h for a list of the core types.

core_prefix()

Implemented in subclasses to return a short prefix indicating the core type used to individuate core function names.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the name of the main ops file minus the .ops extension.

ops_addr_decl($base_suffix)

Optionally implemented in subclasses to return the C code for the ops address declaration. $base_suffix is the name of the main ops file minus the .ops extension with suffix() and an underscore appended.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the same as for run_core_func_decl().

run_core_func_start()

Implemented in subclasses, if run_core_func_decl() is implemented, to return the C code prior to the run core function.

run_core_after_addr_table($base_suffix)

Optionally implemented in subclasses to return the run core C code for section after the address table. $base_suffix is the same as for ops_addr_decl().

run_core_finish($base)

Implemented in subclasses to return the C code following the run core function. $base is the same as for run_core_func_decl().

init_func_init1($base)

Optionally implemented in subclasses to return the C code for the cores init function. $base is the same as for run_core_func_decl().

init_set_dispatch($base_suffix)

Optionally implemented in subclasses to return the C code for initializing the dispatch mechanism within the cores init function. $base_suffix is the same as for ops_addr_decl().

Macro Substitutions

The following methods are called by Parrot::OpFile to perform ops file macro substitutions.

access_arg($type, $value, $op)

Implemented in subclasses to return the C code for the specified op argument type and value. $op is an instance of Parrot::Op.

gen_goto($where)

The various goto_X methods below call this method with the return value of an expr_X method (implemented in subclass).

restart_address($address)

Implemented in subclasses to return the C code for restart ADDRESS($address).

restart_offset($offset)

Implemented in subclasses to return the C code for restart OFFSET($offset).

goto_address($address)

Transforms the goto ADDRESS($address) macro in an ops file into the relevant C code.

goto_offset($offset)

Transforms the goto OFFSET($offset) macro in an ops file into the relevant C code.

goto_pop()

Transforms the goto POP($address) macro in an ops file into the relevant C code.

expr_offset($offset)

Implemented in subclasses to return the C code for OFFSET($offset). Called by goto_offset().

expr_address($address)

Implemented in subclasses to return the C code for ADDRESS($address). Called by goto_address().

Interval arithmetic for Ada is a math library that provides an implementation of intervals for Ada. It includes arithmetic and relational operations.
Examples:
Tri-state logic
The package Intervals serves as a root package and also provides tri-state logic necessary to define relational operations on intervals. The type Logical is defined as:
type Logical is (False, True, Uncertain);
The following operations are defined for Logical:
function "not" (Left : Logical) return Logical;
function "and" (Left, Right : Logical) return Logical;
function "and" (Left : Logical; Right : Boolean)
return Logical;
function "and" (Left : Boolean; Right : Logical)
return Logical;
function "or" (Left, Right : Logical) return Logical;
function "or" (Left : Logical; Right : Boolean)
return Logical;
function "or" (Left : Boolean; Right : Logical)
return Logical;
function "xor" (Left, Right : Logical) return Logical;
function "xor" (Left : Logical; Right : Boolean)
return Logical;
function "xor" (Left : Boolean; Right : Logical)
return Logical;
Enhancements:
- For GNAT users GPS project files were included;
- Based on Measurement units for Ada v 2.4.