Free definitions software for linux

Layer-7 Packet Classifier for Linux is a packet classifier for Netfilter that identifies packets based on application layer (OSI layer 7) data. This means that it is able to classify packets as HTTP, FTP, Gnucleus, Kazaa, etc., regardless of ports.
It complements existing matches that classify based on port numbers, packet length, TOS bits, and so on. Combined with Linux QoS, it allows for full layer 7 packet shaping.
Main features:
- Patches for Linux 2.4 and 2.6
- Support for TCP, UDP and ICMP over IPv4
- Uses Netfilters connection tracking of FTP, IRC, etc
- Examines data across multiple packets
- Number of packets examined tunable on the fly through /proc
- Number of bytes examined tunable at module load time
- Distinguishes between new connections (those still being tested) and old unidentified connections
- Gives access to both Netfilter and QoS (rate limiting) features
- With the Netfilter "helper" match, you can distinguish between parent and child connections (e.g. ftp command/data)

Devel::DebugInit is a Perl extension for creating a debugger initialization files from C header file macros.

SYNOPSIS

use Devel::DebugInit::GDB;
my $gdb = new Devel::DebugInit::GDB filenames => ["/my/path/to/library.h"];
$gdb->write("/my/path/to/library/.gdbinit");

Devel::DebugInit is aimed at C/C++ developers who want access to C macro definitions from within a debugger. It provides a simple and automated way of creating debugger initialization files for a specific project. The initialization files created contain user-defined functions built from the macro definitions in the projects header files.

By calling new(), the files specified by the filenames parameter are parsed by the C preprocessor, and all macros #defined in the file (and if desired, all macros #defined by all #included files as well), will be parsed and expanded. By then calling the write() method, these macros can be written to an output file in the format of user-defined functions specific for your debugger.

By automating the process, a new file can be created whenever the code of a project changes, and that way there will not be antiquated copies lying around to trap the unwary.

NOTES

This module requires the use of one of the debugger-specific backend modules, such as Devel::DebugInit::GDB which is supplied with DebugInit. The backends supply the output routines which are specific for that debugger.
This module also requires both the C::Scan and Data::Flow modules and will not function without them.

Curses::Application provides the Curses Application Framework.

Curses::Application attempts to relieve the programmer of having to deal directly with Curses at all. Based upon Curses::Widgets and Curses::Forms, all one should have to do is define the application forms and contents in the DATA block of a script. Curses::Application will take care of the rest.

This module follows many of the conventions established by the Curses::Widgets and Curses::Forms modules, being built upon that framework. One area of special note, however, is the declaration of forms used within the application.

Curses::Application differentiates between forms and form definitions. A form is an instance of any particular form definition. Keeping that line of separation simplifies the development of MDI (Multiple Document Interface) applications.
Form definitions can be provided in two ways: as a list of definitions in the main::DATA block, or individually by using the addFormDef method. The former would normally be the simplest way to do so.

At the end of your script, declare a DATA block using Perls __DATA__ token. In that DATA block place a hash declaration (%forms) which contains a key/value pair for each form definition. The key being the name of the definition, and the value being a hash reference to the form declarations (see the Curses::Forms pod for directives available to that module). The only extra key that should be in each forms hash reference should be a TYPE directive, which would point to a module name relative to the base Curses::Forms class. If you omit this key, then it will be assumed that the form is a Curses::Forms object, or some custom derivative as specified in ALTPATH.

UJAC provides a collection of JAVA components which may be useful in some projects.
Each component is designed for easy use, easy integration into existing projects, extensibility and last but not least efficiency.
Enhancements:
Chart Module:
- Moved common types into the interface org.ujac.util.UjacTypes.
Form Module:
- Fixed handling of default values.
Print Module:
- At < insert-document > tag: Fixed offset handling.
- At tags < background-image > & < watermark >: Removed code that forces the existance of a page for the background image.
Utils Module:
- Added interface UjacTypes, which defines common types, used inside the UJAC project.
- Added class UjacTypeHelper, which provides methods to convert data type IDs to Strings and vice versa.
- Moved class XmlUtils into sub package org.ujac.util.xml
SimplePatternMatcher:
- Fixed handling of empty patterns (always matches).
Table:
- Moved common types into the interface org.ujac.util.UjacTypes.
TemplateInterpreter:
- Fixed handling of underscores that are not part of statements.
- Added class BaseObjectSerializer, which provides basic code to easily read/write Objects from/to XML.
Web Module:
- Added support for PageTiles to ActionContext.
- Added < tile > tag which includes PageTiles into JSPs.
- Added class WebFormSerializer, which reads/writes WebForm definitions from/to XML.
- Added support for dynamic form registration from XML definitions.
- Fixed bugs in form field value handling.
- Fixed bugs in form field rendering.

Mac::Apps::Seasonality::Constants is a Perl module for static definitions of aspects of Seasonality.

SYNOPSIS

use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_NAME
$SEASONALITY_CREATOR
$SEASONALITY_HISTORY_DATABASE_PATH
};


use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_HISTORY_TABLE
$SEASONALITY_HISTORY_COLUMN_ICAO
$SEASONALITY_HISTORY_COLUMN_TEMPERATURE_C
};


use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_DB_STATUS_TABLE
$SEASONALITY_DB_STATUS_COLUMN_NEW_RECORDS_SINCE_VACUUM
};


use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_HISTORY_COLUMNS_REF
$SEASONALITY_HISTORY_COLUMN_NUMBERS_BY_COLUMN_NAME_REF
$SEASONALITY_HISTORY_COLUMN_NAMES_BY_COLUMN_NUMBER_REF
};

use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_INVALID_DATA
$SEASONALITY_TEMPERATURE_MINIMUM
$SEASONALITY_TEMPERATURE_MAXIMUM
};


use Mac::Apps::Seasonality::Constants qw{ :all };
use Mac::Apps::Seasonality::Constants qw{ :application };
use Mac::Apps::Seasonality::Constants qw{ :database };
use Mac::Apps::Seasonality::Constants qw{ :data };
use Mac::Apps::Seasonality::Constants qw{ :growl };

This provides static metadata about Seasonality via "constants". The exposed values are made immutable via Readonly and not constant, so they are usable within string interpolation, etc.

None of the values are exported by default to avoid the possibility of name clashes, though the names should be unique enough for most uses. Each value must individually be imported or with one of the following tags:

:all

All constants.

:application

The application name and creator code. The name of and default path to the weather history database.

:database

The database table and column names.

:data

The missing data indicator value and the limits on each type of data.

:growl

The values to be used in talking to Growl.

NACE is a generic query engine used to automatically create host and service definitions for hosts on the network.

It is intended to be used in a shell script at regular intervals by an experienced Nagios administrator to perform a query against the supplied host list. It then creates host and service definitions using the parameters supplied in the query.

Q-Audio is a digital audio interface for Q. Q-Audio project contains three modules which together provide the basic functionality needed to write digital audio applications.
The audio module implements a (nearly) real-time audio interface on top of the PortAudio library. The sndfile module allows you to access sound files in various formats using libsndfile.
The wave module provides basic operations for creating and manipulating wave data, including operations to convert sample rates, to calculate Fourier transforms, and to display wave data in a GGI visual.
About Q language:
Q is a functional programming language based on term rewriting. Thus, a Q program or "script" is simply a collection of equations which are used to evaluate expressions in a symbolic fashion. The equations establish algebraic identities and are interpreted as rewriting rules in order to reduce expressions to "normal forms". For instance, here is how you define a function sqr which squares its argument by multiplying it with itself:
sqr X = X*X;
Note that, as in Prolog, capitalized identifiers are used to indicate the variables in an equation, which are bound to the actual values when an equation is applied. Equations may also include a condition part, as in the following definition of the factorial function:
fact N = N*fact (N-1) if N>0;
= 1 otherwise;
Functions on structured arguments are defined by "pattern matching". E.g., the product of a list (denoted in Prolog-like syntax) can be computed with these two equations:
prod [] = 1;
prod [X|Xs] = X*prod Xs;
With this definition, the factorial can now also be defined as follows (the notation [1..N], as in Haskell, denotes an arithmetic sequence):
fact N = prod [1..N];
As you can see, the definitions are really just like mathematical equations. The syntax is superficially similar to other modern functional languages like Miranda and Haskell, except that Q is "free-format", i.e., it does not use layout to indicate syntactical structure (thus the semicolon is used to terminate an equation).
Due to its term rewriting heritage, Q goes well beyond most other functional languages in that it also allows you to perform computations with symbolic expressions. For instance, with the definition of the sqr function from above, you will find that sqr (X+1) evaluates to (X+1)*(X+1). This might first look like an arcane feature, but it is actually quite useful, because you can try your definitions with symbolic inputs, too.
Enhancements:
- src/wave.c: minor fixes for compatibility with latest gcc versions