Free config file software for linux

Edit Config Files is an extension that allows you to edit config files.

Edit configuration files with your favorite editor from Toolbar or Tools menu.

Remove the menu icon

Add the following to userChrome.css:

#editconfigfiles-menu
{
list-style-image:none !important;
}

Xmms::Config is a Perl Interface to xmms_cfg API.

SYNOPSIS

my $file = Xmms::Config->file; #$ENV{HOME}/.xmms/config
my $cfg = Xmms::Config->new($file);

DNS::Config is a Perl module with DNS Configuration.

SYNOPSIS

use DNS::Config;
my $config = new DNS::Config();
$config->debug();

ABSTRACT

This class represents a configuration for a domain name service daemon (DNS).

A domain name service daemon configuration knows about the zone information actively provided to the service users as well as lots of other configuration data.

This class allows to represent this configuration data in a more or less generic way. Another class, the file adaptor, then knows how to write the information to a file in a daemon specific format.

So far this class is strongly related to the ISCs Bind domain name service daemon but it is inteded to get more generic in upcoming releases. Your help is welcome.

libConfig++ is a library made in C++ for reading configuration files which were written in C style syntax.
These are the main points of this project:
- This project allows you to write simple but powerful configuration files and use their in you C++ projects.
- The sintax of configuration file is like C++, that is why it is wellknown for you.
- The sintax parser is written with help of lex and bison. Thats why you can easy change the sintax if you want.
- The library is portable to any unix OS and Windows.
- There is easy using and safe interface to setup your program variables from config. - Type control is made during compilation. This helps to avoid some invisible errors in sources.
- You can define your own types and the library will control this when you setup variables from config file.
- The library allows using multifile configuration. Token "#include" allows to include one config file into other.
Enhancements:
- New syntax was added for section descriptions.
- Minor API changes were made.

Config::Fast is an extremely fast configuration file parser.

SYNOPSIS

# default config format is a space-separated file
company "Supercool, Inc."
support nobody@nowhere.com


# and then in Perl
use Config::Fast;

%cf = fastconfig;

print "Thanks for visiting $cf{company}!n";
print "Please contact $cf{support} for support.n";

This module is designed to provide an extremely lightweight way to parse moderately complex configuration files. As such, it exports a single function - fastconfig() - and does not provide any OO access methods. Still, it is fairly full-featured.

Heres how it works:

%cf = fastconfig($file, $delim);

Basically, the fastconfig() function returns a hash of keys and values based on the directives in your configuration file. By default, directives and values are separated by whitespace in the config file, but this can be easily changed with the delimiter argument (see below).

When the configuration file is read, its modification time is first checked and the results cached. On each call to fastconfig(), if the config file has been changed, then the file is reread. Otherwise, the cached results are returned automatically. This makes this module great for mod_perl modules and scripts, one of the primary reasons I wrote it. Simply include this at the top of your script or inside of your constructor function:

my %cf = fastconfig(/path/to/config/file.conf);

If the file argument is omitted, then fastconfig() looks for a file named $0.conf in the ../etc directory relative to the executable. For example, if you ran:

/usr/local/bin/myapp

Then fastconfig() will automatically look for:

/usr/local/etc/myapp.conf

This is great if youre really lazy and always in a hurry, like I am.

If this doesnt work for you, simply supply a filename manually. Note that filename generation does not work in mod_perl, so youll need to supply a filename manually.

Config::Framework is a Perl module with handy one-stop shopping for (most) of your configuration file needs.

SYNOPSIS

#create a new object, load two configuration files and decrypt the passwords. my $Object = new Config::Framework( Files => [ApplicationCfg.xml,UserCfg.xml], GetSecure => 1 ) || die $Config::Framework::errstr;

#change some data in one of the loaded configs $Object->{UserCfg}->{backgroundColor} = #00CCFF;

#write that change back to the file you loaded it from $Object->WriteConfig(configNamespace => "UserCfg") || die $Object->{errstr};

#Define a new configuration namespace %{ $Object->{newConfig} } = ( configNamespace => "newConfig", protectNamespace => 1, Version => 1, #arbitrary data keys follow backgroundColor => #006699, getRecords => 10, followLinks => 1, someThing => "in a bag" );

#Write your new configuration data out to an encrypted file #under the applications ApplicationFramework directory $Object->WriteConfig( configNamespace => "newConfig", Encrypt => 1, Crypt => "Rijndael", Key => "l33tp4sw3rd" File => "$Object->{FrameworkDir}/newConfig.xml" ) || die $Object->{errstr};

At long last I have decided to re-write the documentation for Config::Framework, in a manner which should be comprehensible by people other than myself. I would like to offer my sincerest appologies to anyone who tried to comprehend the sprawling stream-of-consiousness rant that was the previous documentation. Im sorry, I wasnt trying to make you insane. Now on with the show.

Ok so what is Config::Framework? Its a handy module for dealing with situations where you need your program to be able to load external data from a file that controls how your program operates. Im talking about configuration files here. So what do you do in a situation like that? Well you figure out a format to store your configuration parameters in, then write routines to read that format and put it some sort of meaningful data structure, and to write data from the data structure back out to the file.

Wouldnt it be nice if someone defined a standard config file format so that you wouldnt need to write your own parser? Well in the end, all a config file really is, is an arbitrary data structure expressed in in ascii. A standard way of serializing data structures in ascii you say? That sounds a bit like XML! Well the Data::DumpXML module will serialize perl data structures into XML and restore them for you, and you could certainly dump that to a file easily enough.
Ok getting to the point. The main thing that Config::Framework does for you is to define a standard data structure (or at least some standard guidelines for your data structure) and then front-ends Data::DumpXML so that you can arbitrarily dump and restore these data structures to files.

While were at it, Config::Framework aspires to be your one-stop-shop for config-type-stuff, by helping you stay organized in the way you handle external configuration data.

NetCARD Config project helps linux users to configure network cards for two ip one for DSL network one for Local Network.

Config::General is a perl module opens a config file and parses its contents for you.
Config::General library provides variable interpolation, saving of configs (kinda serializer), an OOP-Interface and much more.
The format of config files supported by Config::General is inspired by the well known apache config format, in fact, this module is 100% compatible to apache configs(read-only), but you can also just use simple name/value pairs in your config files.
In addition to the capabilities of an apache config file it supports some enhancements such as here-documents, C-style comments or multiline options.
Installation:
To install, type:
perl Makefile.PL
make
make test
make install
To read the complete documentation, type:
perldoc Config::General
perldoc Config::General::Extended
perldoc Config::General::Interpolated
See some example config files which can be parsed with Config::Genreal in the subdirectory t/cfg.*
Enhancements:
- A number of bugs were fixed and unit tests were improved.