Free l software for linux

M.U.L.E is a linux port of clone of old MULE for C64 & PC.

This is a Linux/SDL port of a MULE clone. For those unfamiliar, MULE is an early resource strategy game.

You play a colonist on the moon, you acquire territory, and decide how to use it, by either farming, mining ore, collecting solar energy or mining crystals.

You compete with 3 other players, most points at the end of a preset number of months wins.

L.A.U.R.A project provides a secure and performant e-mail proxy designed with the goal of shutting down the "Unsolicited Commercial/Bulk E-mail Era".
What is "Greenmarking"?
Greenmarking is something I think I invented myself (I might be wrong though, I coulndt find it anywhere else). Greenmarking works like this: if a triplet of (sender_ip, sender, recipient) is first seen, it gets marked green. The message will be sent unmarked with the meaning of "never seen it before". Next time the triplet is met, the message will also be marked green, meaning "I know this guy already".
Yes I know this sounds like greylisting (its a variation of it, hence the name). However, greenmarking is (and should be) done after greylisting. Why? Greylisting mostly means that the passing message is almost certalny originating from a valid (E)SMTP mail server daemon. Worms usually dont retry too much. So greenmarking is effective especially against evil mail selvers. Its implemented in the project. Just add an Inbox filter to your (web)mail client and move all the messages with a "neverseen" header in a special suspect folder. If you dont want to hassle with them, activate the Inbox filter only after youve run the greenmarking daemon for a while (1/2 weeks maybe?).
Main features:
- ESMTP capability for interoperating with Postfix
- Lightening fast B+ infrastructure for internal database
- No false positives
- No "lost" e-mail messages
- No miss-rate
- BSD license (the most liberal and FREE, in honour to the FreeBSD team)
- Its written in plain old C
- It was designed to be as fast as applicable
- It is (going to be) very secure (multiple audits, formal verifications, programming care)
- No package dependencies - no extra libraries or tools needed
- Hassle-free for admins - just install it
- Hassle-free for users - it just works, without user intervention
- Hassle-free and polite with other Internet neighbours - no rude messages, nothing
- Secure inter-server cooperation for MX backups - without any hassle or complexity (needs to be done)

DCE::Login is a Perl extension for interfacing to the DCE login API.

SYNOPSIS

use DCE::Login;
my($l, $status) = DCE::Login->get_current_context;
my $pwent = $l->get_pwent;

Perl extension for interfacing to the DCE login API.

PawPaw is a forth-like language except that it allows top-down development.
There are several stacks. As you would expect there is a data stack, a return stack. But there is also a control structure stack.
Include files are implemented with the # token, which is followed by the filename to include (up to 19 levels).
Here is a list of the words that are implemented so far:
EXIT calls exit(0) to end the interpreter.
+L add longs
.L print long
+ int add
. int print
: define a new word
niy print that a word (string arg) is not implemented, exit the interpret loop early.
; end a definition
"word" edit calls the Kwrite editor on the source file name corresponding to word.
(note the name of the file is a hex string followed by .pp)
size var name define a variable.
value const name define a constant
@C fetch from a character var
!C store to a char var
@S fetch from a short var
!S store to a short var
@ integer fetch
! integer store
- int subtract
- int multiply
% int modulus
/ int divide
& integer and
| integer or
^ integer exclusive or
~ 1s complement integer
> integer shift right
> < >= L convert int to long
L->I convert long to int
@L fetch long
!L store long
-L long subtract
*L long multiply
%L long modulus
&L long and
|L long or
^L long eor
~L ones complement long
L shift long right by int arg
L =L !=L ==L long relationals
dup int dup
dupL long dup
drop int drop
dropL long drop
rot int rot
rotL long rot
swap int swap
swapL long swap
pick int pick
pickL long pick by int arg
[]! subscripted store
/* ... */ comment
"word" compile compile a definition file
"xxx" "yyy" add_dep add a dependency for yyy to word xxx file.
control structure
if (expr) then true-part else false-part fi
or
if (expr) then true-part fi
while expr do body od
until expr do body od
Enhancements:
- Autoloading was fixed.

AI::Categorizer::Learner::SVM is a Perl module to support Vector Machine Learner.

SYNOPSIS

use AI::Categorizer::Learner::SVM;

# Here $k is an AI::Categorizer::KnowledgeSet object

my $l = new AI::Categorizer::Learner::SVM(...parameters...);
$l->train(knowledge_set => $k);
$l->save_state(filename);

... time passes ...

$l = AI::Categorizer::Learner->restore_state(filename);
while (my $document = ... ) { # An AI::Categorizer::Document object
my $hypothesis = $l->categorize($document);
print "Best assigned category: ", $hypothesis->best_category, "n";
}

This class implements a Support Vector Machine machine learner, using Cory Spencers Algorithm::SVM module. In lots of the recent academic literature, SVMs perform very well for text categorization.

Grid::Transform is a Perl module with fast grid transformations.

SYNOPSIS

use Grid::Transform;

$g = Grid::Transform->new([a..o], rows=>5);
$g->rotate_270->flip_vertical;
print join( , $g->grid), "n";

The Grid::Transform module provides fast methods to transform a grid of arbitrary data types.

METHODS

$g = Grid::Transform->new( @grid, rows=>num, columns=>num )

Creates a new Grid::Transform object. The first argument is a reference to a 1-dimensional array representing a 2-dimensional "row major" (row by row) grid. (A column major grid is simply the counter transpose of a row major one.) The grid may be composed of arbitrary data types. The original array is never modified- all transformations operate on a copy.

At least one dimension must be specified. If the grid and dimensions do not produce a rectangular grid extra empty elements ("") will be added to the grid.

$g2 = $g->copy

Returns a copy of the original Grid::Transform object.

These methods get or set the grid attributes:

@grid = $g->grid
$grid = $g->grid
@grid = $g->grid( @grid )

In list context, returns an array representing the current grid. In scalar context, returns a reference to the array. Accepts an array reference representing a new grid. The new grid will be resized if the dimensions of the previous grid do not match.

$g->rows
$g->rows( $num )

Returns the current number of rows.

$g->columns
$g->cols
$g->columns( $num )

Returns the current number of columns.

All transform methods return the Grid::Transform object, so transforms can be chained.

$g->rotate_90
$g->rotate90

Rotates the grid 90 degrees clock-wise.

a b c d e f g h i j k l a b c d i e a
| e f g h -> j f b
i e a j f b k g c l h d i j k l k g c
l h d

$g->rotate_180
$g->rotate180

Rotates the grid 180 degrees clock-wise.

a b c d e f g h i j k l a b c d l k j i
| e f g h -> h g f e
l k j i h g f e d c b a i j k l d c b a

$g->rotate_270
$g->rotate270

Rotates the grid 270 degrees clock-wise.

a b c d e f g h i j k l a b c d d h l
| e f g h -> c g k
d h l c g k b f j a e i i j k l b f j
a e i

$g->flip_horizontal
$g->mirror_horizontal

Flips the grid across the horizontal axis.

a b c d e f g h i j k l a b c d i j k l
| e f g h -> e f g h
i j k l e f g h a b c d i j k l a b c d

$g->flip_vertical
$g->mirror_vertical

Flips the grid across the vertical axis.

a b c d e f g h i j k l a b c d d c b a
| e f g h -> h g f e
d c b a h g f e l k j i i j k l l k j i

$g->transpose

Flips the grid across the vertical axis and then rotates it 90 degress clock-wise.

a b c d e f g h i j k l a b c d l h d
| e f g h -> k g c
l h d k g c j f b i e a i j k l j f b
i e a

$g->counter_transpose
$g->countertranspose

Flips the grid across the horizontal axis and then rotates it 90 degrees clock-wise.

a b c d e f g h i j k l a b c d a e i
| e f g h -> b f j
a e i b f j c g k d h l i j k l c g k
d h l

$g->fold_right

Folds the columns to the right.

a b c d e f g h i j k l a b c d b c d a
| e f g h -> f g e h
b c a d f g e h j k i l i j k l j k i l

$g->fold_left

Folds the columns to the left.

a b c d e f g h i j k l a b c d d a c b
| e f g h -> h e g f
d a c b h e g f l i k j i j k l l i k j

dtRdr::Logger is a Perl module for global logging.

SYNOPSIS

use dtRdr::Logger;
L->debug($message, ...);
L->info($message, ...);
L->warn($message, ...);
L->error($message, ...);
L->fatal($message, ...);

For a stacktrace:

sub bar {
L()->logcluck("foo");
}

See Log::Log4perl for more info.

ABOUT

This (currently) installs a $SIG{__WARN__}, though well probably try to move away from that.

import

dtRdr::Logger->import(@args);

Get Logger

L

A shortcut to return a logger object FOR YOUR NAMESPACE with an optional list of subtags.

L($subtag);

Example:

package My::Package;
my $logger = L;
my $logger = L(#foo);

Now $logger will log into the class log4perl.logger.My.Package.#foo.

$subtag MUST start with a #. If this is omitted, it will be changed.

RL

A shortcut to a root-level logger.

RL($tag);

my $logger = RL(#foo);

Now $logger which will log into the class log4perl.logger.#foo.

$tag MUST start with a #. If this is omitted, it will be changed.

editor

Launches $ENV{THOUT_EDITOR} with a tempfile containing $string.

Just a handy way to get some debugging data into an editor.

dtRdr::Logger->editor($string);

Or, to do lazy evaluation only when needed, pass a sub that returns a string.

dtRdr::Logger->editor(sub {do_stuff_that_takes_time()});

DBG_DUMP

Similar to editor, but writes to a tempfile in "/tmp/$filename".

DBG_DUMP($ENV_NAME, $filename, sub {$content});

Only acts if $ENV{"DBG_$ENV_NAME"} is set.

DBG_FOO=1 ./Build test

...will cause this

DBG_DUMP(foo, thisfile.txt, sub {$blah});

...to write the content of $blah to /tmp/thisfile.txt.

The sub {$thing} thing is a speed hack, but that variable is big enough to make you want to open it in an editor, so...

init

dtRdr::Logger->init(filename => "foo");