Free intermediate software for linux

RAVE 1.9.9 is yet another excellent utility for everyone. RAVE stands for Retrospective Analysis and Visualization Engine which is a framework for generating complex analysis products.

RAVE caches the intermediate results of analytic tasks for later use in the same or different analyses. This improves performance by reducing duplicated effort when generating analytic results. RAVE users need to do nothing special in order to take advantage of this performance improvement.

The RAVE project provides tools to use RAVE interactively in a terminal, or to publish "live" RAVE analyses online as a network service for use in network-enabled applications.

Requirements:

• Python 2.4 or higher

strongSwan is an OpenSource IPsec implementation for the Linux operating system. strongSwan is an OpenSource IPsec implementation for the Linux operating system.
In order to have a stable IPsec platform to base our future extensions of the X.509 capability on, we decided to lauch the strongSwan project.
Main features:
- runs both on Linux 2.4 (KLIPS) and Linux 2.6 (native IPsec) kernels
- strong 3DES, AES, Serpent, Twofish, or Blowfish encryption
- Authentication based on X.509 certificates or preshared keys
- Powerful IPsec policies based on wildcards or intermediate CAs
- Retrieval and local caching of Certificate Revocation Lists via HTTP or LDAP
- Full support of the Online Certificate Status Protocol (OCSP, RCF 2560).
- Optional storage of RSA private keys on smartcards or USB crypto tokens
- Smartcard access via standardized PKCS #11 interface
- PKCS #11 proxy function offering RSA decryption services via whack
- NAT-Traversal (RFC 3947) and support of Virtual IPs and IKE Mode Config
- CA management (OCSP and CRL URIs, default LDAP server)
- Dead Peer Detection (DPD, RFC 3706)
- Group policies based on X.509 attribute certificates ( RFC 3281)
- Generation of default self-signed certificates during strongSwan setup
Enhancements:
- Source routes installed by the keying daemons are now in a separate routing table with ID 100 in order to avoid conflicts with the main table.
- Route lookup for IKEv2 traffic is done in userspace to ignore routes installed for IPsec, as IKE traffic shouldnt get encapsulated.
- The ipsec starter has become more tolerant to dynamic DNS lookup failures by keeping the last valid IP address.

AxKit2::Transformer::XSP Perl module contains eXtensible Server Pages.

SYNOPSIS

< xsp:page
xmlns:xsp="http://apache.org/xsp/core/v1" >

< xsp:structure >
< xsp:import >Time::Piece< /xsp:import >
< /xsp:structure >

< page >
< title >XSP Test< /title >
< para >
Hello World!
< /para >
< para >
Good
< xsp:logic >
if (localtime->hour >= 12) {
< xsp:content >Afternoon< /xsp:content >
}
else {
< xsp:content >Morning< /xsp:content >
}
< /xsp:logic >
< /para >
< /page >

< /xsp:page >

XSP implements a tag-based dynamic language that allows you to develop your own tags, examples include sendmail and sql taglibs. It is AxKits way of providing an environment for dynamic pages. XSP is originally part of the Apache Cocoon project, and so you will see some Apache namespaces used in XSP.

Also, use only one XSP processor in a pipeline. XSP is powerful enough that you should only need one stage, and this implementation allows only one stage. If you have two XSP processors, perhaps in a pipeline that looks like:

... => XSP => XSLT => XSLT => XSP => ...

it is pretty likely that the functionality of the intermediate XSLT stages can be factored in to either upstream or downstream XSLT:

... => XSLT => XSP => XSLT => ...

This design is likely to lead to a clearer and more maintainable implementation, if only because generating code, especially embedded Perl code, in one XSP processor and consuming it in another is often confusing and even more often a symptom of misdesign.

Likewise, you may want to lean towards using Perl taglib modules instead of upstream XSLT "LogicSheets". Upstream XSLT LogicSheets work fine, mind you, but using Perl taglib modules results in a simpler pipeline, simpler configuration (just load the taglib modules in httpd.conf, no need to have the correct LogicSheet XSLT page included whereever you need that taglib), a more flexible coding environment, the ability to pretest your taglibs before installing them on a server, and better isolation of interface (the taglib API) and implementation (the Perl module behind it). LogicSheets work, and can be useful, but are often the long way home. That said, people used to the Cocoon environment may prefer them.

Result Code

You can specify the result code of the request in two ways. Both actions go inside a < xsp:logic > tag.

If you want to completely abort the current request, throw an exception:

throw Apache::AxKit::Exception::Retval(return_code => FORBIDDEN);

If you want to send your page but have a custom result code, return it:

return FORBIDDEN;

In that case, only the part of the document that was processed so far gets sent/processed further.

Debugging

If you have PerlTidy installed (get it from http://perltidy.sourceforge.net), the compiled XSP scripts can be formatted nicely to spot errors easier. Enable AxDebugTidy for this, but be warned that reformatting is quite slow, it can take 20 seconds or more on each XSP run for large scripts.

If you enable AxTraceIntermediate, your script will be dumped alongside the other intermediate files, with an extension of ".XSP". These are unnumbered, thus only get one dump per request. If you have more than one XSP run in a single request, the last one will overwrite the dumps of earlier runs.

Gladius DB is a fast and efficient PHP flatfile database engine written in pure PHP; its SQL syntax is compatible with a subset of intermediate SQL92.
You will not need any specific extension to have it work, and it is bundled with an adoDB lite driver.
This project is licensed under the GNU General Public License, be sure to have read and understood it before using Gladius in your own software.
SQL Conformance
The formal name of the SQL standard is ISO/IEC 9075 "Database Language SQL". The version this document refers to is ISO/IEC 9075:2003, or simply SQL:2003. The versions prior to that were SQL:1999 and SQL-92. Each version supersedes the previous one, so claims of conformance to earlier versions have no official standing.
Starting with SQL:1999, the SQL standard defines a large set of individual features rather than the three levels (Entry, Intermediate and Full) declared in SQL-92. A large subset of these features represents the "Core" (mandatory) features, SQL implementation must supply in order to claim conformance. The rest of the features are purely optional.
In the following sections, we provide a list of all SQL:2003 features with an indication of whether it is supported by Gladius DB; every feature consists of an unique identifier and a name. Feature identifiers containing a hyphen are subfeatures. If a particular subfeature is not supported, the main feature is listed as partly supported. Comments are provided where necessary.
Version restrictions:
- performance slowdown with a huge number of records
- no storage gain for binary fields (for example, numbers)
- non-validating SQL parser (an SQL query that works with Gladius may not be syntactically correct)
- all strings are considered binary and should always be Unicode safe
- no specific collation or character set support
- cannot SELECT calculated or immediate values
- CHAR VARYING, DOUBLE PRECISION and INTERVAL data types (specified in the SQL92 standard) are not recognized
- no specific date/time functions (as of Gladius DB v0.6.2)

Tie::Proxy::Hash is a Perl module created to efficiently merge & translate hashes.

SYNOPSIS

my (%hash, $ref);
$ref = tie %hash, Tie::Proxy::Hash, (bart => +{a => 1,
b => 2},
maggie => +{a => 5,
c => 6,
e => 10},
);
$hash{a} == 1; # true
$hash{b} == 2; # true (bart supercedes maggie)
$hash{c} == 6; # true
! defined $hash{d}; # true
$hash{e} == 10; # true

$hash{c} = 9; # set in maggie
$hash{d} = 12; # set in default
$hash{f} = 11; # set in default

$ref->add_hash(lisa, +{d => 3, b => 4});
$hash{c} == 9; # true
$hash{b} == 2; # true (bart overrides lisa)
$hash{d} == 3; # true (lisa overrides default)
$hash{f} == 11; # true (only default knows f)

Proxy hash requests for one or more other hashes, with intermediate value translation.

Tie::Proxy::Hash merges hashes by maintaining a list of hashes to look up, and each key requested is looked up in each hash in order until a hit is found. Resultant values may be subject to a translating subr. In this way, hashes may be merged without the cost of by-value copying.

A default backing hash is provided to store values not present in other hashes.

Tying

$ref = tie %hash, Tie::Proxy::Hash,
bart => +{a => 1, b => 2},
maggie => +{a => 5, c => 6, e => 10} => sub {10*$_[0]},
;

Any arguments passed to tie are palmed off onto add_hash.

Retrieving Values

Values are retrieved by checking each hash in the order of insertion; the first hash found in which a given key exists supplies the value. The value is subject to translation if the given hash has an associated translator.

Courier mail transfer agent (MTA) is an integrated mail/groupware server based on open commodity protocols, such as ESMTP, IMAP, POP3, LDAP, SSL, and HTTP. Courier provides ESMTP, IMAP, POP3, webmail, and mailing list services within a single, consistent, framework.
Individual components can be enabled or disabled at will. Courier now implements basic web-based calendaring and scheduling services integrated in the webmail module. Advanced groupware calendaring services will follow soon.
Couriers source code should compile on most POSIX-based operating systems based on Linux, and BSD-derived kernels. Courier should also compile on Solaris and AIX, with some help from Suns or IBMs freeware add-on tools for their respective operating systems.
Courier evolved out of several related projects, that merged together (more on that later). Courier implements SMTP extensions for mailing list management and spam filtering. Courier can function as an intermediate mail relay, relaying mail between an internal LAN and the Internet, or perform final delivery to mailboxes.
Courier uses maildirs as its native mail storage format, but it can also deliver mail to legacy mailbox files as well. Couriers configuration is set by plain text files and Perl scripts. Most of Couriers configuration can now be adjusted from a web browser, using Couriers web-based administration module.
Courier can provide mail services for regular operating system accounts. Courier can also provide mail services for virtual mail accounts, managed by an LDAP, MySQL, or PostgreSQL-based authentication database.
Enhancements:
- This release introduces a Web-based interface to couriermlm, implementing complete, browser-based mailing list administration functionality.

This tutorial assumes no previous knowledge of scripting or programming, but progresses rapidly toward an intermediate/advanced level of instruction . . . all the while sneaking in little snippets of UNIX wisdom and lore.
Advanced Bash Scripting Guide serves as a textbook, a manual for self-study, and a reference and source of knowledge on shell scripting techniques.
The exercises and heavily-commented examples invite active reader participation, under the premise that the only way to really learn scripting is to write scripts.
Enhancements:
- This release adds a cross-linked index (the final missing critical feature in this project), other new material (including a new appendix and a couple of new example scripts), and bugfixes.
- This is an important update.