Free layer 2 software for linux

SYNOPSIS

#####
# Subroutines
#
use Tie::Layers qw(is_handle config);

$yes = is_handle( $file_handle );

($key, $old_value) = config(%options, $key);
($key, $old_value) = config(%options, $key => $new_value );

####
# Config default startup options
#
@old_options_list = config(%options, @option_list);
@old_options_list = config(%options, @option_list);
@old_options_list = config(%options, %option_list);

#####
# Class interface
#
require Tie::Layers;

#####
# Using support methods and file handle with
# the file subroutines such as open(), readline()
# print(), close()
#
tie *LAYERS_FILEHANDLE, Tie::Layers, @options
$layers = tied *LAYERS_FILEHANDLE;


#####
# Using support methods only, no file subroutines
#
$layers = Tie::Layers->TIEHANDLE(@options);

($key, $old_value) = $layers->config($key);
($key, $old_value) = $layers->config($key => $new_value );

@old_options_list = $layers->config(@option_list);
@old_options_list = $layers->config(@option_list);
@old_options_list = $layers->config(%option_list);

$data = $layers->fin($filename, @options);

$data = $layers->fout($filename, $data, @options);

$yes = $layers->is_handle( $file_handle );

If a subroutine or method will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}.

The Tie::Layers program module contains the tie file handle Tie::Layers package. The Tie::Layers package provides the ability to insert a stack of subroutines between file subroutines print and realine and the underlying $file. The syntax of the subroutines of each layer of the readline stack and the print stack must comply to the the requirements described herein below.

This is necessary so that the Tie::Layers READLINE and PRINT subroutines know how to transfer the output from one layer to the input of another layer. The stacks are setup by supplying options with a reference to the subroutine for each layer in the print stack and the readline stack. The Tie::Layers are line orientated and do not support any character file subrouintes.

The getc, read, and write file subroutines are supported by the Tie::Layers package. The seek routines are line oriented in that the seek and tell subroutine positions are the line in the underlying file and not the character position in the file.

layer7-firewall provides an easily configured layer seven firewall.
layer7-firewall is an easily configured layer seven firewall. It boots from a CD, using a floppy disk for data storage.
Layer7-firewall is a firewall which filters data in layer7 OSI model and has implemented QoS.
Netfilter identifies packets as eDonkey2000, Bittorent, Quake, etc. Many thanks to Justin Levandoski, Ethan Sommer and Matthew Strait for their work in L7-filter. After unpacking bz2 file You get iso image to burn on cd.
Dont forget to connect Your CD as hdb (Primary Slave).
Enhancements:
- added "iptables -I FORWARD -p udp... -j MASQUERADE",
- added "iptables -I FORWARD -p icmp... -j MASQUERADE",
- added "iptables -I INPUT -p udp... -j MASQUERADE",
- added "iptables -I INPUT -p icmp... -j MASQUERADE",
- queues on interfaces have algorithm cbq now (before htb).

GuiLoader/C++ is a C++ binding to GuiLoader library.

GuiLoader/C++ is a convenience layer that simplifies development of GuiLoader based applications written in C++ language by introducing exception safety, binding GTK+ objects defined in GuiXml to C++ variables and type-safe dynamic connection to signals.

Libgenerics is a c++ library that provides object services to analyze class type at runtime sharing the definitions between dynamic modules.
It provides serialization services abstraction too. The project is an absolute generic library.
Enhancements:
- autotool layer added

LiteSQL is a C++ library that integrates C++ objects tightly to relational database and thus provides an object persistence layer.
LiteSQL supports SQLite3, PostgreSQL and MySQL as backends. LiteSQL creates tables, indexes and sequences to database and upgrades schema when needed.
LiteSQL provides object relations, in addition to object persistence which can be used to model any kind of C++ data structures. Objects can be selected, filtered and ordered using template- and class-based API with type checking at compile time.
Main features:
- SQLite3, PostgreSQL and MySQL - backend support
- object persistence layer with relation support
- automatic database schema creation and upgrading
- create complex SQL queries using compile time checked class API; minimizes need to write SQL query strings

Tkinter is Pythons de-facto standard GUI (Graphical User Interface) package. It is a thin object-oriented layer on top of Tcl/Tk.

Tkinter is not the only GuiProgramming toolkit for Python. It is however the most commonly used one, and almost the only one that is portable between Unix, Mac and Windows.

CameronLaird calls the yearly decision to keep TkInter "one of the minor traditions of the Python world."

TwoLAME is an optimised MPEG Audio Layer 2 (MP2) encoder based on tooLAME by Mike Cheng, which in turn is based upon the ISO dist10 code and portions of LAME.
TwoLAME includes libtwolame, a fully thread-safe shared library with an API very similar to LAMEs.
Main features:
- Fully thread-safe
- Static and shared library (libtwolame)
- API very similar to LAMEs (for easy porting)
- Frontend supports wider range of input files (using libsndfile)
- automake/libtool/pkgconfig based build system
Enhancements:
- This release adds win32/winutil.h to the tarball, fixes bug #1629945, fixes presentation of --enable-debug in the configure script, adds twolame_encode_buffer_float32_interleaved(), fixes a bug that was losing stereo in twolame_encode_buffer_float32(), fixes twolame_set_mode() to accept TWOLAME_AUTO_MODE, adds source file IDs to the top of every file, and adds -pedantic to CFLAGS for the debug build.