Free error prone software for linux

libgpg-error package contains common error codes and error handling functions used by GnuPG, Libgcrypt, GPGME and more packages.

Installation:

Please read the file INSTALL!

Here is a quick summary:

1) Check that you have unmodified sources. You can find instructions how to verify the sources below. Dont skip this - it is an important step!

2) Unpack the archive. With GNU tar you can do it this way:

"tar xzvf libgpg-error-x.y.tar.gz"

3) "cd libgpg-error-x.y"

4) "./configure"

5) "make"

6) "make install"

Mac::Errors is a Perl module with constants for Mac error codes.

SYNOPSIS

use Mac::Errors qw(openErr);

if( $value == openErr ) { ... }

my $error = $MacErrors{ $symbol }; # -- OR -- my $error = $MacErrors{ $number };

my $symbol = $error->symbol; my $number = $error->number; my $desc = $error->description;

# in MacPerl, $^E is meaningful, and we tie $MacError to it use Mac::Errors qw( $MacError );

open FILE, $foo or die $^E; # error number open FILE, $foo or die $MacError; # gets description from $^E

The %MacErrors hash indexes error information by the error number or symbol. Each value is a Mac::Errors object which has the symbol, number, and description.

The $MacError scalar performs some tied magic to translate MacPerls $^E to the error text.

mod_ssl_error is a X.509 certificate validation error trapping (SSL).

Valid errors are:

unable to get issuer certificate
unable to get CRL
unable to decrypt certificate signature
unable to decrypt CRL signature
unable to decode issuer public key
certificate signature failure
CRL signature failure
certificate not yet valid
certificate has expired
CRL not yet valid
CRL has expired
error in certificate "not before" field
error in certificate "not after" field
error in CRL "last update" field
error in CRL "next update" field
out of memory
depth zero self signed certificate
self signed certificate in chain
unable to get issuer certificate locally
unable to verify leaf signature
certificate chain too long
certificate revoked
invalid certification authority
path length exceeded
invalid purpose
certificate not trusted
certificate rejected
subject issuer mismatch
"akid" skid mismatch
"akid" issuer serial mismatch
"keyusage" different from "certsign"
unable to get CRL issuer
unhandled critical extension
"keyusage" not for CRL signing
unhandled critical CRL extension

Unicode Error Detector is a product for Plone used to pinpoint errors in your application leading to UnicodeDecodeErrors.

Do not use this product unless you are actively debugging a Unicode Error. Never use this product in production sites.

UnicodeDecodeErrors typically occur when you try to add a Unicode string to a non-ascii string. This product patches StringIO used by page templates to check if the appended string is a Unicode string, and if it is, it replaces the string with an error marker.

As there is some overhead associated with inspecting the strings instead of just appending to the output, this product is meant for debugging purposes only.

Usage

Put the product in your Products directory and restart Zope. Load the template causing the UnicodeDecodeError, and this tool will indicate the location by printing THIS IS WHERE THE ERROR IS in the rendered template.

You can then inspect the template and/or code more closely to figure out where the decode error happens.

Net::DBus::Error is a Perl module with error details for remote method invocation.

SYNOPSIS

package Music::Player::UnknownFormat;

use base qw(Net::DBus::Error);

# Define an error type for unknown track encoding type
# for a music player service
sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new(name => "org.example.music.UnknownFormat",
message => "Unknown track encoding format");
}


package Music::Player::Engine;

...snip...

# Play either mp3 or ogg music tracks, otherwise
# thrown an error
sub play {
my $self = shift;
my $url = shift;

if ($url =~ /.(mp3|ogg)$/) {
...play the track
} else {
die Music::Player::UnknownFormat->new();
}
}

This objects provides for strongly typed error handling. Normally a service would simply call

die "some message text"

When returning the error condition to the calling DBus client, the message is associated with a generic error code or "org.freedesktop.DBus.Failed". While this suffices for many applications, occasionally it is desirable to be able to catch and handle specific error conditions. For such scenarios the service should create subclasses of the Net::DBus::Error object providing in a custom error name. This error name is then sent back to the client instead of the genreic "org.freedesktop.DBus.Failed" code

POE (Perl Object Environment) parcels out execution time among one or more tasks, called sessions. Sessions multitask through cooperation (at least until Perls threads become mainstream). That is, each session returns execution to POE as quickly as possible so it can parcel out time to the next.
POE includes a high-level component architecture. Components are modular, reusable pieces of programs. They perform common, often tedious tasks so programmers can work on more interesting things.
Several POE components have been written to handle client, server, and peer networking tasks. Because of them, POE has become a convenient and quick way to write multitasking network applications.
Anyone can write and publish POE components. The CPAN contains a [steadily growing list] of them. The POE Components List includes ones that havent been uploaded to the CPAN yet.
POE provides medium- and low-level concurrency functions. Components use them to perform their tasks. The functions are also available to programmers who prefer to avoid the overhead of components at the expense of writing more code. Components and custom sessions coexist because they all use the same basic functions.
POE supports graphical toolkits such as Tk and Gtk. It is the only Perl programming framework that does this. It also supports Curses, HTTP, and other user interfaces. POE programs can present multiple user interfaces at once.
Enhancements:
- A number of stability and performance fixes were done, including making the tests less prone to race conditions, improving the installation process, eliminating known resource leaks, and reducing CPU use when combined with Tk.

Berkley Snoop for Linux is a module which adds support for the Snoop protocol, a TCP-aware link layer protocol designed that can improve the performance of TCP over networks of wired and single-hop wireless links.
While TCP adapts well to network congestion, it does not adequately handle the vagaries of wireless media. In this thesis, we address these challenges in detail and design solutions to them. These solutions incorporate link-layer techniques as well as enhancements to TCP at the sender and receiver. The Snoop protocol is a TCP-aware link layer protocol designed to improve the performance of TCP over networks of wired and single-hop wireless links.
The implementation is for kernels of 2.6.x series. This software is intended to use on routers acting between big fat pipe(BFP) link and wireless link.
The problem: The wireless link is error prone by its nature and BFP links such as satellite one has very big round-trip time. When error occurs on wireless segment it causes in speed reduction because the TCP protocol on sending side treats this error as link congestion although the error was just a temporary link quality loss and the connection cannt recover its speed.
The fix: The module will cache TCP segmets passing to host on wireless segment until the ACK(nowledgmet) is received or timeout expired. In case of timeout the segment will be retransmitted again. And by the way the module will drop all DUP(licate) ACK(nowledgmets) caused by packet loss on wireless segment and prevent the reduction of speed of flow from the host beyond the satellite link. The module works now only with connections initiated from wireless hosts.
Enhancements:
- fixed issues with improper use of locks & memory allocation the memory allocates now with GFP_ATOMIC priority