Free legacy 1.1 software for linux

Lynns Legacy is an action-adventure game. Lynn the mercenary is on a quest to figure who tried to kill her and why.

Follow Lynn the mercenary as she recollects the mysterious mission that nearly took her life. Travel through multiple overworld areas, (forest, towns, desert, mountains) and boldly step into uncharted dimensions in search of memory!

Dune Legacy is a free clone of Dune2.

Updated clone of Westood Studios dune2. Uses original dune2 data files (not included) to provide original dune2 graphics and sounds.

New features include multiple unit selection/control, high resolution support, multiplayer gaming via tcp/ip, in game.

Gajim is a Jabber client written in PyGTK.
Gajim does not require GNOME to run, eventhough it exists with it nicely. Gajim is released under the GNU General Public License.
Main features:
- Tabbed chat windows
- Groupchat support (with MUC protocol)
- Emoticons, URL grabber
- Systray icon
- TLS & GPG support (with SSL legacy support)
- Transport Registration support
- Service Discovery including Nodes
- Multiple accounts support
- Gajim is available in English, French, German, Russian, Spanish, Polish, Portugese, Greek and Bulgarian

FLAT::Legacy::FA::RE is a regular expression base class.

SYNOPSIS

use FLAT::Legacy::FA::RE;
use FLAT::Legacy::FA::NFA;
my $re = RE->new();
$re->set_re(a|b|(hi)*);
my $nfa = $re->to_nfa();
print $nfa->info(); # see stuff on NFA
my $dfa = $nfa->to_dfa();
print $dfa->info(); # see stuff on DFA
my @removed = $dfa->minimize();
print $dfa->info(); # see stuff on minimized DFA
print "Removed ".($#removed+1)." statesn";

This module implements a regular expression parser, and supports the conversion of a RE to a deterministic finite automata. A homegrown recursive descent parser is used to build the parse tree, and the method used to conver the regular expression to a DFA uses no intermediate NFA.
Recursive Descent-safe Regex Grammar:

R -> O

O -> CO

O -> | CO | epsilon

C -> SC

C -> .SC | epsilon

S -> LS

S -> *S | epsilon

L -> a | b | c |..| 0 | 1 | 2 |..| (R) | epsilon

Terminal symbols: a,b,c,..,z,0,1,2,..,9,|,*,(,)

NOTE: Concatenation operator, ., is not a terminal symbol and should not be included in the regex

FAQ: Q: Does this support Perl regular expressions?
A: No, just the regular expression using the terminal symbols listed above.

Iguana is designed as a base for the provision of operating system (OS) services for embedded systems. Among others, it provides the underlying OS for Wombat, our version of paravirtualised Linux designed to provide legacy support for embedded systems.

Iguana runs on top of the L4 microkernel, presently the Version 4 API as implemented by L4Ka::Pistachio. L4/Iguana is designed to support a painless transition to the new security-oriented API being developed for L4.

While it borrows many ideas from the Mungi operating system, Iguanas target domain of embedded systems requires a different approach to a number of issues. The main characteristics of Iguanas design are:

- Iguana complements, rather than hides the underlying L4 API. It provides services virtually every OS environment requires, such as memory and protection management, and a device driver framework;
- the memory and cache footprints of Iguana are kept small;
- low-overhead sharing of data is supported;
- Iguana supports the separation of protection and translation, by encouraging a non-overlapping address-space layout. This means that Iguana-based systems can be readily deployed on processors without virtual memory, and can also obtain the best possible performance on the ARM7 and ARM9 cores widely used in embedded systems.

eCryptfs is an POSIX-compliant enterprise-class stacked cryptographic filesystem for Linux. eCryptfs is derived from Erez Zadoks Cryptfs, implemented through the FiST framework for generating stacked filesystems.
eCryptfs extends Cryptfs to provide advanced key management and policy features. eCryptfs stores cryptographic metadata in the header of each file written, so that encrypted files can be copied between hosts; the file will be decryptable with the proper key, and there is no need to keep track of any additional information aside from what is already in the encrypted file itself. Think of eCryptfs as a sort of ``gnupgfs.
eCryptfs is a native Linux filesystem (other popular cryptographic filesystems for Linux require FUSE or operate via RPC calls). It can be built and distributed as a stand-alone kernel module for the Linux kernel version 2.6.15 or higher; there is no need to apply any kernel patches.
Enhancements:
- Legacy releases of eCryptfs.

libGlass is a library for distributed computing that makes its programming easy.
The Glass framework is a scalable set of components that can be used by applications to perform distributed computing. Applications are built reusing the available components as needed.
One of the major goals of libGlass is to be a user-friendly framework, not only suitable for new applications, but also for legacy code.
This is an important feature, as most available solutions for distributed computing require a substantial amount of rewrite of legacy code; some of them require a complete change of the application design.
libGlass was designed to achieve the following goals:
- User transparency: the library must be as transparent as possible. Any tasks that are repetitive or that can be done automatically should be done by the library, without user intervention.
The API (Application Programmers Interface) should be simple and intuitive, with a smooth learning curve and provide high level primitives that can be easily used to solve any problems. Legacy code should be easy to port.
- Extensibility: the library must be easily extensible, requiring no recompilation or any other modification to support new features; they must work as plug-ins.
- Performance and efficiency: since the library is for distributed computing, it has to be efficient, consuming as little processing time as possible.
- Network protocol independence: an abstraction layer makes it possible to change the underlying network protocols easily. The application can use the network protocol most efficient for its needs.
- Portability and interoperability: heterogeneous clusters and grid computing being every day more common, the library must be not only portable, but allow different architectures to interoperate seamlessly, something that is not true for most implementations of distributed computing solutions.
- Scalability: there is no use for a distributed solution that does not scale well. Glass has to work well in all sorts of environments, from small clusters to huge grids, and be able to adapt itself to achieve best results.
- Reconfigurable network architecture: most existing solutions are based on a fixed network architecture, usually Master/Slave or Client/Server.
Given the requirements of scalability and performance, and the fact that peer-to-peer applications are everyday more common, its unreasonable to fix the network architecture: the developer should be free to define how nodes will connect with each other.
- Reliability and fault tolerance: distributed computing often requires reliability. Its not acceptable that the misbehavior or crash of a single node crashes the entire computation.
As clusters grow in size and grid computing becomes more common, the MTBF (Mean Time Between Failures) shrinks to a point that it cannot be ignored.
libGlass must be able to handle node crashes gracefully, keeping the application running and avoiding deadlocks and other problems that could arise from the node crash. Nodes should be allowed to join or leave at anytime.
- Thread support: the library must be completely thread-safe.
With clusters of symmetric multiprocessors (SMP) computers becoming more common and new technologies such as HyperThreadingTM, its unacceptable for a distributed computing framework to have thread issues.
Main features:
Plugins:
- Synchronous shared memory
- Distributed asynchronous events
- Synchronization barriers
- Remote aliases
Protocols:
- TCP/IP
- UDP/IP (unfinished)
Architectures:
- Client/Server
- Pure peer to peer (planned)
- Hierarchical (planned)
- Anonymous peer to peer (planned)
Bindings for:
- Java (mostly finished)
Enhancements:
- Fixed packaging problems that could abort compilation

The syncopt script and its associated work practices are yet another approach to the standard sysadmin problem of keeping multiple machines software installations up to date.
It is independent of the vendors packaging scheme and thus you can use either your vendors system or syncopt, or both!
The core notion is that the install is done once on a central machine and then syncopt takes care of attaching that to every client, often via cron.
- easy to use
- flexible enough to permit control of what is installed locally on a machine and what is served remotely from a central server (for disc space or other reasons)
- keep out of the way of the ``vendors namespace, to avoid treading on the vendors install and conversely to protect our additions from damage by vendor upgrades and patches.
Main features:
lightweight
- If a package is not to be installed local to a client then the burden is usually just two symlinks on the client.
optional
- You can install packages with syncopt or with the vendors packaging scheme, or both!
permits trial installs
- Under syncopt you can install multiple versions of the same package for trial or legacy purposes.
centralised
- The default package version is controlled by a symlink on the master host; change that and all the clients will follow suit next time they run syncopt.
customisable
- Clients can control which packages are local and also override which version is their default for a given package.
Using
Local Package Install
As a consequence, to make an instance of something local to a client machine (lets call it pkg, release version), remove the local symlink:
$ rm /opt/pkg-version
Make a stub directory:
$ mkdir /opt/pkg-version
Alternatively, just edit the .syncopt file and add this line:
pkg-version local
Run syncopt:
$ syncopt -x
That syncs everything. You can just do the new package like this:
$ syncopt -x pkg pkg-version
which syncs the generic (unversioned) link and the version specific local directory.
Undoing a Local Package Install
To make a once-local copy remote, remove the local copy:
$ rm -rf /opt/pkg-version
Also, if you edited the .syncopt file as above, remove that line.
Run syncopt:
$ syncopt -x pkg pkg-version
Bringing a Client into Sync after a New Package Install
To set up a new clients /opt directory after a fresh install:
$ mkdir /opt # if necessary
$ syncopt -x
/opt/.syncopt
The behaviour deduced from the presence or absence of a directory can be overridden with the /opt/.syncopt file, which contains line of the form:
pkg version
to make version the default package version on this particular machine, or
pkg local
to force a package to be local on this machine, or
pkg-version local
to make a particular version local, or
pkg nosync
to not run syncopt on it at all.