Free tc config 0.6.2 software for linux

Snort Config provides an intuitive menu-based interface for the GPL IDS tool Snort.
SnortConf is a tool that provides a fairly intuitive menu-based text interface for setting up the GPL IDS tool Snort. It also provides error and sanity checking on user input, and an online help facility.
Currently, Ive just released a Snortconf version to match up to Snort version 1.9.0. I apologize for the late release date; this project is a unique one for me, in that I dont use this program myself (I like the text editor method better personally), so I tend to forget about it if nobody pesters me, which nobody has. Speaking of which:
NOTE TO USERS: If you like this program, or hate this program, or anything else about this program (feature requests? bugs?), please provide me some feedback. My purpose in releasing this program in its current BETA state was to get feedback from people who use it, and to date I have gotten exactly 1 person willing to drop me an e-mail on the subject. The rest of you are encouraged to join in.
The program should compile on almost any POSIX system with a Curses library. It has only been tested on Linux/Ncurses however, so users of other platforms are encouraged to report any issues they encounter with either the build process, or any runtime errors.
Enhancements:
- yncd to changed on the debian boxen.
- rebuilt RPM and tar.gz on the RedHat boxen.
- Updated to output Snort 1.9.0 config files.
- Dang little else. :)

PXP::Config is a Perl module for PXP configuration.

SYNOPSIS

# do this only once at server initialization:
PXP::Config::init(file=>$finename);
# then from anywhere:
my $global_configuration_hash = PXP::Config::getGlobal();
# only from a plugin class:
my $plugin_configuration_hash = PXP::Config::get();

PXP::Config is a PXP component which provides a unified and simplified API for the PXP server and PXP plugins to read and store there configuration.

PXP::Config uses the XML::Simple module to access a centralized XML configuration file. This file (/opt/etc/imc.xml by default) contains root element named imc which has a global child for the PXP server configuration and a plugins child which has itself a child per plugin configuration (the child name must be the plugin name for this class to automatically retrieve a plugin configuration.

As plugins configurations are retrived by plugin name in a centralized location, the only thing a plugin has to do in order to get its configuration is to call the PXP::Config::get() method which returns a hash convertion of the plugin XML configuration.

Configuring plugins can be made in two manners:

1) the simple way - use it when you dont need to update the configuration from the application itself and when your plugin configuration has a very simple structure:
simply add a tag with the name of your plugin in the etc/imc.xml file, the plugin configuration can then be accessed as a has by calling the PXP::Config::get() method
2) the sophisticated way - use it in other cases:
create a new package in a file MyConfig/PLUGIN_NAME.pm under your plugin directory
in this file, define a package that inherits from PXP::MyConfig class and which overrode the config, loadFile and synchro methods (see plugins/LogViewer/MyConfig/LogViewer.pm for an example)

edit your plugin.xml and add your new package as an extension to the PXP::MyConfig extension point:

< extension
id="MyConfig::LogViewer"
name="Plugin configuration"
version="0.1"
point="IMC::MyConfig"/ >

< file value=/tmp/imc.xml/ >

< /extension >

You can ommit the file tag, configuration file will then default to the main configuration file (the one passed to the server with the -c switch or etc/imc.xml by default).

See the PXP::Config and PXP::MyConfig APIs for using configuration inside plugins.

pkg-config is a helper tool used when compiling applications and libraries. It helps you insert the correct compiler options on the command line so an application can use gcc -o test test.c `pkg-config --libs --cflags glib-2.0` for instance, rather than hard-coding values on where to find glib (or other libraries). It is language-agnostic, so it can be used for defining the location of documentation tools, for instance.
The program free software and licensed under the [WWW]GPL version 2 or any later version (at your option).
pkg-config works on multiple platforms: Linux and other UNIX-like operating systems, Mac OS X and Windows. It does not require anything but a reasonably well working C compiler and a C library, but can use an installed glib if that is present. (A copy of glib 1.2.8 is shipped together with pkg-config and this is sufficient for pkg-config to compile and work properly.)
The first implementation was written in shell, by James Henstridge. Later, it was rewritten in C by Havoc Pennington. It also grew an autoconf macro written by Tim Janik, later rewritten by Scott James Remnant.
Enhancements:
- Segfaults were fixed.
- Win32 fixes were made.
- The --short-errors option was added, and is now used by pkg.m4 if available.
- This gives a better error message if some libraries cant be found.

Rsync::Config is a Perl module for rsync configuration generator.

Rsync::Config is a module who can be used to create rsync configuration files. A configuration file (from Rsync::Config point of view) is made by atoms and modules with atoms. A atom is the smallest piece from the configuration file. This module inherits from Rsync::Config::Module .

INHERITANCE

Objects from Rsync::Config inherits as in the next scheme

/--- Rsync::Config::Module --- Rsync::Config

Rsync::Config::Renderer

--- Rsync::Config::Blank
/

Rsync::Config::Atom --- --- Rsync::Config::Comment

SYNOPSIS

use Rsync::Config;
use Rsync::Config::Atom;
use Rsync::Config::Module;

sub main {
my ($conf, $module);

$conf = new Rsync::Config();
$conf->add_comment(Main configuration file for our rsync daemon);
$conf->add_atom(read only,yes);
$conf->add_atom(chroot,yes);

$module = new Rsync::Config::Module(name => cpan);
$module->add_atom(path,/var/ftp/pub/mirrors/ftp.cpan.org/);
$module->add_atom(comment, CPAN mirror);

$conf->add_module($module);
$conf->to_file(/etc/rsyncd.conf);
}

Config Maker is a tool to automatically create C++ classes that parse configuration files.

Only a few lines of text that describe the possible entries in the configuration file are needed, and the complete class will be generated ready for use.

Basic usage

The input files for Config Maker have a very simple structure (in ANTLR/grep like notation):

objectname (configentry)+
Each configentry looks like this
type entryname defaultvalue (comment)?

type

Type of the entry, can be int, double, string or bool. If the basic type is followed by any number, the corresponding c++object variable will be of type vector < basic type > The number is the initial number of elements that are allocated for the vector, but the actual configuration file can contain more components. These are added using the push_back method.

If there are less elements specified in the configuration file, the object variable will still contain the number of elements specified here. No warning will be issued.
configentry

Name of the entry and corresponding variable. Has to be at least two characters long and can contain characters and numbers. Case insensitive.

defaultvalue

Default value for the entry. This is optional.

comment

Each comment starts with // and is completely ignored

Permit Cookies is a Firefox extension that allows you to set cookie permissions for the site you are viewing. Suggested usage: Disable cookies in Tools-Options-Privacy and only permit cookies from sites you trust.

Config::Std is a Perl module load and save configuration files in a standard format.

SYNOPSIS

use Config::Std;

# Load named config file into specified hash...
read_config demo2.cfg => my %config;

# Extract the value of a key/value pair from a specified section...
$config_value = $config{Section_label}{key};

# Change (or create) the value of a key/value pair...
$config{Other_section_label}{other_key} = $new_val;

# Update the config file from which this hash was loaded...
write_config %config;

# Write the config information to another file as well...
write_config %config, $other_file_name;

This module implements yet another damn configuration-file system.

The configuration language is deliberately simple and limited, and the module works hard to preserve as much information (section order, comments, etc.) as possible when a configuration file is updated.

See Chapter 19 of "Perl Best Practices" (OReilly, 2005) for the rationale for this approach.