Free to be bound software for linux

Cache::Bounded is a size-aware in-memory cache optimized for speed.

SYNOPSIS

Cache::Bounded is designed for caching items into memory in a very fast but rudimentarily size-aware fashion.

Most intelligent caches take either a size-aware or use-aware approach. They do so by either anlysing the size of all the elements in the cache or their frequency of usage before determining which elements to drop from the cache. Unfortunately, the processing overhead for this logic (usually applied on insert) will often slow these caches singnificantly when frequent insertions are needed.
This module was designed address when this speed-penalty becomes a problem. Specifically, it is a rudimentarily size-aware cache that is optimized to be very fast.

For its size analysis, this module merely checks the number of elements in the cache against a raw size limit. (The default limit is 500,000) Additionally, to aid speed, the "size" check doesnt occur on every insertion. Only after a count of a certain number of insertions (default 1,000) is the size check performed. If the size limit has been exceeded, the entire cache is purged. (Since there is no usage analysis, there is no other logical depreciation that can be applied)
This produces a very fast in-memory cache that you can tune to approximate size based upon your data elements.

USAGE

my $cache = new Cache::Bounded;

$cache->set($key,$value);
my $value = $cache->get($key);

AMPLE is short for "A MP3 LEnder". I wrote AMPLE one summer when I was coding for a company and got fed up with having to FTP over all my MP3 files from my home server to the computer at work just to listen to them. And through the other "MP3 servers" I could find didnt fit my needs for one of the following reasons:
Depended on libfoo, libbar, python, perl, php3, Apache, libssl, etc, etc, etc...I just wanted to listen to the files
Had a lot of features for "DJ:ing" etc that I really didnt need. Well....it was fun to write too.
So whats good with AMPLE?
Small, standalone (written in C using no external libraries)
Portable (I think), I often try to compile it on the SourceForge compile farms
Allows you to listen to your own MP3s away from home, nothing more, nothing less
This is beginning to sound like marketing cr*p so Ill just stop right there, check out the links on the left for more info.
Enhancements:
- There are only two fixes in this release. One is a compilation fix for Solaris and the other one is a security fix. Turns out a buffer used for local communication didnt have sufficient checks. User data isnt written without checks though so the worst that can happen is that huge amounts of memory is allocated. The socket was also bound to the loopback device so it should only be locally abuseable.

POE::Session is a Perl module for event driven abstract state machine.

SYNOPSIS

# Import POE::Session constants.
use POE::Session;

POE::Session->create(

# Inline or coderef states.
inline_states => {
state_one => &coderef_one,
state_two => sub { ... },
},

# Plain and mapped object states.
object_states => [
$object_one => [ state_three, state_four, state_five ],
$object_two => { state_nine => method_nine },
],

# Plain and mapped package states.
package_states => [
$package_one => [ state_six, state_seven, state_eight ],
$package_two => { state_ten => method_ten },
],

# Parameters for the sessions _start state.
args => [ argument_zero, argument_one, ... ],

# Initial options. See the option() method.
options => %options,

# Change the sessions heap representation.
heap => [ ],
);
Other methods:
# Retrieve a sessions unique identifier.
$session_id = $session->ID;

# Retrieve a reference to the sessions heap.
$session_heap = $session->get_heap();

# Set or clear session options.
$session->option( trace => 1, default => 1 );
$session->option( trace );

# Create a postback, then invoke it and pass back additional
# information.
$postback_coderef = $session->postback( $state_name, @state_args );
$postback_coderef->( @additional_args );

# Or do the same thing synchronously
$callback_coderef = $session->callback( $state_name, @state_args );
$retval = $callback_coderef->( @additional_args );

POE::Session combines a runtime context with an event driven state machine. Together they implement a simple cooperatively timesliced thread.
Sessions receive their timeslices as events from POE::Kernel. Each event has two fields, a state name and a session identifier. These fields describe the code to run and the context to run it in, respectively.

Events carry several other fields which will be discussed in the "Predefined Event Fields" section.

States are re-entrant since they are invoked with their runtime contexts. Although its not usually necessary, this re-entrancy allows a single function to be bound to several different sessions, under several different state names.
As sessions run, they post new events through the Kernel. These events may be for themselves or other sessions, in which case they act as a form of inter-session communications. The Kernel can also generate events based on external conditions such as file activity or the passage of time.

POE provides some convenient built-in states with special meanings. They will be covered later on in the "Predefined States" section.

Iter Vehemens ad Necem project is a graphical roguelike game.
Iter Vehemens ad Necem (IVAN) is a graphical roguelike game which currently runs in Windows, DOS, and Linux. It features advanced bodypart and material handling, multi-colored lighting and, above all, deep gameplay.
Fellow adventurer, turn back while you can! For here begins the roguelike Iter Vehemens ad Necem, a Violent Road to Death. If you choose to travel along it, you will dive into countless exciting adventures to gain items of great magic, attain powerful equipment made of mysterious materials, bathe in the blessings of mighty gods and recruit loyal allies of various shapes and sizes.
Unfortunately, along the way you will also often be dangerously injured, poisoned, catch numerous diseases, lose several limbs and transform into manifold different kinds of pitiful creatures in the darkest depths of hostile dungeons. And, at the end of the road, you are bound to perish in a most gruesome and painful way. Dont say we didnt warn you.
Enhancements:
- fluids can now cover items and characters and interact with them
- items made of iron alloys can now rust
- added directional light and day and night which use it
- added some cosmetical weather effects
- New Attnam has now many new NPCs, for instance a sumo wrestler who can be challenged
- polymorph control is now more interesting; you need to see a monster once before you can polymorph into it, and more powerful ones require more intelligence
- added wands of acid rain, mirroring and necromancy
- added scrolls of detect material, harden material and golem creation
- added several new monsters, eg. powerful named archangels for each god and necromancers who raise skeletons and zombies to do their bidding
- one can now give pets tactical commands, change their equipment and use them to carry extra stuff (these are accessed using Chat and Issue commands keys)
- the player can now panic if he gets hit too much, like the monsters have done in previous versions
- the player can now become exhausted if he fights for too long and/or uses the new run command too much
- spiders are now able to make webs
- you can now get stuck to slime
- badly hurt/trapped bodyparts now become unusable until they regain some HP/become untrapped
- it is now possible to browse detailed death reasons of individual monsters in the postgame massacre lists
- added many new informative graphical details, for instance recently altered attributes are shown with a different color for some time
- gloomy cave is now longer and has more special levels and rooms
- all the endgame battles are more complex
- added leprosy, a nasty disease which causes your limbs to drop off randomly

libyama is a malloc implementation that bundles leak tracking by auditing allocations, array bound write detection, detection of access to freed memory, free/realloc on invalid pointers. It grew out of an attempt to build array bound overwrite detection into LeakTrac, a leak tracker I wrote earlier.
Since LeakTrac performed only book keeping and not any allocation, it was not possible to make LeakTrac detect array bound write, hence an allocator that does; and also tracks leaks.
You can think of it as merging LeakTrac and code that was inspired by ElectricFence.
If you only want to track leaks, then LeakTrac is just what you need. If you want an allocator that lets you debug also, then YaMa is the one for you. Sure, there are other similar things on the block - which is why this is Yet another Memory allocator.
Main features:
- provides malloc, calloc, realloc and free
- tracks and reports leaks
- detects accesses beyond allocated memory
- detects accesses to freed memory
- detects free on non-malloced pointers, NULL pointers
- detects realloc on non-malloced pointers
Installation:
Currently YaMa is written for Linux x86. Youll need a kernel that provides mmap etc, and gcc that can build ELF shared libraries. You also need to install binutils, if you havent already (very unlikely) And youll need the /proc filesystem.
To install YaMa
Unpack the archive
Edit Makefile; the only things you need to change are INSTALLDIR and BT.
make lib to make
make install to install. Youll need write permission on INSTALLDIR.
You may need to run ldconfig
Usage:
YaMa contains libyama.so, a shared library installed into INSTALLDIR by make install. The library provides malloc, calloc, realloc and free which can be used as replacements to their libc implementations.
A program can be linked against libyama on the command line (-lyama). A more interesting way to use libyama would be to preload it using LD_PRELOAD. The command line
LD_PRELOAD=libyama.so
would cause all calls to malloc, calloc, realloc and free originating from the program being run to be handled by the YaMa implementation. If libyama.so doesnt show up on ldconfig -p or it is not on your LD_LIBRARY_PATH, you need to specify the full path length.
When the program errs by accessing memory across an array bound, i.e, beyond the memory allocated using malloc/calloc/realloc, it receives a SIGSEGV. An access to freed memory also results in a SIGSEGV. If youve compiled your program using -g, you can locate the offending statement using any debugger on the core file. Note that overwrites on statically allocated arrays are not detected by YaMa.
If the program peforms an invalid free or realloc, an "Alert!" message is written to stderr, along with the call chain till the free/realloc. The call fails.
Upon normal program termination, either thro exit or return from main, a summary of leaks is printed on stderr. The size of each chunk of memory that remains un-freed at the end of the program is reported, along with the call chain till the allocation.
The behaviour of YaMa on malloc (0) (or calloc (x, 0)) is controlled by the environment variable ALLOWMALLOCZERO. If this variable is set to values = 2, YaMa returns a valid pointer and no warning is printed. Writes to this pointer, too, will fail. If ALLOWMALLOCZERO is not set, the behaviour is identical to ALLOWMALLOCZERO = 0.
Enhancements:
- Fixed a bug in the stack backtrace code which would crash libyama. Compile time control of backtracing (Ive found it useful at times not to have tracing).

Amrita VPN is an easy-to-use open source VPN solution that runs on the GNU/Linux platform. The implementation is fully in userspace and requires no kernel patches or enhancements. It uses openssl library for strong encryption and authentication through SSLv3.
Amrita VPN IS used to connect two private networks through a public network such as the Internet. It requires only one end to have a direct Internet connection preferably with a permanent public IP address. The other end could be connected to the Internet via a masquerading router.
tar xvfz amvpn-0.99.tar.gz
- cd amvpn-0.99
- ./configure
- make
- make install
Root privilege is required to install and run AmritaVPN. You would need a root login shell to succesfully run make install. If youre logged in as root, then of course you already have a root login shell.Otherwise you must do: su - instead of simply su at command prompt.
Enhancements:
- Added keepalive message option.
- Added basic flow control logic in the relay loop - Prevents amvpn from becoming CPU-bound when theres a break/congestion in the outbound link.

libgnomedb is a data-bound UI library, based on libgda. The project provides all kind of data management-related widgets, like grids, lists, entries, and some specialized widgets like connection and error dialogs, a database browser.

It also provides configuration tools that integrate smoothly into the GNOME desktop and allow for a centralized management of the data access used by all applications using libgda and/or libgnomedb.