Free conforming to software for linux

Config::File is a Perl module to parse a simple configuration file.

SYNOPSIS

use Config::File;
my $config_hash = Config::File::read_config_file($configuration_file);

read_config_file parses a simple configuration file and stores its values in an anonymous hash reference. The syntax of the configuration file is quite simple:

# This is a comment
VALUE_ONE = foo
VALUE_TWO = $VALUE_ONE/bar
VALUE_THREE = The value contains a # (hash). # This is a comment.

Options can be clustered when creating groups:

CLUSTER_ONE[data] = data cluster one
CLUSTER_ONE[value] = value cluster one
CLUSTER_TWO[data] = data cluster two
CLUSTER_TWO[value] = value cluster two

Then values can be fetched using this syntax:

$hash_config->{CLUSTER_ONE}{data};

There can be as many sub-options in a cluster as needed.

BIG_CLUSTER[part1][part2][part3] = data

is fetched by: $hash_config->{BIG_CLUSTER}{part1}{part2}{part3};
There are a couple of restrictions as for the names of the keys. First of all, all the characters should be alphabetic, numeric, underscores or hyphens, with square brackets allowed for the clustering. That is, the keys should conform to /^[A-Za-z0-9_-]+$/

This means also that no space is allowed in the key part of the line.

CLUSTER_ONE[data] = data cluster one # Right
CLUSTER_ONE[ data ] = data cluster one # Wrong

eformmail project is a stand-alone CGI program that accepts an HTML form and emails it. The target email address is not buried in the HTML form, making it impossible for spammers to take advantage of this email address.
The output can be formatted by an XSLT processor, and form fields can be validated against a regular expression. A comprehensive manual is available.
Main features:
- Mail the contents of a form to an email address.
- The email address does not have to be present on the form, so it can not be used by email address harvesters in order to spam it.
- The contents of the email body that will be sent is completely configurable. eformmail can pipe the form data through an XSLT processor, so any formatting is possible.
- Supports both application/x-www-form-urlencoded and multipart/form-data encodings.
- It is possible to specify which fields must be validated. The contents should conform to the specified regular expression, else the email will not be sent.
- Single binary program. No PHP, Perl or other libraries needed.
- eformmail.cgi is protected against harvesting of web pages that might use it, in order to exploit it by sending spam through that web page.
Enhancements:
- A spam trap facility has been added, so form submissions that are obviously spam can be dismissed immediately.

BindConfig is a tool to reduce the error prone work of maintaining BINDs zone files. More precisely, BindConfig is the name of a Python module which can read BINDs zone files and named.conf files, and can modify and save BINDs zone files.

The zone files written by the module will be as concise as possible, since you as an admin are more likely to spot errors in a file which only has the information necessary. The zone files are written to conform to BINDs expectations and with BINDs style guide. There will be an ORIGIN directive and a TTL directive at the top of the zone. All hostnames will be relative to the toplevel ORIGIN, except for absolute hostnames outside of the zone.

BindConfig comes with an interactive shell for editing your zone files.

Invoke the shell with the name of the zone you want to edit. It will parse your systems named.conf file for the location of the zone, and parse that file in turn. When the shell exits, it will save the zone file.

edit-zone dragonsdawn.net
edit-zone:
Copyright 2001 Gordon Messmer
This is free software with ABSOLUTELY NO WARRANTY.
For details type warranty.
Parsing file: /etc/named.conf
Done
Parsing zone: dragonsdawn.net
Done
>

If all goes well, (no missing files), youll be in the edit-zone shell. Type help for a list of available commands. You can print the zone, list records using wildcards, delete records using wildcards, add records or read commands from a file. You can also pipe commands to the shell:

cat zone-commands | edit-zone dragonsdawn.net
echo add CNAME for www bind-config | edit-zone dragonsdawn.net

edictionary is a nifty little application which you can use as your dictionary. It will fit quite well into your command line intensive job and its faster than your browser too!
edictionary can be used to view the meaning of English words. It can also provide related details like etymology, function, pronunciation etc. Adding support for other languages is not included, but is easy.
It can grab the meaning of any word from the convenience of the command line. You can ask for meanings of multiple words at once. You can call edictionary from within your scripts.
edictionary is as platform independent as Perl, because, you guessed it, it is written in Perl. Thus, all you need is Perl installed on your machine, and of course, edictionary. FYI, Perl is a platform independent language.
Interpreters are available for Linux, UNIX, Windows and many other platforms, easily. If you are running Linux or UNIX, chances are that you already have Perl installed on your machine.
Enhancements:
- Fix the MW response parser to conform to the new html output.

Noid is a Perl module that contains routines to mint and manage nice opaque identifiers.

SYNOPSIS

use Noid; # import routines into a Perl script

$dbreport = Noid::dbcreate( # create minter database & printable
$dbdir, $contact, # report on its properties; $contact
$template, $term, # is string identifying the operator
$naan, $naa, # (authentication information); the
$subnaa ); # report is printable

$noid = Noid::dbopen( $dbname, $flags ); # open a minter, optionally
$flags = 0 | DB_RDONLY; # in read only mode

Noid::mint( $noid, $contact, $pepper ); # generate an identifier

Noid::dbclose( $noid ); # close minter when done

Noid::checkchar( $id ); # if id ends in +, replace with new check
# char and return full id, else return id
# if current check char valid, else return
# undef

Noid::validate( $noid, # check that ids conform to template ("-"
$template, # means use minters template); returns
@ids ); # array of corresponding strings, errors
# beginning with "iderr:"

$n = Noid::bind( $noid, $contact, # bind data to identifier; set
$validate, $how, # $validate to 0 if id. doesnt
$id, $elem, $value ); # need to conform to a template

Noid::note( $noid, $contact, $key, $value ); # add an internal note

Noid::fetch( $noid, $verbose, # fetch bound data; set $verbose
$id, @elems ); # to 1 to return labels

print Noid::dbinfo( $noid, # get minter information; level
$level ); # brief (default), full, or dump
Noid::getnoid( $noid, $varname ); # get arbitrary named internal
# variable

Noid::hold( $noid, $contact, # place or release hold; return
$on_off, @ids ); # 1 on success, 0 on error
Noid::hold_set( $noid, $id );
Noid::hold_release( $noid, $id );

Noid::parse_template( $template, # read template for errors, returning
$prefix, $mask, # namespace size (NOLIMIT=unbounded)
$gen_type, # or 0 on error; $message, $gen_type,
$message ); # $prefix, & $mask are output params

Noid::queue( $noid, $contact, # return strings for queue attempts
$when, @ids ); # (failures start "error:")

Noid::n2xdig( $num, $mask ); # show identifier matching ord. $num

Noid::sample( $noid, $num ); # show random ident. less than $num

Noid::scope( $noid ); # show range of ids inside the minter

print Noid::errmsg( $noid, $reset ); # print message from failed call
$reset = undef | 1; # use 1 to clear error message buffer

Noid::addmsg( $noid, $message ); # add message to error message buffer

Noid::logmsg( $noid, $message ); # write message to minter log

IFF Format Library provides header structures and utility functions for reading and writing data files in the Interchange Files.
The Interchange File Format is a simple structured binary file format consisting of sized and typed chunks of data, selectively readable without having to know the format of each chunk.
This functionality is similar to what XML provides for text documents, and the IFF format can indeed be viewed as a sort of a binary XML. IFFs extensibility is an excellent way of not breaking old applications when the file format changes, making it an excellent choice for your next applications data files.
The IFF is also the simplest and the smallest such data format, ensuring that your files consist of real data rather than overhead and that your code spends more time on real work than on parsing the data file. This library defines the IFF header structures and provides simple algorithms for directly writing many of your objects as chunks and containers.
Installation:
This library can be downloaded from SourceForge, as can its sole prerequisite:
libiff - The library source package.
uSTL - An STL implementation, required.
First, unpack and install uSTL, as described in its documentation. Unpack libiff and run ./configure; make install, which will install the library to /usr/local/lib and headers to /usr/local/include. ./configure --help lists available configuration options, in the usual autoconf fashion. The one thing to be aware of is that by default the library will not be completely conforming to EA85 specification. Why that is so, and why you should take the default options anyway, is discussed in detail in the next section. If you really want to use the original EA85 format, you can to pass --with-bigendian --with-2grain to configure.
Usage:
If you are using C++, chances are you already have an object-oriented design of some kind. You have a collection of objects, related to each other in some way, and you want to write them all to a file in some way. It is, of course, possible to just write them all to the file, one after the other, but that approach makes things difficult if you ever decide to change the structure of those objects, write more or fewer of them, or explain to other people how to read your format. Hence, it is desirable to create some kind of structure in the file, to be able to determine where each objects begins and ends, and what kind of object is where. When using an IFF format, youll make simple objects into chunks, and objects containing other objects into FORMs, LISTs, or CATs.
The first task is to make each of your objects readable and writable through uSTL streams. To do that youll need to define three methods, read, write, and stream_size, and create flow operator overrides with a STD_STREAMABLE macro. Here is a typical example:
#include < iff.h > // iff header includes ustl.h, but doesnt use the namespace.
using namespace ustl; // it is recommended to leave iff:: namespace on.
/// Stores players vital statistics.
class CPlayerStats {
public:
void read (istream& is);
void write (ostream& os) const;
size_t stream_size (void) const;
private:
uint16_t m_HP;
uint16_t m_MaxHP;
uint16_t m_Mana;
uint16_t m_MaxMana;
};
// Since the object is simple, and contains no other objects,
// well make it a simple chunk.
enum { // Define a chunk format for writing this object.
fmt_PlayerStats = IFF_FMT(S,T,A,T)
}; // In a hex editor youll see STAT at the beginning of the object
// making it easy to find when you want to hack something in it.
/// Reads the object from stream p is
void CPlayerStats::read (istream& is)
{
is >> m_HP >> m_MaxHP >> m_Mana >> m_MaxMana;
}
/// Writes the object to stream p os.
void CPlayerStats::write (ostream& os) const
{
os<<less