Free needing software for linux

pmping provides a parallel multiple host ping with audible results (beep on the PC speaker).
pmping is a script that pings multiple hosts in parallel and gives audible results depending on host state.
The sounds come from the internal PC speaker, thus not needing a sound card. It beeps when a host OS is losing many packets, or when it is down.
If the host is down, the script can send an email notification or run a command. All aspects are fully customisable by the user.
Main features:
- Logs notifications to standard output.
- Reloads config file on-the-fly.
- Ability to run a command when a host is down.
- Sends e-mail notifications when a host is down and when it comes up.
Enhancements:
- Corrected dynamic config reload (wasnt really working).
- Try to catch SMTP connection errors when sending notification e-mails.
- Changed the way we check network errors (regex was not working).

Enterprise Sign On Engine (ESOE) is an advanced system which allows an enterprise to meet its individual goals for integrated identity management, federation, single sign on, authorization and accountability for resource access in a very extensible manner.
The ESOE is built using the OASIS SAML 2.0 specification, and the ESOEs powerful authorization engine is built around a reduced version of the OASIS XACML 2.0 standard which we have called Lightweight eXtensible Authorization Control Markup Language or "LXACML".
The ESOE can integrate identity from unlimited repositories, automatically create sessions for users whom are logged into Active Directory (true single sign on), provide for centralized authorization policy management and natively federate with technologies such as Shibboleth and OpenID.
We hope youll find the ESOE a good choice for your needs amongst the wide variety of SSO solutions that are available, both from commercial providers and other open source projects. Of course if youre already using an SSO solution, there is a pretty good chance the ESOE can interact with it, allowing you to use the enhanced capabilities of the ESOE without needing to replace everything you already have.
Being heavily standards based, all your existing identity infrastructure such as LDAP compliant directories, databases and even flat files are only a plugin away. The ESOE is designed to fit around your environment, not have your environment change to fit it.
Were calling the current release an Alpha and some of the service providers, tools and documentation are still coming up to full completion. Nonetheless, we hope youll have a look around at what the ESOE can do for your enterprise and contribute back anything you can to help us build a strong community of users for the future.
Enhancements:
- Many bugfixes have gone into this release specifically relating to MySQL deployments.
- New features for this release are integrators for Confluence, Jira, and Blackboard.

e2fsimage allows you to create ext2 filesystem images, mostly used on Linux systems, by copying an entire directory structure into an ext2 formatted image without needing root permissions.
Without this tool you need to loopback-mount an existing filesystem image and copy all files there as root.
This application is usually used by people creating rescue disks, initrds, bootable floppys or CDs or the more. Especially on build hosts where they do not have root permissions and the ptrace() bug is already fixed.
Enhancements:
- support for user ids in .UIDGID file and usernames resolved by passwd file
- free uiddb structure after use
- manpage updated

OpenThought is a Web Application Environment which doesnt require page reloads.

SYNOPSIS

use OpenThought();

my $o = OpenThought->new( $OP );

my $field_data;
$field_data->{myTextBox} = "Text Box Data";
$field_data->{myCheckbox} = "true";
$field_data->{myRadioBtn} = "RadioBtnValue";
$field_data->{mySelectList} = [
[ "text1", "value1" ],
[ "text2", "value2" ],
[ "text3", "value3" ],
];

my $html_data;
$html_data->{id_tagname} = "New HTML Code";

print $o->serialize({
fields => $field_data,
html => $html_data,
focus => "myTextBox",
javascript => $javascript_code
});

OpenThought is a powerful and flexible web application environment. OpenThought applications are different from other web applications in that all communication between the browser and the server is performed in the background. This gives a browser the ability to receive data from the server without ever reloading the currently loaded document. Data received can be displayed automatically on the existing page, can access JavaScript functions and variables, and can load new pages. Additionally, OpenThought completely manages all of your session data for you. These features give the look and feel of a full-blown application instead of just an ordinary Web page.

OpenThought is extended with OpenPlugin, also described briefly in this documentation.

OpenThought works by communicating with the server through the use of a hidden frame. Now some may say "Frames? Youre using frames??" No need to fret though, the frame is completely hidden. There is no visible way for your users to tell that they are using an application which makes use of frames.

This hidden frame performs all communication with the server for you, and allows your browser to talk to the server without reloading the content currently visible in your web browser. This is how OpenThought can update portions of the screen, and how the server can run JavaScript code in the browser, all without reloading the page.

Any time an OpenThought application is loaded, a unique session id is generated for that user. Each time communication takes place between the browser and server, OpenThought is careful to make sure that this session id is sent along with the request. There is nothing you need to do to make this work, it is done for you. When youre programming your application, you can always expect a session id to be sent to the server, and you can easily retrieve it along with the rest of the data sent by the browser.

In addition to being able to update portions of a screen, you can also load new pages within the content frame. If you choose to load new pages, your session continues to be maintained.

OpenThought gives you an easy way of tieing together multiple web pages, and allows you to build web applications which act like "real" applications. When an application is required, some people would decide to build it in Tk, Visual Basic, Gtk, or any number of other systems which offer a visual interface. But then, your application is either not available on the web, or you have to create a seperate web interface to interact with the backend.

Have you ever tried to create a web interface which minics the interface of a non-web based application? The web based application no longer looks or acts like your other interface, it acts like an ordinary webpage. It probably uses several screens to get the same amount of content that your application offered in one.

By not ever needing to reload the page, OpenThought offers this application look and feel thats been missing from the web. This allows you to create just one interface, for both LAN and web use.

The Zero Install system makes software installation not merely easy, but unnecessary. Users run their applications directly from the Internet from the software authors pages.
Caching makes this as fast as running a normal application after the first time, and allows off-line use.
Main features:
- Software is only ever cached, not installed. Anyone can run any software, and nothing is run as root.
- Running a program is done in the same way whether its cached or not.
- Running cached software is as fast as running traditionally-installed software.
- Zero Install is both simpler and more secure than traditional packaging systems.
- Software can be removed from the cache to free space without affecting the behaviour of the system (it will be re-cached on demand).
- You can still run a program you cached last week, without using the net again.

Alvis::Pipeline is a Perl extension for passing XML documents along the Alvis pipeline.

SYNOPSIS

use Alvis::Pipeline;
$in = new Alvis::Pipeline::Read(host => "harvester.alvis.info",
port => 16716,
spooldir => "/home/alvis/spool");
$out = new Alvis::Pipeline::Write(port => 29168);
while ($xml = $in->read(1)) {
$transformed = process($xml);
$out->write($transformed);
}

This module provides a simple means for components in the Alvis pipeline to pass documents between themselves without needing to know about the underlying transfer protocol. Pipe objects may be created either for reading or writing; components in the middle of the pipeline will create one of each. Pipes support exactly one method, which is either read() or write() depending on the type of the pipe. The granularity of reading and writing is the XML document; neither smaller fragments nor larger aggregates can be transferred.

The documents expected to pass through this pipeline are those representing documents acquired for, and being analysed by, Alvis. These documents are expressed as XML contructed according to the specifications described in the Metadata Format for Enriched Documents. However, while this is the motivating example pipeline that led to the creation of this module, there is no reason why other kinds of documents should not also be passed through pipeline using this software.

The pipeline protocol is described below, to facilitate the development of indepedent implementations in other languages.

EncFS provides an encrypted filesystem in user-space. EncFS runs without any special permissions and uses the FUSE library and Linux kernel module to provide the filesystem interface. You can find links to source and binary releases below.

As with most encrypted filesystems, Encfs is meant to provide security against off-line attacks; ie your notebook is stolen, your backups are stolen, etc. The way Encfs works is different from the �loopback� encrypted filesystem support built into the Linux kernel because it works on files at a time, not an entire block device.

You do not need to allocate storage ahead of time for EncFS.

Advantages of a pass-thru system vs an encrypted block device:

An empty EncFS filesystem consists of a couple dozen bytes. With a loopback encrypted filesystem, you allocate a filesystem ahead of time with the size you want.

An EncFS filesystem can be backed-up on a file-by-file basis. A backup program can detect which files have changed, even though it wont be able to decipher the files. This way backups can be made without needing to mount the encrypted filesystem.

An EncFS acts as a translator for filenames and file data and should theoretically be able to pass through to any underlying filesystem. You could have an EncFS filesystem on a DVD, or a DVD mounted remotely and served through a Samba server and mount it locally with EncFS in order to view the encrypted data (your mileage may vary).