Free server connections software for linux

PunJab is a HTTP jabber client interface. It is a SOAP, XMLRPC, JEP-0025 or JEP-0124 server that allows persistent client connections to a jabber server.
PunJab can be used for many things, but its main purpose is to allow for stateless applications (ie web) a stateful connection to jabber.
Enhancements:
- Speed improvements were made in handling requests. Speed improvements were made in session creation and authentication.
- A memory leak in a bad observer for messages was fixed.
- A SASL bug which was triggered if there was no "realm" was fixed.
- A connection bug in HTTP polling and XMLRPC was fixed.
- A few changes were made to make it more compliant with XEP - 0124.

Web-Based Adult Content Server is a suite of programs which manage photo sets and video clips of an adult nature.
It runs on a home Linux/Unix server and creates a personalized adult Web server in which to store, preuse, and catalogue a personal collection of adult material.
Web-Based Adult Content Server has many features, like model catalogs, attribute-based searching, randomized highlights, new addition lists, and a flexible bookmark mechanism.
Enhancements:
- This release has new features and many bugfixes.
- It includes a new Web-based Model Manager application, locations-based filtering (e.g. Bathroom), and a new connections infrastructure for galleries and ad-hoc collections.

Newsstar fetches news and posts it to a local server; INN, s-news and sn are supported, and it should be easy to adapt for other servers with some configuration and extra scripts. Its designed for Unix-like systems, and all the development was done on Linux.

There are already plenty of other programs to do this, but what makes newsstar special is that it can make multiple simultaneous connections, not only to one server, but to several, supporting up to 10 threads. Before fetching each article it checks that it hasnt already been downloaded by another thread or in a previous session. It can also pipeline article requests to make better use of available bandwidth.

I wrote it because a number of ISPs I have used suffer from unreliable newsfeeds. There is an excellent free server made available by news.individual.net, but it can be a bit slow at times, and using external servers uses more bandwidth. Therefore I wanted a program which could fetch whatever articles my ISP has available, but use the foreign server to avoid missing posts or getting them very late, and to do it as fast as possible.

This project is distributed under the GPL.

spamdyke is a drop-in filter for qmail to provide connection-time blacklisting, graylisting, DNS RBL checking, improved logging, and more spamdyke project is a standalone program that does not use qmail source code or require patching/recompiling qmail.
For anyone who runs a mail server, spam is a problem. Its a huge problem and its only getting bigger. Unfortunately, qmail doesnt have many facilities for dealing with spam. qmail also doesnt do good logging. The qmail logs are probably useful to qmail developers but not to system administrators. Consider:
- Qmail doesnt log with a human-readable time format.
- Qmail logs dont track usable information (like senders and recipients).
- Qmail doesnt log to a single log file, making it very difficult to track an email from connection to delivery.
- Qmail logs roll over after a set size is reached (could be a few hours, could be a few minutes).
All of these things makes qmail very difficult to troubleshoot or monitor. spamdyke solves this. It monitors incoming traffic, acting as a middleman between qmail and the remote server. It catches the sender and recipient addresses as they go by and logs them to syslog. If it sees something it doesnt like (e.g. a blacklisted sender), it cuts the connection, closes qmail and fakes the rest of the SMTP transaction with the remote server. qmail thinks the remote server disconnected normally. The remote server thinks qmail is rejecting the message. Its the best of both worlds.
Some history: DJBs ucspi-tools package includes a handy little program called rblsmtpd for checking incoming SMTP connections against a DNSRBL. Initially, this seemed like a great thing (and it was) but it didnt go far enough. Lots of spam still came through. So after extending rblsmtpd to do more and more and more things, a limit was finally reached where it wouldnt go any further. Thus, spamdyke was born.
Main features:
- Reject the connection if the remote server has no reverse DNS entry.
- Reject the connection if the remote servers reverse DNS entry does not resolve.
- Reject the connection if the remote servers reverse DNS entry contains its IP address and a prohibited keyword (like "dynamic").
- Reject the connection if the remote servers reverse DNS entry contains its IP address and ends in a country code (whats the japanese word for "dynamic"?).
- Reject the connection if the remote servers IP address is listed in an IP blacklist.
- Reject the connection if the remote servers reverse DNS entry is listed in a domain name blacklist.
- Reject the connection if the remote servers IP address is listed in a given DNS realtime blacklist.
- Reject the connection if the remote server sends data before the SMTP greeting banner is displayed (earlytalkers).
- Reject the connection if the senders address is listed in a sender blacklist file.
- Limit recipients to a maximum number per connection. (Yes, this goes against RFC 821 but legitimate mail servers retry the rejected recipients, spammers dont.)
- Graylist incoming mail to specific domains (some domains can enjoy graylisting while others do not).
- Close the connection after a set idle time.
- Close the connection after a set maximum time.
Those filters end up rejecting more than 99.9% of the incoming connections to my mail server. As a result, I receive (on average) less than one spam message PER WEEK! (Down from a high of 70+ per day.) Regular correspondance with real people has not suffered.
Graylisting deserves special mention. As of 2007, its not widely used (and therefore still effective against spammers). Heres how it works:
An incoming connection is received and the sender and recipient are identified.
A log is consulted to see if the sender has sent email to the recipient before. If so, the message is accepted. If not, the message is rejected with a temporary rejection code and a log entry is made.
When the remote mail server retries the message (usually only a few minutes later), the previously-logged connection is noted and the message is accepted.
Simple, right? After the system is activated, regular correspondents first email is delayed a few minutes. After that, there are no delays. But the spam stops because most spammers dont retry their deliveries! Even when they do, they usually change their sender address to a new (fake) one, which gets graylisted.
Graylisting is amazing and makes a tremendous difference (for now). spamdyke will also:
- Bypass all filters if the remote servers IP address is listed in an IP whitelist file.
- Bypass all filters if the remote servers reverse DNS entry is listed in a domain name whitelist file.
- Log meaningful messages to the syslog (very unlike qmails logs).
- Log all SMTP traffic to aid diagnosing problems.
Enhancements:
- This release fixes a serious bug that was causing lost mail when the remote server sent the message and disconnected in a burst without waiting for a response.
- Code has been added to translate bare line feeds into carriage return+line feeds.
- Support has been added for MUAs that send their username with their AUTH LOGIN command.

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.