Free archiveopteryx 2.01 software for linux

Archiveopteryx is an Internet mail server, optimized to support heavy usage and long-term archiving.
The project stores mail in a PostgreSQL database, and provides access to it through IMAP, POP, and more.
Enhancements:
- A very serious SMTP submit bug was fixed.
- A new feature to copy outgoing mail to the sender was added.
- Support for SMTP+TLS on port 465 was added for Outlook.
- HTTP archive display improvements were made.
- A few minor bugs were fixed.

AtExit is a Perl module that can perform exit processing for a program or object.

SYNOPSIS

use AtExit;

sub cleanup {
my @args = @_;
print "cleanup() executing: args = @argsn";
}

## Register subroutines to be called when this program exits

$_ = atexit(&cleanup, "This call was registered first");
print "first call to atexit() returned $_n";

$_ = atexit("cleanup", "This call was registered second");
print "second call to atexit() returned $_n";

$_ = atexit("cleanup", "This call shouldve been unregistered by rmexit");
rmexit($_) or warn "couldnt unregister exit-sub $_!";

if (@ARGV == 0) {
## Register subroutines to be called when this lexical scope is exited
my $scope1 = AtExit->new( &cleanup, "Scope 1, Callback 1" );
{
## Do the same for this nested scope
my $scope2 = AtExit->new;
$_ = $scope2->atexit( &cleanup, "Scope 2, Callback 1" );
$scope1->atexit( &cleanup, "Scope 1, Callback 2");
$scope2->atexit( &cleanup, "Scope 2, Callback 2" );
$scope2->rmexit($_) or warn "couldnt unregister exit-sub $_!";

print "*** Leaving Scope 2 ***n";
}
print "*** Finished Scope 2 ***n";
print "*** Leaving Scope 1 ***n";
}
print "*** Finished Scope 1 ***n" if (@ARGV == 0);

END {
print "*** Now performing program-exit processing ***n";
}

The AtExit module provides ANSI-C style exit processing modeled after the atexit function in the standard C library (see atexit(3C)). Various exit processing routines may be registered by calling atexit and passing it the desired subroutine along with any desired arguments. Then, at program-exit time, the subroutines registered with atexit are invoked with their given arguments in the reverse order of registration (last one registered is invoked first). Registering the same subroutine more than once will cause that subroutine to be invoked once for each registration.

An AtExit object can be created in any scope. When invoked as a function, atexit registers callbacks to be executed at program-exit time. But when invoked as an object-method (using the $object->method_name syntax), callbacks registered with an AtExit object are executed at object-destruction time! The rules for order of execution of the registered subroutines are the same for objects during object-destruction, as for the program during program-termination.

The atexit function/method should be passed a subroutine name or reference, optionally followed by the list of arguments with which to invoke it at program/object exit time. Anonymous subroutine references passed to atexit act as "closures" (which are described in perlref). If a subroutine name is specified (as opposed to a subroutine reference) then, unless the subroutine name has an explicit package prefix, it is assumed to be the name of a subroutine in the callers current package. A reference to the specified subroutine is obtained, and, if invocation arguments were specified, it is "wrapped up" in a closure which invokes the subroutine with the specified arguments. The resulting subroutine reference is added to the front of the list of exit-handling subroutines for the program (atexit) or the AtExit object ($exitObject->atexit) and the reference is then returned to the caller (just in case you might want to unregister it later using rmexit. If the given subroutine could not be registered, then the value zero is returned.

The rmexit function/method should be passed one or more subroutine references, each of which was returned by a previous call to atexit. For each argument given, rmexit will look in the list of exit-handling subroutines for the program (rmexit) or the AtExit object ($exitObject->rmexit) and remove the first matching entry from the list. If no arguments are given, then all program or object exit-handlers are unregistered! The value returned will be the number of subroutines that were successfully unregistered.

At object destruction time, the DESTROY{} subroutine in the AtExit module iterates over the subroutine references in the AtExit object and invokes each one in turn (each subroutine is removed from the front of the queue immediately before it is invoked). At program-exit time, the END{} block in the AtExit module iterates over the subroutines in the array returned by the exit_subs method and invokes each one in turn (each subroutine is removed from the front of the queue immediately before it is invoked). Note that in both cases (program-exit, and object-destruction) the subroutines in this queue are invoked in first-to-last order (the reverse order in which they were registered with atexit).

livecoding 2.01 is yet another excellent utility for any developers It actually provides code reloading support library for Python.

There are two key facets this library:

• The code reloading functionality it provides.
• The bypassing of the standard module system with a custom one.

The standard module system is still there and continues to work with the custom one, but only the custom one is covered by the code reloading functionality of this library.

In order to decide whether you want the flexibility of the code reloading that this library provides, you need to decide whether you can live with writing the reloadable scripts within the custom module system.

Major Features:

1. Automatic code reloading on script file changes.
2. Less interruptions to developer workflow.
3. Code reloading allows a running application to change its behaviour in response to changes in the Python scripts it uses. When the library detects a Python script has been modified, it reloads that script and replaces the objects it had previously made available for use with newly reloaded versions.
4. As a tool, it allows a programmer to avoid interruption to their workflow and a corresponding loss of focus. It enables them to remain in a state of flow. Where previously they might have needed to restart the application in order to put changed code into effect, those changes can be applied immediately.

Requirements:

• Python

dbdeploy is a Database Change Management tool. The project helps developers and DBAs change their database in a simple, controlled, flexible and frequent manner.

The recurring problem with database development is that at some point you’ll need to upgrade an existing database and preserve its content. In development environments it’s often possible (even desirable) to blow away the database and rebuild from scratch as often as the code is rebuilt but this approach cannot be taken forward into more controlled environments such as QA, UAT and Production.

Drawing from our experiences, we’ve found that one of the easiest ways to allow people to change the database is by using version-controlled SQL delta scripts. We’ve also found it beneficial to ensure that the scripts used to build development environments are the exact same used in QA, UAT and production. Maintaining and making use of these deltas can quickly become a significant overhead - dbdeploy aims to address this.

How It Works

By comparing the SQL delta scripts on your filesystem against a patch table in the target database, it generates SQL scripts – it doesn’t directly apply them.

Invocation methods

dbdeploy can be called from within an ant build file.

DBMS support

dbdeploy supports the following DBMS:

Oracle
MS SQL Server
Sybase
Hypersonic SQL

Contact Form is a perl script that you can run on your website that will allow others to send you email through a web interface. Unlike other web to email gateways, Contact Form is designed to thwart spammers.
It does not allow email to be sent to unknown addresses, nor does it reveal addresses that it knows.
Main features:
- Allow email to be sent to a list of known email addresses through a web interface.
- Prevent email from being sent to other addresses.
- Never reveal email addresses through the web interface.
- Contain no cross site scripting (XSS) vulnerabilities.
- Do not allow arbitrary code to be run on the host.
- Provide adequate information in email headers to trace any spammers.
- Allow, but do not require, an external form.
- Server side validity checking of all data before email is sent.
- Optional client side validity checking of all data before the form is submitted.
- A default configuration that requires only a list of email addresses to be ready for use.
- A customizable interface that allows arbitrary fields.
- Easy to change the way it looks to integrate into your website
Setup:
- Download the contactform archive.
- Extract the contents of the download.
- Place contact.pl in your webservers cgi-bin directory or another place that allows scripts.
- Edit contact.pl to change the email addresses to which email can be sent.
- Optional - Change any other parameters in contact.pl to taste.
- Point your web browser at contact.pl on your server.
- Send yourself email through the web.

Webalizer is a fast, free web server log file analysis program. The project produces highly detailed, easily configurable usage reports in HTML format, for viewing with a standard web browser.
It was written to solve several problems that I had with currently available analysis packages. A vast majority of them were written in Perl or some other scripting language, and took forever to run. Some were not free. Some even produced wrong results, or results that were not in a format I found very useful.
In order to get the stats I wanted, in a format that I liked, I wrote The Webalizer, and have made it available here, to anyone who wants it, for any purpose. Starting as a simple Perl script with limited capabilities, it has grown into a full featured, robust and fast analysis tool, being used by thousands of systems around the globe.
Main features:
- Is written in C to be extremely fast and highly portable. On a 200Mhz pentium machine, over 10,000 records can be processed in one second, with a 40 Megabyte file taking roughly 15 seconds (over 150,000 records).
- Supports standard Common Logfile Format server logs. In addition, several variations of the Combined Logfile Format are supported, allowing statistics to be generated for referring sites and browser types as well. Now also has native support for wu-ftpd xferlog FTP and squid log formats as well.
- Generated reports can be configured from the command line, or by use of one or more configuration files. Detailed information on configuration options can be found in the README file, supplied with all distributions.
- Supports multiple languages. Currently, Catalan, Chinese (traditional and simplified), Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, Galician, German, Greek, Hungarian, Icelandic, Indonesian, Italian, Japanese, Korean, Latvian, Lithuanian, Malay, Norwegian, Polish, Portuguese (Portugal and Brazil), Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, Turkish and Ukrainian are available.
- Unlimited log file sizes and partial logs are supported, allowing logs to be rotated as often as needed, and eliminating the need to keep huge monthly files on the system.
- Distributed under the GNU General Public License, complete source code is available, as well as binary distributions for some of the more popular platforms.

Rad SFTP Applet is a graphical secure FTP (SFTP) applet. It is multi-threaded and thus capable of carrying out several concurrent uploads and downloads and resuming interrupted transfers.
The applet received a four star rating from jars.com - the premier java software review site and became featured on the official java website as well.
The secure FTP applet is ideal for Internet Service Providers and web hosting companies as a value addition to their service. The applet will also help web and software companies to reduce license costs with its per web site license model.
The desktop client is suited for individuals or organizations looking for a secure alternative to FTP.
Enhancements:
- Bugfixes and other improvements related to the management of hidden files and folders.

WebalizerXML provides a patch for making Webalizer produce XML output.

WebalizerXML is a simple patch for Webalizer that makes it possible to generate XML stats instead of regular HTML files.

It is very useful if you want to show your stats using your own templates or graphics.

It works only on Webalizer 2.01-10.