Free httunnel 0.04 software for linux

HTTunnel is a universal HTTP tunnel using Apache, mod_perl and Perl.

To install this module do the following:

perl Makefile.PL
make
make test
make install

Note 1: The test suite will require the URL to an Apache::HTTunnel server to run. You will prompted for it during the installation. This server must allow tunnels to localhost:80. That Apache server must also return an HTTP 200 code for a "GET / HTTP/1.0" request.
Generally if the server has index.html file in the document root it will be ok.

HTTunnel::Client is a client class for Apache::HTTunnel.

SYNOPSIS

my $hc = new HTTunnel::Client("http://localhost/httunnel") ;
$hc->connect(tcp, $some_host, $some_port) ;

$hc->print(some request) ;
my $some_response = $hc->read(1024) ;

$ch->close() ;

HTTunnel::Client is the client class to Apache::HTTunnel. It allows the creation of a network connection tunnelled through HTTP. All data sent and received during this connection will be transported inside normal HTTP requests.

HTTunnel::Client extends LWP::UserAgent, so all LWP::UserAgent methods are available through HTTunnel::Client.

CONSTRUCTORS

new ( URL, [ARGS] )

Creates an HTTunnel::Client object that will use URL to contact the Apache::HTTunnel server. ARGS are is passed directly to the LWP::UserAgent constructor.

METHODS

connect ( PROTO, HOST, PORT, [TIMEOUT] )

Asks the Apache::HTTunnel server to establish a connection of protocol PROTO to HOST:PORT. An exception is thrown if an error occurs.

Accepted values for PROTO are tcp and udp.

print ( DATA )

Asks the Apache::HTTunnel server to write DATA to the established remote connection. An exception is thrown if an error occurs.
DATA can be a scalar or a list, in which case the list items are concatenated together.

read ( LEN, [TIMEOUT], [LIFELINE], [LIFELINE_CUT_ACTION] )

Asks the Apache::HTTunnel server to read up to LEN bytes from the established remote connection. An exception is thrown if an error occurs.

When trying to read, HTTunnel::Client will establish an HTTP connection to the Apache::HTTunnel server asking that LEN bytes be read. If no data is available after TIMEOUT seconds (the default value is 15 seconds), the HTTP connection is closed by the server and the read method will establish a new one. This will go on until some data or EOF is returned.

Therefore read will return only when some (or no more) data is available to be read (like the regular read).

LIFELINE can be any valid filehandle from which one can read. If used, read will interrupt its connection loop and execute LIFELINE_CUT_ACTION when data (or EOF) is available to be read from LIFELINE. It will then return undef.
LIFELINE_CUT_ACTION wust be a CODE ref. The default value is

sub {die("lifeline cutn")}

These features can be used if you want fork and to start a process that does nothing but reads and returns the data via a pipe. You can then use a second pipe to make sure the reader process terminates when the master process terminates.

Here is an example:

my $lifeline = new IO::Pipe() ;
my $reader = new IO::Pipe() ;
my $pid = fork() ;
if ($pid){
$reader->reader() ;
$lifeline->writer() ;

# Read data from $reader...
}
else {
$reader->writer() ;
$reader->autoflush(1) ;
$lifeline->reader() ;

while (1){
my $data = $hc->read(1024, 15, $lifeline, sub {exit()}) ;
exit() unless defined($data) ;
print $reader $data ;
}
}
close ( )

Asks the Apache::HTTunnel server to close a previously established connection.
get_peer_info ( )

The get_peer_info method returns information about the remote connection. A string containing the IP address and port number, separated by a colon (:) is returned. This method can be useful with UDP connections to validate the sender of each packet.

request_callback ( REQUEST )

The request_callback method is a callback method that can be used to access the HTTP::Request object just before it is sent. The default implementation does nothing.

response_callback ( RESPONSE )

The response_callback method is a callback method that can be used to access the HTTP::Response object just after it is received. The default implementation does nothing.

Inline::Lua is a Perl extension for embedding Lua scripts into Perl code.

SYNOPSIS

use Inline Lua;
print "The answer to life, the universe and everything is ", answer(6, 7), "n";

__END__
__Lua__
function answer (a, b)
return a*b
end

Inline::Lua allows you to write functions in Lua. Those of you who are not yet familiar with Lua should have a cursory glance at http://www.lua.org/ to get a taste of this language. In short:

Lua was designed to be embedded into other applications and not so much as a language on its own. However, despite its small set of language features, it is an extremely powerful and expressive language. Its strong areas are an elegant and yet concise syntax, good overall performance and a beautiful implementation of some concepts from the world of functional programming.

Net::UPS is an implementation of UPS Online Tools API in Perl.

SYNOPSIS

use Net::UPS;
$ups = Net::UPS->new($userid, $password, $accesskey);
$rate = $ups->rate($from_zip, $to_zip, $package);
printf("Shipping this package $from_zip => $to_zip will cost you $.2fn", $rate->total_charges);

Net::UPS implements UPS Online Tools API in Perl. In a nutshell, Net::UPS knows how to retrieve rates and service information for shipping packages using UPS, as well as for validating U.S. addresses.

This manual is optimized to be used as a quick reference. If youre knew to Net::UPS, and this manual doesnt seem to help, youre encouraged to read Net::UPS::Tutorial first.

Shell::Parser is a simple shell script parser.

SYNOPSIS

use Shell::Parser;

my $parser = new Shell::Parser syntax => bash, handlers => {

};
$parser->parse(...);
$parser->eof;

This module implements a rudimentary shell script parser in Perl. It was primarily written as a backend for Syntax::Highlight::Shell, in order to simplify the creation of the later.

mod_limitipconn is an Apache module which allows web server administrators to limit the number of simultaneous downloads permitted from a single IP address.

Simulum deals with different simulations of star movements and their visualizations. At first we look at the projection and accumulation of star brightness.

In actually doing this we have to distribute stars among a three dimensional figure. To get a nice effect we combine the photographic image production with a moving view point. So we get the visual impression of flying through a star field.

Secondly we will study different algorithms of particle movements and clustering. The primary approach will use a combination of Newtons gravitational law, energy and impulse conservation.

At all these stages an highly dynamic view of the processes could be produced and will lead at least to interesting screen savers...

Whats New in This Release:

ï¿1⁄2 A huge refactoring phase took place.
ï¿1⁄2 Now the code is much better organized.
ï¿1⁄2 A simple gravity engine is included, so you can watch gravity at work.
ï¿1⁄2 It has now a nice GUI.
ï¿1⁄2 You can browse the simulation with your mouse.
ï¿1⁄2 The provided unsigned jar includes an applet that can directly be used by HTML pages; this release includes sample HTML pages.
ï¿1⁄2 You can also webstart the signed jar or start it with "java -jar lib/mulumis.jar".

Perl6::Take is a Perl module to gather/take in Perl 5.

SYNOPSIS

use Perl6::Take;

my @foo = gather {
take 5;
};

EXPORT

gather

Accepts a block. take statements inside the dynamic scope of the block are used to accumulate a list, which is gathered as the return value of the block.

take

Accumulates its argument (or list of arguments) on to the nearest gather in the dynamic scope. Arguments are evaluated in list context. The arguments may be passed on to a variable, but note that this assignment should usually be done in list context, as per usual context rules:

$answer = take 42; # 1
($answer) = take 42; # 42