Free webalizer 2.01 software for linux

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.

Webalizer::Hist is a Perl module to parse the webalizer.hist-file.

SYNOPSIS

use Webalizer::Hist;

if(my $dwh = Webalizer::Hist->new(source => "webalizer.hist")) {

while(my $hashref = $dwh->month()) {
print "Got " . $hashref->{totalhits} . " hits in month "
. $hashref->{month} . "n";
}

if(my $totals = $dwh->totals()) {
print "This website used a total of " . $totals->{kbytes}
. "KBn";
}

}

Webalizer - a popular web server log analysis program - uses a so-called webalizer.hist file to store (temporary) statistics. That file usually contains one year of monthly statistics about a website/webserver.

Webalizer::Hist can be used read and parse those data.

Geolizer is a patch for Webalizer that uses the GeoIP library to generate faster and more reliable geographic statistics than the default DNS suffix method. It is recommended that DNS reversal be disabled on your HTTP server for improved performance and more accurate statistics. It can be compiled under MinGW/MSYS and features a human-readable transfer size display.
Side effects can be: possibility to compile native Win32 port under MinGW/MSYS and human-readable size display.
"GeoIP is a C library that enables the user to find the country that any IP address or hostname originates from. It uses a file based database that is accurate as of March 2003. This database simply contains IP blocks as keys, and countries as values. This database should be more complete and accurate than using reverse DNS lookups."
And how to port this feature to Webalizer? At users point of view, patched code takes each IP address and discovers its country default suffix. Then, obtained suffix is appended to hostname (somewhat like "127.0.0.1" becoming "127.0.0.1.net"). After this, Webalizer normally processes such host, I mean it finds full country name and accounts stats on it. This is quite abstract, but the real process isnt too far, its just s bit more optimized. Oh, quite forgot it: if processed entry isnt IP address but DNS hostname, Webalizers
default suffix routines are used. This method is less precise, but resolving DNS once again isnt a smart solution.
Enhancements:
- Country flag picture support was added, but needs the flags package from http://flags.blogpotato.de/.
- Country names were updated from the GeoIP source.
- Localization of country names was improved.
- Code cleanups were done.
- The "--enable-geoip" option is now default, as is "--enable-flags".
- The Win32 version now seeks the webalizer.conf file in the executable directory.
- Static binaries are now bound with the GeoIP 1.4.1 library and "GEO-106FREE 20070101 Build 1" database.

LZO is a data compression library which is suitable for data de-/compression in real-time. This means it favours speed over compression ratio.
LZO is written in ANSI C. Both the source code and the compressed data format are designed to be portable across platforms.
Main features:
- Decompression is simple and *very* fast.
- Requires no memory for decompression.
- Compression is pretty fast.
- Requires 64 kB of memory for compression.
- Allows you to dial up extra compression at a speed cost in the compressor. The speed of the decompressor is not reduced.
- Includes compression levels for generating pre-compressed data which achieve a quite competitive compression ratio.
- There is also a compression level which needs only 8 kB for compression.
- Algorithm is thread safe.
- Algorithm is lossless.
Enhancements:
- Changed the configure system to install the LZO library under the name "liblzo2" so that parallel installation with LZO v1 is possible.
- Improved auto-configuration in miniLZO for some embedded targets like Blackfin and H8/300 processors.

SEOlizer is a GPL application that generates web pages of analysis, from webserver log files (Apache, etc). The seolizer is based on the webalizer code.
Please note that the code is one-night hack, from my point of view its a very very poor quality! It is not recommended to run seolizer on a production server. I have published the seolizer to get some feedback from SEO community. Stable version will be available in several months, after I make clear decision how to implement all required features. Your feedback is appreciated !
Compile seolizer by running make all -C src. Then you can run it using ./seolizer [logfile]. Output will be placed in the current directory.
SEOlizer functions
Web spiders daily/monthly crawling reports (incl. bots IP addresses)
Keyword and phrase analysis, displays pages that matched query
Most popular pages for search engine query results and relevant keywords and phrases
Fully static HTML
About SEO
Search engine optimization (SEO) as a subset of search engine marketing seeks to improve the number and quality of visitors to a web site from "natural" ("organic" or "algorithmic") search results. The quality of visitor traffic can be measured by how often a visitor using a specific keyword leads to a desired conversion action, such as making a purchase or requesting further information. In effect, SEO is marketing by appealing first to machine algorithms to increase search engine relevance and secondly to human visitors.
Enhancements:
- Pagerank support was added along with support for www.rankcheck.info.
- The code was cleaned up and better HTML was implemented.

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).

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.

MLDBM is a Perl module to store multi-level hash structure in single level tied hash.

SYNOPSIS

use MLDBM; # this gets the default, SDBM
#use MLDBM qw(DB_File FreezeThaw); # use FreezeThaw for serializing
#use MLDBM qw(DB_File Storable); # use Storable for serializing

$dbm = tie %o, MLDBM [..other DBM args..] or die $!;

This module can serve as a transparent interface to any TIEHASH package that is required to store arbitrary perl data, including nested references. Thus, this module can be used for storing references and other arbitrary data within DBM databases.

It works by serializing the references in the hash into a single string. In the underlying TIEHASH package (usually a DBM database), it is this string that gets stored. When the value is fetched again, the string is deserialized to reconstruct the data structure into memory.

For historical and practical reasons, it requires the Data::Dumper package, available at any CPAN site. Data::Dumper gives you really nice-looking dumps of your data structures, in case you wish to look at them on the screen, and it was the only serializing engine before version 2.00. However, as of version 2.00, you can use any of Data::Dumper, FreezeThaw or Storable to perform the underlying serialization, as hinted at by the SYNOPSIS overview above. Using Storable is usually much faster than the other methods.