Free http 1.1 software for linux

Shttp is a partial implementation of HTTP/1.1. The project does not conform to the RFC but works well enough to serve static content in a experimental/educational context.

The module consists of well under 1000 LoC making it an excellent example of what can be done with ServerKit with little effort and a great learning tool for those getting started with ServerKit programming.

Usage:

It is advised that you read the ServerKit documentation before trying to use this module, as most of the basic usage is simply using ServerKit, nothing specific to this module.

Due to the simple nature of this module it does not include a personality template and it is not expected that you would use it under daemontools.

Instead, the module sources include a simple startup script to run it "in-tree" without installing it in the system. There is still a c11n file included which gets used "in-tree" as well. See below for the configuration options.

HTTP::DAV is a WebDAV client library for Perl5.
SYNOPSIS
# DAV script that connects to a webserver, safely makes
# a new directory and uploads all html files in
# the /tmp directory.
use HTTP::DAV;
$d = new HTTP::DAV;
$url = "http://host.org:8080/dav/";
$d->credentials( -user=>"pcollins",-pass =>"mypass",
-url =>$url, -realm=>"DAV Realm" );
$d->open( -url=>"$url )
or die("Couldnt open $url: " .$d->message . "n");
# Make a null lock on newdir
$d->lock( -url => "$url/newdir", -timeout => "10m" )
or die "Wont put unless I can lock for 10 minutesn";
# Make a new directory
$d->mkcol( -url => "$url/newdir" )
or die "Couldnt make newdir at $urln";
# Upload multiple files to newdir.
if ( $d->put( -local => "/tmp/*.html", -url => $url ) ) {
print "successfully uploaded multiple files to $urln";
} else {
print "put failed: " . $d->message . "n";
}
$d->unlock( -url => $url );
Main features:
- Full RFC2518 method support. OPTIONS, TRACE, GET, HEAD, DELETE, PUT, COPY, MOVE, PROPFIND, PROPPATCH, LOCK, UNLOCK.
- A fully object-oriented API.
- Recursive GET and PUT for site backups and other scripted transfers.
- Transparent lock handling when performing LOCK/COPY/UNLOCK sequences.
- http and https support (https requires the Crypt::SSLeay library). See INSTALLATION.
- Basic AND Digest authentication support (Digest auth requires the MD5 library). See INSTALLATION.
- dave, a fully-functional ftp-style interface written on top of the HTTP::DAV API and bundled by default with the HTTP::DAV library. (If youve already installed HTTP::DAV, then dave will also have been installed (probably into /usr/local/bin). You can see its man page by typing "perldoc dave" or going to http://www.webdav.org/perldav/dave/.
- It is built on top of the popular LWP (Library for WWW access in Perl). This means that HTTP::DAV inherits proxy support, redirect handling, basic (and digest) authorization and many other HTTP operations. See LWP for more information.
- Popular server support. HTTP::DAV has been tested against the following servers: mod_dav, IIS5, Xythos webfile server and mydocsonline. The library is growing an impressive interoperability suite which also serves as useful "sample scripts". See "make test" and t/*.

elhttp provides a full-featured HTTP proxy server designed for embedded systems.
Elhttp is a very light HTTP proxy server, mostly useful on embedded Linux systems such as ADSL routers. It supports HTTP 1.1 (keep-alive), the connect method, IP-based ACLs, SSL relaying, and client request logging.
It runs on most Unix variants (Linux, *BSD, etc.) and Win32.
Compiling elhttp
. under Linux or *BSD, run "make linux"
Version restrictions:
- The default parameters are not secure: everyone has access to the proxy, no logging is done and the http CONNECT method is enabled. It is thus highly recommended to setup more restrictive parameters when starting elhttp.
Enhancements:
- elhttp can now be run from inetd

thttpd is a simple, small, portable, fast, and secure HTTP server:
Simple; It handles only the minimum necessary to implement HTTP/1.1. Well, maybe a little more than the minimum.
Small; See the comparison chart. It also has a very small run-time size, since it does not fork and is very careful about memory allocation.
Portable; It compiles cleanly on most any Unix-like OS, specifically including FreeBSD, SunOS 4, Solaris 2, BSD/OS, Linux, OSF.
Fast; In typical use its about as fast as the best full-featured servers (Apache, NCSA, Netscape). Under extreme load its much faster.
Secure; It goes to great lengths to protect the web server machine against attacks and breakins from other sites.
It also has one extremely useful feature (URL-traffic-based throttling) that no other server currently has. Plus, it supports IPv6 out of the box, no patching required.
Enhancements:
- Move fdwatch initialization before the chroot, so that /dev/poll can work.
- Multiple fdwatch cleanups and fixes (Adam Zell).

Socks via HTTP provides a socks tunnel via HTTP.

Socks via HTTP is a program converting SOCKS requests into HTTP requests and tunnelling them through HTTP proxies if needed.

The SOCKS protocol allows programs to traverse firewalls on any port number and is used by many popular programs, like Napster, MSN Messenger, CRT(telnet client) and many others.

Many companies restrict firewall traversals only to HTTP requests, disabling SOCKS proxy.

Socks via HTTP provides a miniature SOCKS server for the SOCKS client, performing its connection through an HTTP proxy to a remote server, which establishes the real connection.

Socks via HTTP is 100% Java, and can run on any OS. It is entirely written in Java.

BFilter is a filtering web proxy. BFilter was originally intended for removing banner ads only, but at some point it has been extended to remove popups and webbugs. It cant be used as a general purpose filtering proxy because it was never intended this way.
For example you cant just block an arbitary object, you can only hint the ad detector in its decision making.
The main advantage BFilter has over the similar tools is its heuristic ad detection algorithm. The traditional blocklist-based approach is also implemented, but its mostly used for dealing with false positives.
Unlike other tools that require constant updates of their blocklists, BFilter manages to remove over 90% of ads even with an empty blocklist!
The javascript generated ads are not a problem for BFilter, as it has a javascript engine to combat them.
BFilter is expected work with any browser that supports proxies (nearly any browser does), and can forward requests to another HTTP proxy.
BFilter is written in C++ and is distributed under the GNU GPL.
Main features:
- HTTP/0.9 - HTTP/1.1 support.
- Persistent connections (HTTP/1.1 only).
- Pipelining (HTTP/1.1 only).
- HTTP compression.
- Forwarding to another proxy.
- All processing is done on the fly. It doesnt load the whole page or image before processing.
- Heuristic and regex-based approaches to detect ads.
- Detects and removes image, iframe, flash ads, popups and webbugs.
- A javascript engine to combat js-generated ads and popups.
- Heuristic analyzing of images and Flash files.
Enhancements:
- BFilter now caches external scripts it fetches for analyzing.
- Filtering accuracy was improved.
- Added a workaround for "Error decompressing response" problem with Opera and some websites.
- JavaScript engine was updated.

HTTP::Handle is a HTTP Class designed for streaming.

SYNOPSIS

use HTTP::Handle;

my $http = HTTP::Handle->new( uri => "http://www.google.com/" );
$http->connect();

my $fd = $http->fd();

while () {
print "--> $_";
}

The HTTP::Handle module allows you to make HTTP requests and handle the data yourself. The general ideas is that you use this module to make a HTTP request and handle non-header data yourself. I needed such a feature for my mp3 player to listen to icecast streams.

HTTP::Handle->new()

Create a new HTTP::Handle object thingy.

Arguments possible:

url => "http://www.google.com/"

Sets the initial URL to connect to.

follow_redirects => [ 0 | 1 ]

Automatically follow HTTP redirects. This defaults to true (1). Set to 0 to disable this.

http_request => HASHREF

Any thing put in here will be sent as "key: value" in the http request string.

$http->connect()

Connect, send the http request, and process the response headers.

This function returns -1 on failure, undef otherwise. The reason for failure will be printed to STDERR.

$http->fd()

Get the file descriptor (socket) were using to connect.

$http->url( [ url_string ])

Get or set the URL. If a url string is passed, you will change the url that is requested. If no parameter is passed, a URI object will be returned containing the

$http->follow_redirects( [ 0 | 1 ] )

If a value is passed then you will set whether or not we will automatically follow HTTP 302 Redirects. If no value is passed, then we will return whatever the current option is.

Defaults to 1 (will follow redirects).

$http->http_request_string()

Returns a string containing the HTTP request and headers, this is used when

$http->connect() is called.