Free java http client 2.5.0 software for linux

GData Java Client provides a library and source code that make it easy to access data through Google Data APIs.

The Google data APIs ("GData" for short) provide a simple standard protocol for reading and writing data on the web. GData combines common XML-based syndication formats (Atom and RSS) with a feed-publishing system based on the Atom publishing protocol, plus some extensions for handling queries.

Google also provides a set of client libraries for interacting with GData-enabled services, in a variety of programming languages. Using these libraries, you can construct GData requests, send them to a service, and receive responses.

This package provides a complete http client library. It currently implements most of the relevant parts of the HTTP/1.0 and HTTP/1.1 protocols, including the request methods HEAD, GET, POST and PUT, and automatic handling of authorization, redirection requests, and cookies.

Furthermore the included Codecs class contains coders and decoders for the base64, quoted-printable, URL-encoding, chunked and the multipart/form-data encodings. The whole thing is free, and licenced under the GNU Lesser General Public License (LGPL) (note that this is not the same as the GPL).

Following are the kits and documentation for the HTTPClient Version 0.3-3. If you have any problems, bugs, suggestions, comments, etc. see the info on debugging and reporting problems. An older version of these pages are also available in Japanese, thanks to the kindly efforts of Yuji Kumasaka.

Using the HTTPClient should be quite simple. First add the import statement import HTTPClient.*; to your file(s). Next you create an instance of HTTPConnection (youll need one for every server you wish to talk to). Requests can then be sent using one of the methods Head(), Get(), Post(), etc in HTTPConnection.

These methods all return an instance of HTTPResponse which has methods for accessing the response headers (getHeader(), getHeaderAsInt(), etc), various response info (getStatusCode(), getReasonLine(), etc), the response data (getData(), getText(), and getInputStream()) and any trailers that might have been sent (getTrailer(), getTrailerAsInt(), etc). Following are some examples to get started.
To retrieve files from the URL "http://www.myaddr.net/my/file" you can use something like the following:
try
{
HTTPConnection con = new HTTPConnection("www.myaddr.net");
HTTPResponse rsp = con.Get("/my/file");
if (rsp.getStatusCode() >= 300)
{
System.err.println("Received Error: "+rsp.getReasonLine());
System.err.println(rsp.getText());
}
else
data = rsp.getData();

rsp = con.Get("/another_file");
if (rsp.getStatusCode() >= 300)
{
System.err.println("Received Error: "+rsp.getReasonLine());
System.err.println(rsp.getText());
}
else
other_data = rsp.getData();
}
catch (IOException ioe)
{
System.err.println(ioe.toString());
}
catch (ParseException pe)
{
System.err.println("Error parsing Content-Type: " + pe.toString());
}
catch (ModuleException me)
{
System.err.println("Error handling request: " + me.getMessage());
}

This will get the files "/my/file" and "/another_file" and put their contents into byte[]s accessible via getData(). Note that you need to only create a new HTTPConnection when sending a request to a new server (different protocol, host or port); although you may create a new HTTPConnection for every request to the same server this not recommended, as various information about the server is cached after the first request (to optimize subsequent requests) and persistent connections are used whenever possible (see also Advanced Info).

To POST form data from an applet back to your server you could use something like this (assuming you have two fields called name and e-mail, whose contents are stored in the variables name and email):
try
{
NVPair form_data[] = new NVPair[2];
form_data[0] = new NVPair("name", name);
form_data[1] = new NVPair("e-mail", email);

// note the convenience constructor for applets
HTTPConnection con = new HTTPConnection(this);
HTTPResponse rsp = con.Post("/cgi-bin/my_script", form_data);
if (rsp.getStatusCode() >= 300)
{
System.err.println("Received Error: "+rsp.getReasonLine());
System.err.println(rsp.getText());
}
else
stream = rsp.getInputStream();
}
catch (IOException ioe)
{
System.err.println(ioe.toString());
}
catch (ModuleException me)
{
System.err.println("Error handling request: " + me.getMessage());
}

Here the response data is read at leisure via an InputStream instead of all at once into a byte[].

As another example, if you want to upload a document to a URL (and the server supports http PUT) you could do something like the following:
try
{
URL url = new URL("http://www.mydomain.us/test/my_file");

HTTPConnection con = new HTTPConnection(url);
HTTPResponse rsp = con.Put(url.getFile(), "Hello World");
if (rsp.getStatusCode() >= 300)
{
System.err.println("Received Error: "+rsp.getReasonLine());
System.err.println(rsp.getText());
}
else
text = rsp.getText();
}
catch (IOException ioe)
{
System.err.println(ioe.toString());
}
catch (ModuleException me)
{
System.err.println("Error handling request: " + me.getMessage());
}

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.

The Java Brainfuck Compiler is a compiler for the uniquely powerful Brainfuck language, which produces Java bytecode that will run on any Java Virtual Machine (with no intermediate steps such as going by way of Java code).

HBCI4Java is a Java library for the HBCI home banking interface. HBCI4Java project supports almost all aspect of the HBCI versions 2.01, 2.1, 2.2, HBCI+ and FinTS-3.0 (with PIN/TAN support).
Its API is very application-oriented, so no knowledge about HBCI is required. The HBCI client package can be used to develop applications using HBCI features.
The HBCI server package can be used to develop your own HBCI servers. This may be useful for credit institutes or software developers who want to setup their own HBCI test server.
Enhancements:
- Added sample files to show how to use HBCIBatch tool.
- Solved some problems with the MT940 parser (for statement of account).

Azureus offers multiple torrent downloads, queuing/priority systems (on torrents and files), start/stop seeding options and instant access to numerous pieces of information about your torrents.

Azureus has now features like an embedded tracker, that is easily to set up and ready to use.

The wmpptpd is a Linux PPTP (Point to Point Tunnelling Protocol) server. Comparing to the existing PPTP client and server, it handles multiple connections and clients, implements window protocol, etc. After few minor changes you can use it as a client, too.

The PPTP, point-to-point tunelling protocol, is used to tunell a PPP connection over the local network. It is often used to build the virtual private networks using Windows 9x machines and NT server. There exists a PPTP server and PPTP client for Linux, both of them used to communicate with a windows machine:

server (PoPToP): http://poptop.lineo.com
client (PPTP-Linux): http://cag.lcs.mit.edu/~cananian/Projects/PPTP

However, there are more implementations than the one in Windows around, and weve got a Compaq Microcom 4000 modem rack, which answers digital incomming calls and forwards the requests to a server (using PPTP of course). At first, we tried to adapt a PoPToP server or client to do the job for us, but unfortunately found many problems, so we started from scratch. Our goals were:
- working PPTP implementation
- extensible and flexible design
- multiple connections at one time
- support for as many pptp-talking clients as possible

After few nights, the first versions were ready, few bugs were caught (for example, we had to throw our implementation of windows, as microcom 4000 does not use them; we found few serious design flaws of PPTP protocol itself, spent some time catching the bugs with multiple connections, ...). Then we installed this all on our production server and forgot about it. After some time, weve got some bug reports, which needed to be ironed out. So we re-visited the sources, fixed the bugs and made this release.