This is Info file CfgTie.info, produced by Makeinfo version 1.68 from
the input file CfgTie.tex.

This is the documentation for the CfgTie library

Copyright (c) 1996-9 Randall Maas


File: CfgTie.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)

* Menu:

* Introduction::           An introduction

* Overview::		   An overview of the CfgTie world

* SS::			   Safety & Security

* CSS::                    Style Sheet for example CGI scripts.

* Modules ::               A collection of code

* Related Work::

* Function Index::         The index of all procedure and functions

* Variable Index::

* Concept Index::


File: CfgTie.info,  Node: Introduction,  Next: Overview,  Prev: Top,  Up: Top

CfgTie:: A Configuration Interface thru Perl
********************************************

Introduction
============

CfgTie is a package of Perl modules and tools.  These make it easier to
configure and maintain Unix computers.

The idea is that just about everything in your machines environment can
- nay should - be operable thru a single consistent interface.  This is
a set of tools that make many of the various configuration subsystem in
your machine appear to be Perl variables of some sort.  (There are
other modules available from CPAN for the other aspects of your
environment).

Problem Domain
--------------

This module makes the configuration text files and subsystems available
to Perl as conventional objects.  These are mapped into Perl, usually
as hash arrays, but providing object methods where appropriate.  Any
changes to these is mapped back into the various text files and other
subsystems.

Installation
------------

After unpacking the tar file, do:
             perl Makefile.PL
             make
             make test
             make install

Additional, post-install tests
------------------------------

There are some extra tests that can also be done after a successful
install.  This are not intended for normal installs, but for
developpers working on CfgTie and various extensions.

Optional Modules
----------------

   * Rcs

   * Getopts::Long

How to find out more
--------------------

*online documentation*
     There is a set of online documentation.





     `http://www.geocities.com/CapeCanaveral/Lab/1862/script/CfgTie_toc.html'

*mailling list*
     There is a mailling list to discuss this package.

    Send email to <cfgtie@onelist.com>

    You can subscribe by going to
          `http://www.onelist.com/subscribe.cgi/cfgtie'

    You can browse through the archives by going to
          `http://www.onelist.com/archives.cgi/cfgtie'

    You can subscribe by going to OneList's homepage.
          `http://www.onelist.com/'

*Contact the author:*
     Randall Maas (<randym@acm.org>)

Copyright
---------

Copyright (C) 1998-1999, Randall Maas. All rights reserved.  This
package is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.


File: CfgTie.info,  Node: Overview,  Next: SS,  Prev: Introduction,  Up: Top

A broad overview of CfgTie
**************************

CfgTie is a set of PERL modules, each working with the configuration
tables of some subsystem.    For our purposes, configuration will
basically be defined loosely as:
   * Settings in various files, or databases

   * Probably establish some bounds for your system

   * Describe an arrangement of modules and subsystems

   * May describe how things currently are.

Standards in the API
====================

Most of the configuration elements have been developed to work as both
Perl ties (almost always hashes or associative arrays), and as Perl
objects.  In the more complex cases, the associative arrays often refer
to other associatve arrays.  Otherwise the stored values are list
references.

To make these work as a normal variable you need only:

   * reference the desired module: `require cfgthingy;' `my %Table;'

   * Then, tie it a variable that you want to use: `tie %Table,
     'cfgthingy', param1, param2, ...'

Traps
-----

Traps on changes in the variables are not currently implemented in this
module.   The Perl module `Tie::Watch' seems to provide the proper
functionality for this.

Common object methods
---------------------

There as some standard methods typically (but not always) available to
associative arrays:

`HTML();' or `$Table->HTML('MyHTMLClass');'  This return a string
formatted in HTML.  If an HTML class is specified, it will be embedded
in the HTML.  This is useful for style sheets.

`stat();' This works like a normal `stat', returning information about
the last time the table (e.g. file) was accessed, modified, etc.

Attributes
==========

The flags used in all of the variable control procedures are composed of
three sections, based upon what they control

Scope
     This controls the scope of the variable setting.  The scope, from
     the narrowest to the widest scope: *Session*, *Application*,
     *User*, *Group*, *Global*.  That is, a variable set in the *user*
     scope, say, will only affect applications run by that user.
     Currently all of the configuration modules are effectively global.

Inheritance
     This controls whether or not a child process would inherit the
     variable.

Precedence
     This controls whether an operation should affect an already
     existing variable.

Scope attributes
----------------

The current scopes are mutually exclusive, and defined as follows, from
the narrowest to the widest scope:

"session"
     This sets the variable for this session only.

"application"
     This sets the variable for executions of this application only.

"user"
     This sets the variable for use by this user (and any applications
     that may run by said user) only.  If a user is not specified or
     otherwise implied, the effective user id is used to determine the
     user name.

"group"
     This sets the variable for use by this group (and any applications
     that may run by an users in said group) only.  The effective group
     id is used to determine the user name.

"global"
     This sets the variable for use in general by any user or any
     applications.

Implementation
==============

CfgTie uses external utilities
------------------------------

Wherever possible, CfgTie employs utility programs to interact with the
low-level configuration data.  This was choosen for several reasons:

   * The issues of locking, timing, state, security and communication
     with the services can be very specific.  It is better to use a
     utility that correctly addresses this, than reinvent an incorrect
     one.

   * Many of the utilities can be used with `chroot' and other powerful
     tools limit their scope for security reasons.

   * The utilities are usually well designed and offer well thought-out
     functionality that take advantage of the underlying affordances.
     We take advantage of this too.

   * The utilities are written by sharp, dedicated people who will fix
     the bugs with their systems.  CfgTie is meant to work on a broad
     range of platforms: identifying and correctly bugs in low level
     implementations is difficult, and hard to do.

   * The utilities of offer some degree of independence from the
     underlying system.  This lets the system developers choose the
     appropriate implementation, while letting CfgTie work across a
     variety of implementations.

*In conclusion:* By using utilities that were designed with a strong
understanding of these makes CfgTie development faster, more secure
(since we are less likely to make mistakes in implementation those
low-level things), and more portable.

Overhead: where the slow stuff is
---------------------------------

The start-up (e.g. `BEGIN', `tie'), run-time, and shutdown (e.g. `END')
phases all have different costs.  Many of the modules try to balance
light costs with keeping in sync with the rest of the system.  Wherever
possible, the design has been to allow inclusion of the module for
minimal functionality (e.g. `stat') with a low overhead.

This often includes delaying scanning the tables and files until the
first action on the tie.  That is scanning is typically not done when a
variable is tied, but when the tied variable is used with `FETCH',
`FIRSTKEY', `EXISTS', `STORE', `DELETE', etc.

Rewriting a file includes generating a subroutine to do the work; this
is usually delayed to the `END' phase.

Some modules (e.g. `CfgTie::TieGroup', `CfgTie::TieUser',
`CfgTie::TieRCService', etc.) employ an external utility program to make
the system changes.  These programs are run either at the `END' phase,
or at the time of the change, which ever minimizes the number of
program calls and can be done early.

A quick note on the associative arrays versus indexed arrays
------------------------------------------------------------

[Kernighan 98] note that:(1)

     "using Perl associative arrays where indexed arrays would server
     can increase runtimes dramatically."

CfgTie does use arrays for just this reason.  But associative arrays
are used extensive for:
   * When there is a large amount of partly structured information, but
     the particular elements can't be neccessarily be known ahead of
     time or atleast guaranteed to be present.

   * When some keys of the hash may not be supported on all machines; a
     conventional array couldn't keep the same structure portably.

   * When some elements are controlled or implemented by different
     modules.

   * When a very similar tie is implemented as an associative array.
     For example, `CfgTie::TieUser' (*note CfgTie-TieUser::.) is
     implemented as an associative array for all of the previous
     reasons.  However, `CfgTie::TieGroup' (*note CfgTie-TieGroup::.)
     doesn't have those issues.  It was implemented as an associative
     array to mirror `CfgTie::TieUser' (*note CfgTie-TieUser::.) to
     keep them similar.

---------- Footnotes ----------

(1) [Kernighan 98] Kernighan, Brian; Van Wyk, Christopher. `Timing
Trials, or, the Trials of Timing: Experiments with scripting and
User-Interface Languages'
`http://www.cs.bell-labs.com/cm/cs/who/bwk/interps/pap/html'


File: CfgTie.info,  Node: SS,  Next: CSS,  Prev: Overview,  Up: Top

Safety & Security
*****************

Safety
======

Undoing changes to the configuration
------------------------------------

Since undoing a modification is a critical functionality, this module is
designed to allow this:
  1. The destructive changes (delete or modifying and existing value)
     are not committed until the END phase of execution.

  2. Changes done to the text files are done in a way so that original
     file is not replaced until after the text file has been completed.

  3. All aspects that employ text files support the use of the `Rcs'
     module and checking these text files.


The last item requires an add-on module, and user experience with RCS to
undo changes.  There is some prototyping of an additional method to
complete this, and make it possible in a programmatic fashion.  The
plan is to allow tagging of configuration sets...

   * <tag, {<file,version>}>

   * Ability to rollback (undo) changes.

   * go back to $tag versions, or

   * revert all the settings associated with $tag to what the were
     before

Security
========

Much of the environment manager package is agnostic about security - it
does not try apply much of its view of security, nor does it try to
undermine standard security models.   Here are the basics:
  1. None of the modules in the standard distribution attempt to switch
     to another user or group, except to make the real UID and GID the
     same as the effective UID and GID.  This is for SUID/SGID
     programs, and this switch is done when opening files for reading,
     writing, appending, or anything else.  These are returned to their
     previous settings after the file is closed.

     The switch is done to cover the following kinds of scenarios.
     Lets say there is a SUID program to let some people do a
     particular task, but the task is SUID'd to root.  The effective
     UID would be root, but all of the files the create here will be
     owned by the normal user.  This is to prevent anyone other than
     (say) root from creating or changing files (and contents) that are
     or will be owned by root -  which would be bad to let happen.
     Alternatively, lets say the admin login in as root (the user id
     really is root),  but as temporarily switch effective user ids to
     help a user out.  We don't let any files with critical
     configuration information get owned by the user - not for an
     instant.

  2. The potential replacement files are initially created with the
     current real user & group priviledges, as described above.  These
     are changed to match the target configuration file's priviledges;
     if (and only if) they match, then the replacement configuration
     file will be migrated in.  A very nice article appeared recently
     in Dr. Dobbs Journal that describes this method,
     `http://www.ddj.com/articles/1999/9901/9901h/9901h.htm'

  3. The environment manager employs `system', and `popen', which have
     known issues with SGID, SUID programs and others.

By logical extension, the security of your system with respect to the
things the environment manager touches are:
  1. The effective and actual user and group ids at execution time.
     Sticky bits, SGID, SUID, and executing as root should be carefully
     considered.  (SUID is to be avoided even more than SUID). There
     are alternative ways, some of which are discussed below.

  2. The execution ID and group of the system service programs and
     daemons that use the configuration files.  It is strongly advised
     (from both experience, and logical security) that none of the
     service daemons be allowed to operate as root user ID or root
     group ID.  One alternative is to assign daemons their own user ID
     and a common group ID.

  3. The permissions set on the configuration files.  In general, none
     of the service processes or daemons should be allowed to modify
     their configuration files; at the least, not unless executed
     specifically, and carefully by an administrator.  Instead, it is
     advised that both world and group permissions to the configuration
     files not have write (or execute!) access.  The configuration
     files group should be the same as the daemon's group, with read
     permission enabled for the group.  The owner of the configuration
     files should a user (preferably not root) other than the daemon's
     user id, and may have write access.  Alternatively, if SGID
     methods are used (and the configuration files are allowed group
     write access), be sure that the daemons execute as a different
     group id.   This way, control of who may modify the configuration
     files can be carefully maintained, and not by anyone who may
     subvert the daemon.

These suggestions are an operational definition of the "principle of
least priviledge".

Requirements
============

If you wish to use the revision control aspects, you will need the RCS
module for Perl (from CPAN).


File: CfgTie.info,  Node: CSS,  Next: Modules,  Prev: SS,  Up: Top

Adding your own style sheet
***************************

The various modules provide methods for generating HTML fragments,
something `sys.cgi' (*note sys.cgi::.) uses as an example.  The HTML is
done in a style-sheet friendly way.

Cascading Style Sheets (CSS) are easy enough that we recommend looking
at the existing style sheet (`cgi/CfgTie.css') and skim the spec
(`http://www.w3.org/Style/CSS/'). The only really non-straightforward
thing is the nesting of styles and cascading. You don't need to read
the entire long document in full to understand it; Skimming it is
plenty.

The key to style-sheets is "classes".  HTML markup can include a class
attribute to indicate how it should rendered.  An example might be:
     	<td class="cfgval">blah</td>

CfgTie uses the `cfgval' class to indicate values for various settings,
and `cfgattr' to indicate the variable names that are being set.

Nesting in style sheets
=======================

The following CSS fragment means that paragraphs nested inside TDs of
class `cfgattr'  will have black text and yellow backgrounds.

        TD.cfgattr P { color: black; background: yellow; }

Contrast this with:

        TD.cfgattr, TD.cfgval { ... }

Which means that both TDs of class `cfgattr' and `cfgval' will have the
given style. Commas: terseness, No commas: nesting. There's a few nice
paragraphs dedicated to this in the spec.

As for cascading, that's the downfall of style sheets and their greatest
benefit. Read the spec for that, it's pretty involved and is described
there better than we could do anyway.

Basically, the spec is the best source of info on this, and
experimentation with existing style sheets is the best way to learn.


File: CfgTie.info,  Node: Modules,  Next: Related Work,  Prev: CSS,  Up: Top

Modules
*******

* Menu:


* bykind::

* bytype::

* alphabetical::


File: CfgTie.info,  Node: bykind,  Next: bytype,  Prev: Modules,  Up: Modules

* Menu:


* Examples:: Example utilities

* Network::  Network related configuration

* Users::    Users, Groups, etc. Stuff


File: CfgTie.info,  Node: Examples,  Next: Network,  Prev: bykind,  Up: bykind

Examples
========

* Menu:


* CfgAliases:: A Command Line Tool to manage `/etc/aliases'

* CfgNamed:: A Command line tool to manage your DNS server

* mail-validate:: A tool that describes possible problems with the mail spool

* sys.cgi :: A CGI script to browse thru the configuration


File: CfgTie.info,  Node: Network,  Next: Users,  Prev: Examples,  Up: bykind

Network
=======

* Menu:


* CfgNamed::

* CfgTie-TieHost::

* CfgTie-TieNamed::

* CfgTie-TieNet::

* CfgTie-TieProto::

* CfgTie-TieServ::


File: CfgTie.info,  Node: Users,  Prev: Network,  Up: bykind

User and Group Configuration
============================

* Menu:


* CfgTie-TieGroup::

* CfgTie-TieShadow::

* CfgTie-TieUser::


File: CfgTie.info,  Node: bytype,  Next: alphabetical,  Prev: bykind,  Up: Modules

Categories
==========

* Menu:


* bin::
* CfgTie::


File: CfgTie.info,  Node: alphabetical,  Prev: bytype,  Up: Modules

Alphabetical
============

* Menu:


* CfgAliases::
* CfgNamed::
* CfgTie-CfgArgs::
* CfgTie-Cfgfile::
* CfgTie-filever::
* CfgTie-TieAliases::
* CfgTie-TieGeneric::
* CfgTie-TieGroup::
* CfgTie-TieHost::
* CfgTie-TieNamed::
* CfgTie-TieNet::
* CfgTie-TiePh::
* CfgTie-TieProto::
* CfgTie-TieRCService::
* CfgTie-TieRsrc::
* CfgTie-TieServ::
* CfgTie-TieShadow::
* CfgTie-TieUser::
* mail-validate::
* sys.cgi::


File: CfgTie.info,  Node: bin,  Next: CfgTie,  Up: bytype

bin
***

bin
===

* Menu:


* CfgAliases::
* CfgNamed::
* mail-validate::
* sys.cgi::


File: CfgTie.info,  Node: CfgAliases,  Next: CfgNamed,  Up: bin

CfgAliases
==========

NAME
----

CfgAliases -- a tool to help change you email `/etc/aliases' settings

DESCRIPTION
-----------

This is a tool to help modify and keep your `/etc/aliases' file up to
date.

COMMAND LINE PARAMETERS
-----------------------

The parameters are a broken down into three categories:

Specifying groups, users, and people
     `--user', `--group'

Adding, changing, removing, or retrieving entries
     `--add', `--delete', `--fetch', `--join', `--remove', `--rename',
     `--set'

Specifying Groups, Users, People
................................

`--user='*NAME*

`--user '*NAME*
     This specifies the user name.

`--group='*NAME*

`--group '*NAME*
     This specifies the group name

Adding, Changing, Removing, or Retrieving Entries.
..................................................

The following specify how to change various entries.  Typically they
can not be intermixed on the same command line.  (Exceptions are noted.)

`--add '*ADDRESS*

`--add='*ADDRESS*
     This will add the *ADDRESS* (user, group, etc.) to a mail group.
     The group must be specified with the `--group' option above.

`--delete '*NAME*

`--delete='*NAME*
     This will remove the mail *alias*(es) specified by *NAME*.  It
     will also remove from any mail *alias*(es) (or groups) any
     *member*(s) that matches *NAME*.  *NAME* may be a regular
     expression.  (Can be used with `--remove' and `--rename').

`--fetch '*NAME*

`--fetch='*NAME*
     This will retrieve the list of recipients in the mail group
     *NAME*.  If *NAME* is a regular expression, information will
     retrieved for every group that matches the pattern.

`--join'

`--join '*GROUP*

`--join='*GROUP*

`--join '*GROUP1*,*GROUP2*,...

`--join='*GROUP1*,*GROUP2*,...
     The current or effective user will be added to a mail *group*(s).
     If no groups are specified with this option, it must be specified
     using the `--group' option above.  Multiple `--join's may be used
     on a command line.

`--remove '*NAME*

`--remove='*NAME*
     Like `delete' above, this will remove the mail *group*(s)
     specified by *NAME*.  *NAME* may be a regular expression.  (Can be
     used with `--delete' and `--rename')

`--rename' *NAME-NEW*=*NAME-OLD*
     This will change all of the occurrences or references that match
     *NAME-OLD* to the newer form of *NAME-NEW*.  This may be a group
     name, and / or members of a group.  This may be a regular
     expression, similar to;
                  s/NAME-OLD/NAME-NEW/

`--set' *NAME*=*MEMBERS*
     This will create a mail group called *NAME* with a set of
     specified members *MEMBERS*.  (Can be used with `--delete' and
     `--remove').

FILES
-----

`/etc/aliases'

SEE ALSO
--------

* Menu:


* CfgTie-CfgArgs::
 for more information on the standard parameters
the *aliases*(5) manpage the *sendmail*(8) manpage

NOTES
-----

Author
......

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgNamed,  Next: mail-validate,  Prev: CfgAliases,  Up: bin

CfgNamed
========

NAME
----

CfgNamed -- a tool to help change your DNS settings

DESCRIPTION
-----------

This is a tool to help modify and keep your DNS server files up to date.

COMMAND LINE PARAMETERS
-----------------------

The parameters are a broken down into three categories:

Retrieving entries
     `--fetch', `--list-forward', `--list-primaries', `--list-reverse',
     `--list-secondaries'

Adding, changing, removing entries
     `--delete', `--remove', `--rename', `--set'

Cleanliness
     `--xref'

Retrieving Entries
..................

`--fetch '*NAME*

`--fetch='*NAME*
     This will retrieve the list of recipients in the group *NAME*.  If
     *NAME* is a regular expression, information will retrieved for
     every group that matches the pattern.

`--list-forward'
     This will retrieve the list of name to address domains being
     served.

`--list-primaries'
     This will retrieve the list of primary domains being served.

`--list-reverse'
     This will retrieve the list of reverse DNS domains (address to
     name) being served.

`--list-secondaries'
     This will retrieve the list of secondary domains being served.

Adding, Changing, or Removing Entries.
......................................

The following specify how to change various entries.  Typically they
can not be intermixed on the same command line.  (Exceptions are noted.)

`--comment '*NAME*=*TEXT*
     This will add a comment record (TXT) describing the named machine.

`--delete '*NAME*

`--delete='*NAME*
     This will remove the *alias*(es) specified by *NAME*.  It will
     also remove from any mail *alias*(es) (or groups) any *member*(s)
     that matches *NAME*.  *NAME* may be a regular expression.  (Can be
     used with `--remove' and `--rename'.)

`--remove '*NAME*

`--remove='*NAME*
     Like `delete' above, this will remove the mail *group*(s)
     specified by *NAME*.  *NAME* may be a regular expression.  (Can be
     used with `--delete' and `--rename'.)

`--rename' *NAME-NEW*=*NAME-OLD*
     This will change all of the occurrences or references that match
     *NAME-OLD* to the newer form of *NAME-NEW*.  This may be a group
     name, and / or members of a group.  This may be a regular
     expression, similar to:
                  s/NAME-OLD/NAME-NEW/

`--set' *NAME*=*MEMBERS*
     This will create a group called *NAME* with a set of specified
     members *MEMBERS*.  (Can be used with `--delete' and  `--remove'.)

Cleanliness
...........

`--xref'

`--xref '*FWD-NAME-SPACE*
     This will have the reverse and forward namespaces properly cross
     referenced and up to date.

FILES
-----

SEE ALSO
--------

* Menu:


* CfgTie-CfgArgs::
 for more information on the standard parameters
the *named*(8) manpage

NOTES
-----

Author
......

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: mail-validate,  Next: sys.cgi,  Prev: CfgNamed,  Up: bin

mail-validate
=============

NAME
----

mail-validate -- A CfgTie example that checks /var/spool/mail for errors

SYNOPSIS
--------

             mail-validate

DESCRIPTION
-----------

This is an example of how CfgTie might be used.  It just checks out the
mail spool (/var/spool/mail) and makes some recommendations.

FILES
-----

`/var/spool/mail'

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: sys.cgi,  Prev: mail-validate,  Up: bin

sys.cgi
=======

NAME
----

sys.cgi -- An example CGI script to browse configuration space via
CfgTie

SYNPOSIS
--------

             http://www.mydomain.com/sys.cgi/user/joeuser
             http://www.mydomain.com/sys.cgi/users
             http://www.mydomain.com/sys.cgi/groups


File: CfgTie.info,  Node: CfgTie,  Prev: bin,  Up: bytype

CfgTie
******

CfgTie
======

* Menu:


* CfgTie-CfgArgs::
* CfgTie-Cfgfile::
* CfgTie-filever::
* CfgTie-TieAliases::
* CfgTie-TieGeneric::
* CfgTie-TieGroup::
* CfgTie-TieHost::
* CfgTie-TieNamed::
* CfgTie-TieNet::
* CfgTie-TiePh::
* CfgTie-TieProto::
* CfgTie-TieRCService::
* CfgTie-TieRsrc::
* CfgTie-TieServ::
* CfgTie-TieShadow::
* CfgTie-TieUser::


File: CfgTie.info,  Node: CfgTie-CfgArgs,  Next: CfgTie-Cfgfile,  Up: CfgTie

CfgTie-CfgArgs
==============

NAME
----

CfgTie::CfgArgs -- Configuration module for parsing commandline-like
arguments

SYNOPSIS
--------

This module is meant to help create useful configuration tools and
utilities.

DESCRIPTION
-----------

A tool to allow many of your computer's subsystems to be configured.
This module parses commandline arguments.  It is provided to help
create a standardized lexicon.

Scope controls and settings
...........................

To specify how much of your system should be affected by the change in
settings:
       --scope=session|application|user|group|system

In addition, each of the individual parts can specified (instead of
their defaults):

`--application='*NAME*

`--application '*NAME*
     This specifies the application.

`--user='*NAME*

`--user '*NAME*
     This specifies the user name.

`--group='*NAME*

`--group '*NAME*
     This specifies the group name.

Operations on variables
.......................

The specific operation to be done:
             --op=set|unset|remove|delete|exists|fetch|get|copy|rename

or:
             --copy   name1=name2 name3=name4 ...
             --exists name1 name2 name3 ...
             --test   name1=value1 name2=value2 ...
             --unset  name1 name2 ...

`--delete '*NAME*

`--delete='*NAME*
     This will remove the entry specified by *NAME*.  *NAME* may be a
     regular expression.

`--fetch '*NAME*

`--fetch='*NAME*
     This will retrieve the information associated with *NAME*.  If
     *NAME* is a regular expression, information will retrieved for
     every entry that matches the pattern.

`--remove '*NAME*

`--remove='*NAME*
     Like `delete' above, this will remove the entry specified by
     *NAME*.  *NAME* may be a regular expression.

`--rename' *NAME-NEW*=*NAME-OLD*
     This will change all of the occurrences or references that match
     *NAME-OLD* to the newer form of *NAME-NEW*.  This may be a regular
     expression, similar to;
                  s/NAME-OLD/NAME-NEW/

`--set' *NAME*=*VALUE*
     This will create an entry called *NAME* with a setting of *VALUE*.

The variable names are optional, and can be explicitly specified:
             --name

Otherwise it is assumed to be the first no flag parameter.

Similarly, the value can be specified
             --value

Other flags
...........

`--file 'FILE

`--file='FILE
     This specifies the configuration file to employ.  If none is
     specified, the default for the particular subsystem will be used
     instead.

`--comment 'COMMENT

`--comment='COMMENT
     This provides a text comment on what changes are being made.

             -n,
             --dry-run,
             --just-print
             --recon

With these flags, the utility program *should not modify any files*.
Instead, it should merely document what changes it would make, what
programs it would run, etc.
             --copyright
             --help
             --info
             --information
             --manual
             --verbose
             --version
             --warranty

Exit value
..........

If the operation exists the return value is zero, otherwise it is
nonzero.

Return from parsing
...................

The hash return:
        {
           SCOPE=> session,application,user,group,system
           OP  => COPY, RENAME, STORE, DELETE, FETCH, or EXISTS
           KEY =>
           VALUE=>
        }


File: CfgTie.info,  Node: CfgTie-Cfgfile,  Next: CfgTie-filever,  Prev: CfgTie-CfgArgs,  Up: CfgTie

CfgTie-Cfgfile
==============

NAME
----

CfgTie::Cfgfile -- A module to help interface to configuration files

SYNOPSIS
--------

Helps interface to the text based configuration files commonly used in
Unix

DESCRIPTION
-----------

This is a fairly generic interface to allow many configuration files to
be used as hash ties.  *Note: This is not intended to be called by user
programs, but by modules wishing to reuse a template structure!*
        package mytie;
        require CfgTie::Cfgfile;

        @ISA = qw(CfgTie::Cfgfile);

        sub TIEHASH
        {
           my $self = shift;
           my $Node = {};
           my $Obj =  bless $Node, $self;
           $Node->{delegate} = CfgTie::Cfgfile->new($Obj,@_);
           $Obj;
        }

my_package_name
     This refers to the package which will parse and interpret the
     configuration file.  More information on this can be found below.

filepath
     *optional*.  If defined, this is the path to the configuration
     file to be opened; otherwise the default for the specified package
     will be used.

RCS-Object
     *optional*.  If defined, this is an RCS object (or similar) that
     will control how to check in and check out the configuration file.
     See RCS Perl module for more details on how to create this object
     (do not use the same instance for each configuration file!).
     Files will be checked back in when the `END' routine is called.
     If a `filepath' is specified, it will override the one previously
     set with the RCS object.  If no `filepath' is specified, but the
     RCS has one specified, it will be used instead.

The *Obj* object
................

The Object may need to provide the following methods:

`scan'
     This is called when the file is first tied in.  It should scan the
     file, placing the associated contents into the `{Contents}' key.

`format'(*key*,*contents*)
     This formats a single entry to be stored in a file.  This is used
     for when a value can be stored simply.

`cfg_begin'
     If this method is defined, it is called just before the
     configuration file will be modified.

`cfg_end'
     If this method is defined, it is called after the configuration
     file has changed.  It can be used, for instances, to rebuild a
     binary database, restart a service, or email Martians.

`makerewrites'
     This is called just before the configuration file will be
     rewritten.  It should return a reference to a function that is
     used to transform the current control file into the new one.  This
     transforming function is called for each line in the configuration
     file while it is being rewritten.

Object methods you can use
..........................

`Comment_Add' This appends the string to the list of comments that will
be logged for this revision (assuming that a Revision Control object
was used).

`Queue_Store($key,$val)' This queues (for later) the transaction that
*key* should be associated with *val*.  The queue is employed to
synchronize all of the settings with the stored settings on disk.

`Queue_Delete($key)' This queues (for later) the transaction that any
value associated with *key* should be removed.

`RENAME(\%rules)' This method will move through the whole table and
make a series of changes.  It may:

Remove some entries, based upon their keys

Rename the keys from some entries

Change the contents of the keys, possibly removing portions
`\%rules' is the set of rules that governs will be changed in name and
what will be removed.  It is an associative array (hash) of a form like:
             {
                 PATTERN1 => "",
                 PATTERN2 => REWRITE,
             }

`PATTERN1 = ' Two things will happen with a rule like this:

Every key in the table that matches the pattern will be removed

Any element (of an entry) that matches the pattern will be removed
`PATTERN2 = REWRITE' In this case the rewrite indicates what should
replace the pattern:

   *  Every key that matches the pattern will be rewritten and replace
     with a new key.

   *  Any element (of an entry) that matches the pattern will be
     modified to match the rewrite rule.

SEE ALSO
--------

* Menu:


* CfgTie-TieRCService::

* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,

* CfgTie-TieGroup::
,
* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,

* CfgTie-TieNet::
,
* CfgTie-TiePh::
,
* CfgTie-TieProto::
,
* CfgTie-TieServ::
,

* CfgTie-TieShadow::
,
* CfgTie-TieUser::

*p321*

CAVEATS
-------

Additions that do not change any previously established values are
reflected immediately (and `newaliases' is run as appropriate).
Anything which changes a previously established value, regardless of
whether or not it has been committed, are queue'd for later.  This
queue is used to rewrite the file when `END' is executed.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-filever,  Next: CfgTie-TieAliases,  Prev: CfgTie-Cfgfile,  Up: CfgTie

CfgTie-filever
==============

NAME
----

CfgTie::filever -- a simple module for substituting newer versions into
a file system.

SYNOPSIS
--------

This module allows a newer version of file to be safely placed into the
file system.

DESCRIPTION
-----------

This is a set of utilities for manipulating files.

`File's_Rotate' (*$Old, $New*)
..............................

This is the file space equivalent to the variable exchange or swap.  The
*old* file will be renamed (with a .old extension) and the *new* file
will be renamed to *old*.  This is extremely useful for many
semi-critical functions, where modifying the file directly will cause
unpredictable results.  Instead, the preferred method is to modify
*old* sending the results to *new* in the background and then doing a
*very* quick switcheroo.

It preserves the permissions and ownership of the original file.

If this routine fails, it will make an attempt to restore things to
their original state and return.

*Return Value*: 0 on success, -1 on error;

`Roll('*path*,*depth*,*sep*`)'
..............................

This convert the specified files into a backup file (the original file
is renamed, so you had better have something to put there).

*Depth*
     (optional) Controlls the number of backup copies

*Sep*
     (optional) Controlls the seperator between the main name and the
     backup number

The defaults for *depth* and *sep* are controlled by following two
variables in the package:

`RollDepth'
     Controlls the number of of older versions that are kept around as
     backup copies.  *`['Default: 4`]'*

`RollSep'
     Controls the separator between the file name and the backup number.
     *`['Default: *`~'*`]'*

`RCS_path ('*RCSObj*,*path*`)'
..............................

For the given RCS object, this sets the working directory and the file.

find_by_user
............

This function attempts to locate all of the files in the system that
are owned by the specified users.  It takes the following parameters:

`Base'
     `Base' can be a string to the base path or a reference to a list
     of base paths to search.

Return Value:

`undef' if there was an error

otherwise the list of file that matched
AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieAliases,  Next: CfgTie-TieGeneric,  Prev: CfgTie-filever,  Up: CfgTie

CfgTie-TieAliases
=================

NAME
----

CfgTie::TieAliases -- an associative array of mail aliases to targets

SYNOPSIS
--------

Makes it easy to manage the mail aliases (`/etc/aliases') table as a
hash.
        tie %mtie,'CfgTie::TieAliases'

        #Redirect mail for foo-man to root
        $mtie{'foo-man'}=['root'];

DESCRIPTION
-----------

This Perl module ties to the `/etc/aliases' file so that things can be
updated on the fly.  When you tie the hash, you are allowed an optional
parameter to specify what file to tie it to.
        tie %mtie,'CfgTie::TieAliases'

or
        tie %mtie,'CfgTie::TieAliases',I<aliases-like-file>

or
        tie %mtie,'CfgTie::TieAliases',I<revision-control-object>

Methods
.......

`ImpGroups' will import the various groups from `/etc/group' using
`CfgTie::TieGroup'.  It allows an optional code reference to select
which groups get imported.  This code is passed a reference to each
group and needs to return nonzero if it is to be imported, or zero if
it not to be imported.  For example:
        (tied  %mtie)->ImpGroups
             {
                my $T=shift;
                if ($T->{'id} < 100) {return 0;}
                return 1;
             }

Format of the `/etc/aliases' file
.................................

The format of the `/etc/aliases' file is poorly documented.  The format
that `CfgTie::TieAliases' understands is documented as follows:

`#'*comments*
     Anything after a hash mark (`#') to the end of the line is treated
     as a comment, and ignored.

*text*`:'
     The letters, digits, dashes, and underscores before a colon are
     treated as the name of an alias.  The alias will be expanded to
     whatever is on the line after the colon.  (Each of those is in
     turn expanded).

CAVEATS
-------

Not all changes to are immediately reflected to the specified file.
See the

* Menu:


* CfgTie-Cfgfile::
 module for more information

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,
* CfgTie-TieRCService::
,

* CfgTie-TieGeneric::
,
* CfgTie-TieGroup::
,
* CfgTie-TieHost::
,

* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,
* CfgTie-TiePh::
,

* CfgTie-TieProto::
,
* CfgTie-TieServ::
,
* CfgTie-TieShadow::
,

* CfgTie-TieUser::

the *aliases*(5) manpage the *newaliases*(1) manpage

AUTHOR
------

Randall Maas (randym@acm.org)


File: CfgTie.info,  Node: CfgTie-TieGeneric,  Next: CfgTie-TieGroup,  Prev: CfgTie-TieAliases,  Up: CfgTie

CfgTie-TieGeneric
=================

NAME
----

CfgTie::TieGeneric -- A generic hash that automatically binds others

SYNOPSIS
--------

This is an associative array that automatially ties other configuration
hashes

DESCRIPTION
-----------

This is a tie to bring other ties together automatically so you, the
busy programmer and/or system administrator, don't have to.  The
related Perl module is not loaded unless it is needed at runtime.
             my %gen;
             tie %gen, 'CfgTie::TieGeneric';

Primary, or well-known, keys
............................

`env'
     This refers directly to the `ENV' hash.

`group'

`mail'
     This is a special key.  It forms a hash, with subkeys.  See below
     for more information

`net'
     This is a special key.  It forms a hash with additional subkeys.
     See below for more details.

`user'
     This is a link to the `TieUser' module (

     * Menu:
     
     
     * CfgTie-TieUser::
     ).

*Composite*
     Composite primary keys are just like absolute file paths.  For
     example, if you wanted to do something like this:
                  my %lusers = $gen{'user'};
                  my $Favorite_User = $lusers{'mygirl'};

     You could just do:
                  my $Favorite_User = $gen{'/users/mygirl'};

others...
     These are the things automatically included in.  This will be
     described below.

Subkeys for `mail'
..................

`aliases'
     * Menu:
     
     
     * CfgTie-TieAliases::

Subkeys for `net'
.................

`host'
     * Menu:
     
     
     * CfgTie-TieHost::

`service'
     * Menu:
     
     
     * CfgTie-TieServ::

`protocol'
     * Menu:
     
     
     * CfgTie-TieProto::

`addr'
     * Menu:
     
     
     * CfgTie-TieNet::

How other ties are automatically bound
......................................

Other keys are automatically (if it all possible) brought in using the
following procedure:

  1. If it is something already linked to it, that thingy is
     automatically returned (of course).

  2. If the key is simple, like `AABot', we will try to `use AABot;' If
     that works we will tie it and return the results.

  3. If the key is more complex, like `/OS3/Config', we will try to see
     if `OS3' is already tied (and try to tie it, like above, if not).
     If that works, we will just look up `Config' in that hash.  If it
     does not work, we will try to `use' and `tie' `OS3::Config',
     `OS3::TieConfig', and `OS3::ConfigTie'.  If any of those work, we
     return the results.

  4. Otherwise, `undef' will be returned.


SEE ALSO
--------

* Menu:


* CfgTie-TieAliases::
,
* CfgTie-TieGroup::
,

* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,

* CfgTie-TiePh::
,
* CfgTie-TieProto::
,
* CfgTie-TieRCService::
,

* CfgTie-TieServ::
,
* CfgTie-TieShadow::
,
* CfgTie-TieUser::

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieGroup,  Next: CfgTie-TieHost,  Prev: CfgTie-TieGeneric,  Up: CfgTie

CfgTie-TieGroup
===============

NAME
----

CfgTie::TieGroup -- an associative array of group names and ids to
information

SYNOPSIS
--------

Makes the groups database available as regular hash
             tie %group,'CfgTie::TieGroup'
             $group{'myfriends'}=['jonj', @{$group{'myfriends'}];

DESCRIPTION
-----------

This is a straight forward hash tie that allows us to access the user
group database sanely.

It cross ties with the user package and the mail packages

Ties
....

There are two ties available for programmers:

`tie %group,'CfgTie::TieGroup''
     `$group{$name}' will return a hash reference of the named group
     information.

`tie %group_id,'CfgTie::Group_id''
     `$group_id{$id}' will return a HASH reference for the specified
     group.

Structure of hash
.................

Any given group entry has the following information assoicated with it:

`name'

`id'

`members'
     A list reference to all of the users that are part of this group.

`_members'
     A list reference to all of the users that are explicitly listed in
     the `/etc/group' file.

Plus an (probably) obsolete fields:

`Password'
     This is the encrypted password, but will probably be obsolete.

Each of these entries can be modified (even deleted), and they will be
reflected in the overall system.  Additionally, the programmer can set
any other associated key, but this information will only be available
to a running Perl script.

Additional Routines
...................

`&CfgTie:TieGroup'status()'

`&CfgTie::TieGroup_id'status()'
     Will return `stat' information on the group database.

Miscellaneous
.............

`$CfgTie::TieGroup_rec'groupmod' contains the path to the program
`groupmod'.  This can be modified as required.

`$CfgTie::TieGroup_rec'groupadd' contains the path to the program
`groupadd'.  This can be modified as required.

`$CfgTie::TieGroup_rec'groupdel' contains the path to the program
`groupdel'.  This can be modified as required.

FILES
-----

`/etc/passwd' `/etc/group' `/etc/gshadow' `/etc/shadow'

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,

* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,
* CfgTie-TieHost::
,

* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,
* CfgTie-TiePh::
,

* CfgTie-TieProto::
,
* CfgTie-TieRCService::
,

* CfgTie-TieServ::
,
* CfgTie-TieShadow::
,
* CfgTie-TieUser::

the *group*(5) manpage, the *passwd*(5) manpage, the *shadow*(5)
manpage, the *groupmod*(8) manpage, the *groupadd*(8) manpage, the
*groupdel*(8) manpage

CAVEATS
-------

The current version does cache some group information.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieHost,  Next: CfgTie-TieNamed,  Prev: CfgTie-TieGroup,  Up: CfgTie

CfgTie-TieHost
==============

NAME
----

CfgTie::TieHost -- This accesses the hosts tables.

SYNOPSIS
--------

This is an associative array that allows the hosts tables to be
configured easily.
             tie %host,'CfgTie::TieHost';

DESCRIPTION
-----------

This is a straightforward hash tie that allows us to access the host
database sanely.

Ties
....

There are two ties available for programmers:

`tie %host,'CfgTie::TieHost''
     `$host{$name}' will return a hash reference of the named host
     information.

`tie %host_addr,'CfgTie::TieHost_addr''
     `$host_addr{$addr}' will return a hash reference for the specified
     host.

Structure of hash
.................

Any given host entry has the following information assoicated with it:

`Name'
     Host name

`Aliases'
     Other names for this host

`AddrType'
     The type of address

`Length'

`Addrs'
     A list reference of addresses.  You will need something like
                 ($a,$b,$c,$d) = unpack('C4',$Addr);

     to get the address out sanely.

Additionally, the programmer can set any other associated key, but this
information will only be available to a running Perl script.

SEE ALSO
--------

* Menu:


* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,
* CfgTie-TieGroup::
,

* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,
* CfgTie-TiePh::
,

* CfgTie-TieProto::
,
* CfgTie-TieServ::
,
* CfgTie-TieShadow::
,

* CfgTie-TieUser::

the *host*(5) manpage

CAVEATS
-------

The current version does cache some host information.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieNamed,  Next: CfgTie-TieNet,  Prev: CfgTie-TieHost,  Up: CfgTie

CfgTie-TieNamed
===============

NAME
----

CfgTie::TieNamed -- A tool to help configure the name daemon (BIND DNS
server)

SYNOPSIS
--------

This is a PERL module to help make it easy to configure the DNS name
server

DESCRIPTION
-----------

This is a tie hash to the NAMED configuration files.  You use it as
follows:
        tie %named, 'CfgTie::TieNamed','/path/to/named.boot';
        $named = CfgTie::TieNamed->new('/path/to/named.boot');

These will set up a hash (*named*) to the named configuration files.
It will used the specified `named.boot' file.
        tie %named, 'CfgTie::TieNamed';
        $named = CfgTie::TieNamed->new();

These will set up a hash (*named*) to the named configuration files.
The files will be automatically determined from the system startup
scripts.

Examples
........

Lets say you would like to name a bunch of machines (like modems) with
a base name and a number.  The number part needs to be the same as the
same as the last number in the IP address.  You know these go in a
domain like, "wikstrom.pilec.rm.net" which is a zone for your name
server:
           tie %DNS, 'CfgTie::TieNamed';
           my $Tbl = $DNS->{'primary'}->{'wikstrom.pilec.rm.net'};
           my $N=10; #Ten modems;
           my $prefix="usr2-port";
           my $ip_start=11;
           for (my $i = 0; $i < $N; $i++)
           {
              #Insert the address record in the table
              $Tbl->{$prefix.$i}->{'A'} = "127.221.19.".($i+$ip_start);
           }

           #Finally make sure that the reverse name space is up to date
           (tied %DNS)->RevXRef('wikstrom.pilec.rm.net','19.221.127.in-addr.arpa');

Even the address to name mapping will be kept up to date.

The basic structure of the named configuration table
....................................................

`bogusns'
     A list of name server addresses to ignore.

`cache'
     See the *named*(8) manpage for a description

`check-names'

`directory'
     This specifies the working directory of the `named' server, and is
     used in determining the location of the associated files.

`forwarders'
     A list of other servers' addresses on the site that can be used
     for recursive look up.

`limit'
     Controls operational parameters of the `named' server.  See below.

`options'
     The list of options the `named' server should adhere to.

`primary'
     This maps to a an associative array of name spaces we are primary
     for.  See below for more details on this is handled.

`secondary'
     This maps to a an associative array of name spaces we are
     secondary for.

`sortlist'
     See the *named*(8) manpage for a description

`xfrnets'
     The list of networks which are allowed to request zone transfers.
     If not present, all hosts on all networks are.

Others may be set as well, but they are for backwards compatibility and
should be changed to the more appopriate form.  See the *named*(8)
manpage for more information.

Extra methods for the configuration table
.........................................

These are various methods you can use.  Of course, you will need an
object reference you can use for the remaining methods.  Note that if
you tied the variable, you will want to use code sorta like: `my $Obj =
tied %CfgTie::TieNamed;'

`RevSpaces' Is the list of the reverses addresses spaces that the
server is primary for (except loopback)

`FwdSpaces' Is the list of name spaces the server is primary for
(except the loopback and reverse name spaces)

`RevXRef($'*fwd*`,$'*rev*`)' This will check that reverse look up is up
to date with the primary look up.  It will add reverse entries as
appropriate (if there is one missing, or the value is correct).  It
will not change a reverse entry if there are multiple names with the
same address entry.  *rev* is optional, but this method will return
(with a 0) if it is not specified and there is more than one reverse
name space.  *fwd* is optional, but this method will return (with a 0)
if it is not specified and there is more than one primary name space.
Returns the number of entries changed or added.

*Note:* This also derives any other methods from the `CfgTie::Cfgfile'
module (

* Menu:


* CfgTie-Cfgfile::
).

The basic structure of a primary name space table
.................................................

The `$named-'>`{primary}' entry refers to a associative arrays.  The
keys are the domain names that are to be server.  ie,
        my %mydom = $name->{primary}->{'mydomain.com'};

These associations in turn refer to a table of names and their
respective attributes.  The keys to this table are the machine names.

The values associated keys are hash references to domain name records.
This in turn refers to another (confused yet?) associative array.  The
keys of this table are the DNS attribute names.  The values associated
with the key are list references, usually a set of possible values for
the given attribute and name pair.  The most common ones are:

`A'
     This is a list reference to all of the physical addresses the
     given machine name has.

`NS'
     This is a list reference to all of the servers that can serve as
     domain name servers.

`CNAME'
     This is a list reference to all of the real names the given machine
     name has.

`SOA'
     Has a list reference with the following structure `HOSTDATAFROM
     MAILADDR SERIAL REFRESH RETRY EXPIRE MinTTL' The Serial number is
     automatically updated for each table that is changed.  The format
     is guessed (from various date formats include YYYYMMDD, YYYYDDD,
     and others), and properly incremented or set.

`PTR'
     This is a list reference to the real name of a given machines
     address.

`TXT'
     Each element of this list refers to a string describing the domain
     or name.

`WKS'

`HINFO'
Extra methods table
...................

`DblLinks' This looks for entries with both a `A' and a `CNAME' entry.
*Keep* controls whether to keep the `A' or the `CNAME' entry; the
default is to keep the `A' entry (and delete the `CNAME' entry).
Returns a count of all the records that were modified.

*Note:* This also derives any other methods from the `CfgTie::Cfgfile'
module (

* Menu:


* CfgTie-Cfgfile::
).

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,

* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,
* CfgTie-TieGroup::
,

* CfgTie-TieHost::
,
* CfgTie-TieNet::
,
* CfgTie-TiePh::
,

* CfgTie-TieProto::
,
* CfgTie-TieRCService::
,
* CfgTie-TieServ::
,

* CfgTie-TieShadow::
,
* CfgTie-TieUser::

CAVAETS
-------

Much of the information is cached and the file is updated at the end.
The `named' process will sent the `SIGHUP' signal to restart and reload
the configuration files.

The reverse name file can not be automatically created... Only modified.

The SOA records in the named configuration files are not easy to change.

Changing the file name or directory currently does not move the files
in the file system

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieNet,  Next: CfgTie-TiePh,  Prev: CfgTie-TieNamed,  Up: CfgTie

CfgTie-TieNet
=============

NAME
----

CfgTie::TieNet -- A module to tie in the net database

SYNOPSIS
--------

             tie %net,'CfgTie::TieNet'

DESCRIPTION
-----------

This is a straightforward hash tie that allows us to access the net
database sanely.

Ties
....

There are two ties available for programmers:

`tie %net,'CfgTie::TieNet''
     `$net{$name}' will return a hash reference of the named net
     information

`tie %net_addr,'CfgTIe::TieNet_addr''
     `$net_addr{$addr}' will return a hash reference for the specified
     network address.

Structure of hash
.................

Any given net entry has the following information assoicated with it:

`Name'
     net name

`Aliases'
     A list reference for other names for this net

`AddrType'
     The type of address

`Addr'
     The address

Additionally, the programmer can set any other associated key, but this
information will only available to the running Perl script.

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,

* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,
* CfgTie-TieGroup::
,

* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,
* CfgTie-TiePh::
,

* CfgTie-TieProto::
,
* CfgTie-TieServ::
,
* CfgTie-TieShadow::
,

* CfgTie-TieUser::

CAVEATS
-------

The current version does cache some net information.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TiePh,  Next: CfgTie-TieProto,  Prev: CfgTie-TieNet,  Up: CfgTie

CfgTie-TiePh
============

NAME
----

CfgTie::TiePh -- a ph phonebook server configuration tool

SYNOPSIS
--------

Makes it easy to manage the ph phonebook server configuration files as
a hash.
        tie %myhash, 'ph'

        %myhash{who}->{Person}

DESCRIPTION
-----------

This is a file to help configure the `ph' program.
        tie %myhash, 'ph'

        %myhash{who}->{Person}
        %myhash{who}->{Phone}

Methods
.......

This inherits any methods from the `CfgTie::Cfgfile' module (

* Menu:


* CfgTie-Cfgfile::
)

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,

* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,

* CfgTie-TieGroup::
,
* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,

* CfgTie-TieNet::
,
* CfgTie-TiePh::
,
* CfgTie-TieProto::
,

* CfgTie-TieRCService::
,

* CfgTie-TieServ::
,
* CfgTie-TieShadow::
,
* CfgTie-TieUser::

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieProto,  Next: CfgTie-TieRCService,  Prev: CfgTie-TiePh,  Up: CfgTie

CfgTie-TieProto
===============

NAME
----

CfgTie::TieProto, CfgTie::TieProto_num -- Ties the protocol number file
to a  PERL hash

SYNOPSIS
--------

             tie %proto, 'CfgTie::TieProto';
             print $proto{'tcp'};

DESCRIPTION
-----------

This is a straightforward hash tie that allows us to access the protocol
number database sanely.

Ties
....

There are two ties available for programmers:

`tie %proto,'CfgTie::TieProto''
     `$proto{$name}' will return a hash reference of the named protocol
     information

`tie %proto_num,'CfgTie::TieProto_num''
     `$proto_num{$num}' will return a hash reference for the specified
     protocol number.

Structure of hash
.................

Any given proto entry has the following information assoicated with it:

`Name'
     proto name

`Aliases'
     A list reference for other names for this proto

`Number'
     The protocol number

Additionally, the programmer can set any other associated key, but this
information will only be available to the running Perl script.

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,
* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,

* CfgTie-TieGroup::
,
* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,

* CfgTie-TieNet::
,
* CfgTie-TiePh::
,
* CfgTie-TieProto::
,

* CfgTie-TieServ::
,
* CfgTie-TieShadow::
,
* CfgTie-TieUser::

CAVEATS
-------

The current version does cache some proto information.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieRCService,  Next: CfgTie-TieRsrc,  Prev: CfgTie-TieProto,  Up: CfgTie

CfgTie-TieRCService
===================

NAME
----

CfgTie::TieRCService -- A module to manage Unix services

SYNOPSIS
--------

        my %RC;
        tie %RC, 'CfgTie::TieRCService';

DESCRIPTION
-----------

This is a straightforward interface to the control scripts in
@file{/etc/rc?.d} This package helps manage these system services.  The
tie hash is structured like so:
        {
            $Service_Name => $Service_Ref,
        }

`$Service_Ref' is a hash reference; the details will be covered in the
next section.  `(tied $Service_Ref)' can also be treated as an object
to control the service.  That is covered in the *Service Methods*
section.

While fetching from the structure, and deleting services is supported
(and reflected to the system), directly storing new services is not.
Currently the method to do this is:
             (tied %RC)->add('mynewservice');

This will add the new service (to be managed as well as available) to
the run-levels.  The start and kill scripts will be linked into each
appropriate run-level.  The script should already exist (in the proper
format) in `/etc/rc.d/init.d' or equivalent.

The Service hash reference
..........................

        {
           levels   => [],
           defaults => [],
           category => [],
           pid  => $pid,
           path =>,
           description =>,
           start_priority=>,
           stop_priority =>,
        }

`levels' refers to a list used to determine if the service is present
for a given run-level.  The scope of changes this list is
*system-wide*.  It is persistent across boots.  Example:

my $listref = (tied %{$RC{'atd'}})->*levels()*;
         if ($L < scalar @{$listref} && $listref->[$L])
           {print "present at run level $L\n";}

Service Methods
...............

`new($service_name,$path)' *path* is optional, and may refer either to
the folder containing the relevant control script, or may refer to the
control script itself.

`start'  will start the service (if not already started).  The scope of
this action is *system-wide*.  Example: `$Obj-'>`start();'

`stop' will stop the service (if running).  The scope of this action is
*system-wide*.  Example: `$Obj-'>`stop();'

`restart' will restart the service, effectively stopping it (if it is
running) and then starting it.  The scope of this action is
*system-wide*.  Example: `$Obj-'>`restart();'

`status' The scope of this action is limited to a single *session*.

`reload' The scope of this action is *system-wide*.

CAVEATS
-------

This can not create a new service start/kill script.  At best this can
only modify an existing one, or link it into the init folders.

BUGS
----

Requires `/sbin/chkconfig' to work.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieRsrc,  Next: CfgTie-TieServ,  Prev: CfgTie-TieRCService,  Up: CfgTie

CfgTie-TieRsrc
==============

NAME
----

CfgTie::TieRsrc -- an associative array of resources and their usage
limits

SYNOPSIS
--------

This module makes the resource limits available as a regular hash
             tie %Resources,'CfgTie::TieRsrc'

DESCRIPTION
-----------

This is a straightforward hash tie that allows us to access the user
database sanely.

The resource limits for the system.  Note: this requires that
`BSD::Resource' be installed.

It is a hash reference.  The keys may be any of `cpu', `data', `stack',
`core', `rss', `memlock', `nproc', `nofile', `open_max', `as', `vmem',
`nlimits', `infinity'.  The values are always list references of the
form:
                     [$soft, $hard]

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,
* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,

* CfgTie-TieGroup::
,

* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,

* CfgTie-TiePh::
,
* CfgTie-TieProto::
,
* CfgTie-TieServ::
,

* CfgTie-TieShadow::

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieServ,  Next: CfgTie-TieShadow,  Prev: CfgTie-TieRsrc,  Up: CfgTie

CfgTie-TieServ
==============

NAME
----

CfgTie::TieServ -- A HASH tie that allows access the service port
database

SYNOPSIS
--------

             tie %serv,'CfgTie::TieServ';
             print $serv{'smtp'};

DESCRIPTION
-----------

This is a straight forward HASH tie that allows us to access the service
port database sanely.

Ties
....

There are two ties available for programers:

`tie %serv,'CfgTie::TieServ''
     `$serv{$name}' will return a HASH reference of the named service
     information

`tie %serv_port,'CfgTie::TieServ_port''
     `$serv_port{$port}' will return a HASH reference for the specified
     service port.

Structure of hash
.................

Any given serv entry has the following information assoicated with it:

`Name'
     Service name

`Aliases'
     A list reference for other names for this service

`Port'
     The port number

`Protocol'
     The protocol name

Additionally, the programmer can set any other associated key, but this
information will only available to running PERL script.

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,
* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,

* CfgTie-TieGroup::
,

* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,

* CfgTie-TiePh::
,
* CfgTie-TieProto::
,
* CfgTie-TieShadow::
,

* CfgTie-TieUser::

CAVAETS
-------

The current version does cache some service information.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieShadow,  Next: CfgTie-TieUser,  Prev: CfgTie-TieServ,  Up: CfgTie

CfgTie-TieShadow
================

NAME
----

CfgTie::TieShadow -- an associative array of user names to password
information

SYNOPSIS
--------

This module makes the shadow database available as a regular hash.

DESCRIPTION
-----------

This is a straightforward hash tie that allows us to access the shadow
password database sanely.

Ties
....

This tie is available for programmers:

`tie %shadow,'CfgTie::TieShadow''

`$shadow{$name}' will return a hash reference of the named shadow
information

Structure of hash
.................

Any given shadow entry has the following information associated with it
(the keys are case-insensitive):

`Name'
     Login name

`Password'
     The encrypted password

`Last'
     Last time it was changed

`Min'
     The minimum number of days before a change is allowed

`Max'
     Maximum number of days before a change in passowrds is required

`Warn'
     The number of days before expiration that they will receive a
     warning

`Inactive'
     The number of days before an account is inactive

`Expires'
     The date the account expires on

`Inactive'
     The number of days after a password expires that the account is
     considered inactive and expires

Each of these entries can be modified (even deleted), and they will be
reflected in the overall system.  Additionally, the programmer can set
any other associated key, but this information will only available to
the running Perl script.

Additional Routines
...................

`&CfgTie::TieShadow'status()'

`&CfgTie::TieShadow_id'status()'
     Will return `stat' information on the shadow database.

Miscellaneous
.............

`$CfgTie::Tiehadow_rec'usermod' contains the path to the program
`usermod'.  This can be modified as required.

`$CfgTie::TieShadow_rec'useradd' contains the path to the program
`useradd'.  This can be modified as required.

`$CfgTie::TieShadow_rec'userdel' contains the path to the program
`userdel'.  This can be modified as required.

FILES
-----

`/etc/passwd' `/etc/group' `/etc/shadow'

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,
* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,

* CfgTie-TieGroup::
,

* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,

* CfgTie-TiePh::
,
* CfgTie-TieProto::
,
* CfgTie-TieServ::
,

* CfgTie-TieShadow::
,
* CfgTie-TieUser::

the *group*(5) manpage, the *passwd*(5) manpage, the *shadow*(5)
manpage, the *usermod*(8) manpage, the *useradd*(8) manpage, the
*userdel*(8) manpage

CAVEATS
-------

The current version does cache some shadow information.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: CfgTie-TieUser,  Prev: CfgTie-TieShadow,  Up: CfgTie

CfgTie-TieUser
==============

NAME
----

CfgTie::TieUser -- an associative array of user names and ids to
information

SYNOPSIS
--------

makes the user database available as a regular hash.
             tie %user,'CfgTie::TieUser'
             print "randym's full name: ", $user{'randym'}->{gcos}, "\n";

DESCRIPTION
-----------

This is a straightforward hash tie that allows us to access the user
database sanely.

It cross ties with the groups packages and the mail packages

Ties
....

There are two ties available for programmers:

`tie %user,'CfgTie::TieUser''
     `$user{$name}' will return a hash reference of the named user
     information.

`tie %user_id,'CfgTie::TieUser_id''
     `$user_id{$id}' will return a hash reference for the specified
     user.

Structure of hash
.................

Any given user entry has the following information assoicated with it
(the keys are case-insensitive):

`Name'
     Login name

`GroupId'
     The principle group the user belongs to.

`Id'
     The user id number that they have been assigned.  It is possible
     for many different user names to be given the same id.  However,
     changing the id for the user (i.e., setting it to a new one) has
     one of two effects.  If `user'Chg_FS' is set 1, then all the files
     in the system owned by that id will changed to the new id in
     addition to changing the id in the system table.  Otherwise, only
     the system table will be modified.

`Comment'

`Home'
     The user's home folder

`LOGIN_Last'
     This is the information from the last time the user logged in.  It
     is an array reference to data like:
                  [$time, $line, $from_host]

`Shell'
     The user's shell

`AuthMethod'
     The authentication method if other than the default.  (Note: This
     can be set, but currently can't get fetched.)

`ExpireDate'
     The date the account expires on.  (Note: this can be set, but
     currently can't be fetched.)

`Inactive'
     The number of days after a password expires.  (Note: this can be
     set, but currently can't be fetched.)

`Priority'
     The scheduling priority for that user.  (Note: this requires that
     `BSD::Resource' be installed.)

`Quota'

`RUsage'
     The process resource consumption by the user.  Note: This requires
     that `BSD::Resource' be installed.

     Returns a list reference of the form:
             [$usertime, $systemtime, $maxrss,  $ixrss,   $idrss,  $isrss,  $minflt,
              $majflt,   $nswap,      $inblock, $oublock, $msgsnd, $msgrcv, $nsignals,
              $nvcsw, $nivcsw]

Plus two (probably) obsolete fields:

`Password'
     This is the encrypted password, but will probably be obsolete.

`GCOS'
     *General Electric Comprehensive Operating System* or *General
     Comprehensive Operating System* field

     This is now the user's full name under many Unix's, incl. Linux.

Each of these entries can be modified (even deleted), and they will be
reflected in the overall system.  Additionally, the programmer can set
any other associated key, but this information will only be available
to the running Perl script.

Configuration Variables
.......................

Additional Routines
...................

`&CfgTie::TieUser'stat()'

`&CfgTie::TieUser_id'stat()'
     Will return `stat'-like statistics information on the user
     database.

Adding or overiding methods for user records
............................................

Lets say you wanted to change the default HTML handling to a different
method.  To do this you need only include code like the following:
        package CfgTie::TieUser_rec;
        sub HTML($)
        {
           my $self=shift;
           "<h1>".$Self->{name}."</h1>\n".
           "<table border=0><tr><th align=right>\n".
             join("</td></tr>\n<tr><th align=right>",
               map {$_."</th><td>".$self->{$_}} (sort keys %{$self})
            </td></tr><lt></table>C<\n>";
        }

If, instead, you wanted to add your own keys to the user records,
`CfgTie::TieUser::add_scalar('*$Name*,*$Package*`)' Lets you add scalar
keys to user records.  The *Name* specifies the key name to be used; it
will be made case-insensitve.  The *Package* specifies the name of the
package to be used when tie'ing the key to a value.  (The `TIESCALAR'
is passed the user id as a parameter).

`CfgTie::TieUser::add_hash('*$Name*,*$Package*`)' Lets you add hash
keys to user records.  The *Name* specifies the key name to be used; it
will be made case insensitve.  The *Package* specifies the name of the
package to be used when tie'ing the key to a value.  (The `TIEHASH' is
passed the user id as a parameter).

Miscellaneous
.............

`$CfgTie::TieUser_rec'usermod' contains the path to the program
`usermod'.  This can be modified as required.

`$CfgTie::TieUser_rec'useradd' contains the path to the program
`useradd'.  This can be modified as required.

`$CfgTie::TieUser_rec'userdel' contains the path to the program
`userdel'.  This can be modified as required.

Not all keys are supported on all systems.

This may transparently use a shadow tie in the future.

When the changes are reflected to /etc/passwd
.............................................

FILES
-----

`/etc/passwd' `/etc/group' `/etc/shadow'

SEE ALSO
--------

* Menu:


* CfgTie-Cfgfile::
,
* CfgTie-TieAliases::
,
* CfgTie-TieGeneric::
,

* CfgTie-TieGroup::
,

* CfgTie-TieHost::
,
* CfgTie-TieNamed::
,
* CfgTie-TieNet::
,

* CfgTie-TiePh::
,
* CfgTie-TieProto::
,
* CfgTie-TieServ::
,

* CfgTie-TieShadow::

the *group*(5) manpage, the *passwd*(5) manpage, the *shadow*(5)
manpage, the *usermod*(8) manpage, the *useradd*(8) manpage, the
*userdel*(8) manpage

CAVEATS
-------

The current version does cache some user information.

AUTHOR
------

Randall Maas (<randym@acm.org>)


File: CfgTie.info,  Node: Related Work,  Next: Function Index,  Prev: Modules,  Up: Top

Related Work and things to do
*****************************

Related Modules
===============

The following is a table of related modules.  They are different from
this module.  Any feedback or work on determining if this difference
should be reduced would be appreciated.  Of course, doing the work too.

HTTPD
     There is a Perl module, `HTTPD-Tools' that help configure the HTTPD
     daemon.

.newsrc associative array
     The Perl module that already does this is `News-Newsrc'

Process associative arrays
     The relevant existing Perl module is `Proc-ProcessTable'.  If it
     used an associative array interface, in part, this would make
     signalling named services easier.

Quotas
     The relevant Perl module is `Quota' The quota subsystem works with
     the C<CfgTie::TieUser> and the C<CfgTie::TieMTab> hash-spaces.

Windows INI files
     The relevenat Perl module is `Win32_Tie_Ini_Source'

Windows Registry Files
     The relevant Perl module is `Win32_TieRegistry'

What needs to be or could be written
====================================

Get tested on Win32 platforms

Get tested on Qube platforms

Get tested on Solaris platforms

Get tested on MacPerl platforms

Ability to add or remove a service from various run levels

Ability to add or remove a service altogether

Ability to change the defaults for a service

IO descriptor associative array
     manipulate sockets and files and such

semaphore associative array

shared memory associative array

arp interface

session associative array

tty associative array

folder associate array
     Scan folders and such.  Not necessarily good idea.

The future:
Boundaries, routers, gateways and bridges
        * ascend

        * cisco

Interlink services
        * sendmail

        * qmail

        * apache (see the HTTPD thing above.)

        * INN

        * modifying services table (media protocols, and service
          protocols)

Monitor services
        * NOCOL

        * statusd

Distribution services
        * rsync, rdist

User interfaces
        * XWindows  Window managers (FVWM2)  .Xresources

        * C shell

        * POSIXly shells -  Korn & Bourne & BASH

Local system
        * filesystem tables

        * tunefs

Ability to receive batch changes

CVS

Handle symbolic links better.

Work with cfengine
     `http://www.delorie.com/gnu/docs/cfengine/'

Possibly work with RFC 2244
     `ftp://ftp.isi.edu/in-notes/rfc2244.txt'

Work with linuxconf
     `http://www.solucorp.qc.ca/linuxconf/'

Work with webmin
     `http://www.webmin.com/webmin/'

Possibly work with opStore
     `http://24.1.97.22/gmd/opStore/framedIndex.html'


File: CfgTie.info,  Node: Function Index,  Next: Variable Index,  Prev: Related Work,  Up: Top

Function Index
**************

* Menu:

* &CfgTie::TieGroup_id'status():         CfgTie-TieGroup.
* &CfgTie::TieShadow'status():           CfgTie-TieShadow.
* &CfgTie::TieShadow_id'status():        CfgTie-TieShadow.
* &CfgTie::TieUser'stat():               CfgTie-TieUser.
* &CfgTie::TieUser_id'stat():            CfgTie-TieUser.
* &CfgTie:TieGroup'status():             CfgTie-TieGroup.


File: CfgTie.info,  Node: Variable Index,  Next: Concept Index,  Prev: Function Index,  Up: Top

Variable Index
**************

* Menu:

* --add *ADDRESS*:                       CfgAliases.
* --add=*ADDRESS*:                       CfgAliases.
* --application *NAME*:                  CfgTie-CfgArgs.
* --application=*NAME*:                  CfgTie-CfgArgs.
* --comment *NAME*=*TEXT*:               CfgNamed.
* --comment COMMENT:                     CfgTie-CfgArgs.
* --comment=COMMENT:                     CfgTie-CfgArgs.
* --delete *NAME* <1>:                   CfgTie-CfgArgs.
* --delete *NAME* <2>:                   CfgNamed.
* --delete *NAME*:                       CfgAliases.
* --delete=*NAME* <1>:                   CfgTie-CfgArgs.
* --delete=*NAME* <2>:                   CfgNamed.
* --delete=*NAME*:                       CfgAliases.
* --fetch *NAME* <1>:                    CfgTie-CfgArgs.
* --fetch *NAME* <2>:                    CfgNamed.
* --fetch *NAME*:                        CfgAliases.
* --fetch=*NAME* <1>:                    CfgTie-CfgArgs.
* --fetch=*NAME* <2>:                    CfgNamed.
* --fetch=*NAME*:                        CfgAliases.
* --file FILE:                           CfgTie-CfgArgs.
* --file=FILE:                           CfgTie-CfgArgs.
* --group *NAME* <1>:                    CfgTie-CfgArgs.
* --group *NAME*:                        CfgAliases.
* --group=*NAME* <1>:                    CfgTie-CfgArgs.
* --group=*NAME*:                        CfgAliases.
* --join:                                CfgAliases.
* --join *GROUP*:                        CfgAliases.
* --join *GROUP1*,*GROUP2*,...:          CfgAliases.
* --join=*GROUP*:                        CfgAliases.
* --join=*GROUP1*,*GROUP2*,...:          CfgAliases.
* --list-forward:                        CfgNamed.
* --list-primaries:                      CfgNamed.
* --list-reverse:                        CfgNamed.
* --list-secondaries:                    CfgNamed.
* --remove *NAME* <1>:                   CfgTie-CfgArgs.
* --remove *NAME* <2>:                   CfgNamed.
* --remove *NAME*:                       CfgAliases.
* --remove=*NAME* <1>:                   CfgTie-CfgArgs.
* --remove=*NAME* <2>:                   CfgNamed.
* --remove=*NAME*:                       CfgAliases.
* --rename *NAME-NEW*=*NAME-OLD* <1>:    CfgTie-CfgArgs.
* --rename *NAME-NEW*=*NAME-OLD* <2>:    CfgNamed.
* --rename *NAME-NEW*=*NAME-OLD*:        CfgAliases.
* --set *NAME*=*MEMBERS* <1>:            CfgNamed.
* --set *NAME*=*MEMBERS*:                CfgAliases.
* --set *NAME*=*VALUE*:                  CfgTie-CfgArgs.
* --user *NAME* <1>:                     CfgTie-CfgArgs.
* --user *NAME*:                         CfgAliases.
* --user=*NAME* <1>:                     CfgTie-CfgArgs.
* --user=*NAME*:                         CfgAliases.
* --xref:                                CfgNamed.
* --xref *FWD-NAME-SPACE*:               CfgNamed.
* _members:                              CfgTie-TieGroup.
* Addr:                                  CfgTie-TieNet.
* addr:                                  CfgTie-TieGeneric.
* Addrs:                                 CfgTie-TieHost.
* AddrType <1>:                          CfgTie-TieNet.
* AddrType:                              CfgTie-TieHost.
* Aliases <1>:                           CfgTie-TieServ.
* Aliases <2>:                           CfgTie-TieProto.
* Aliases <3>:                           CfgTie-TieNet.
* Aliases:                               CfgTie-TieHost.
* aliases:                               CfgTie-TieGeneric.
* AuthMethod:                            CfgTie-TieUser.
* Base:                                  CfgTie-filever.
* bogusns:                               CfgTie-TieNamed.
* cache:                                 CfgTie-TieNamed.
* cfg_begin:                             CfgTie-Cfgfile.
* cfg_end:                               CfgTie-Cfgfile.
* check-names:                           CfgTie-TieNamed.
* CNAME:                                 CfgTie-TieNamed.
* Comment:                               CfgTie-TieUser.
* directory:                             CfgTie-TieNamed.
* env:                                   CfgTie-TieGeneric.
* ExpireDate:                            CfgTie-TieUser.
* Expires:                               CfgTie-TieShadow.
* format(*key*,*contents*):              CfgTie-Cfgfile.
* forwarders:                            CfgTie-TieNamed.
* GCOS:                                  CfgTie-TieUser.
* group:                                 CfgTie-TieGeneric.
* GroupId:                               CfgTie-TieUser.
* HINFO:                                 CfgTie-TieNamed.
* Home:                                  CfgTie-TieUser.
* host:                                  CfgTie-TieGeneric.
* Id:                                    CfgTie-TieUser.
* id:                                    CfgTie-TieGroup.
* Inactive <1>:                          CfgTie-TieUser.
* Inactive:                              CfgTie-TieShadow.
* Last:                                  CfgTie-TieShadow.
* Length:                                CfgTie-TieHost.
* limit:                                 CfgTie-TieNamed.
* LOGIN_Last:                            CfgTie-TieUser.
* mail:                                  CfgTie-TieGeneric.
* makerewrites:                          CfgTie-Cfgfile.
* Max:                                   CfgTie-TieShadow.
* members:                               CfgTie-TieGroup.
* Min:                                   CfgTie-TieShadow.
* Name <1>:                              CfgTie-TieUser.
* Name <2>:                              CfgTie-TieShadow.
* Name <3>:                              CfgTie-TieServ.
* Name <4>:                              CfgTie-TieProto.
* Name <5>:                              CfgTie-TieNet.
* Name:                                  CfgTie-TieHost.
* name:                                  CfgTie-TieGroup.
* net:                                   CfgTie-TieGeneric.
* NS:                                    CfgTie-TieNamed.
* Number:                                CfgTie-TieProto.
* options:                               CfgTie-TieNamed.
* Otherwise, undef will be returned.:    CfgTie-TieGeneric.
* Password <1>:                          CfgTie-TieUser.
* Password <2>:                          CfgTie-TieShadow.
* Password:                              CfgTie-TieGroup.
* Port:                                  CfgTie-TieServ.
* primary:                               CfgTie-TieNamed.
* Priority:                              CfgTie-TieUser.
* Protocol:                              CfgTie-TieServ.
* protocol:                              CfgTie-TieGeneric.
* PTR:                                   CfgTie-TieNamed.
* Quota:                                 CfgTie-TieUser.
* RollDepth:                             CfgTie-filever.
* RollSep:                               CfgTie-filever.
* RUsage:                                CfgTie-TieUser.
* scan:                                  CfgTie-Cfgfile.
* secondary:                             CfgTie-TieNamed.
* service:                               CfgTie-TieGeneric.
* Shell:                                 CfgTie-TieUser.
* SOA:                                   CfgTie-TieNamed.
* sortlist:                              CfgTie-TieNamed.
* tie %group,'CfgTie::TieGroup':         CfgTie-TieGroup.
* tie %group_id,'CfgTie::Group_id':      CfgTie-TieGroup.
* tie %host,'CfgTie::TieHost':           CfgTie-TieHost.
* tie %host_addr,'CfgTie::TieHost_addr': CfgTie-TieHost.
* tie %net,'CfgTie::TieNet':             CfgTie-TieNet.
* tie %net_addr,'CfgTIe::TieNet_addr':   CfgTie-TieNet.
* tie %proto,'CfgTie::TieProto':         CfgTie-TieProto.
* tie %proto_num,'CfgTie::TieProto_num': CfgTie-TieProto.
* tie %serv,'CfgTie::TieServ':           CfgTie-TieServ.
* tie %serv_port,'CfgTie::TieServ_port': CfgTie-TieServ.
* tie %user,'CfgTie::TieUser':           CfgTie-TieUser.
* tie %user_id,'CfgTie::TieUser_id':     CfgTie-TieUser.
* TXT:                                   CfgTie-TieNamed.
* undef if there was an error:           CfgTie-filever.
* user:                                  CfgTie-TieGeneric.
* Warn:                                  CfgTie-TieShadow.
* WKS:                                   CfgTie-TieNamed.
* xfrnets:                               CfgTie-TieNamed.


File: CfgTie.info,  Node: Concept Index,  Prev: Variable Index,  Up: Top

Concept Index
*************

* Menu:

* *Composite*:                           CfgTie-TieGeneric.
* *Depth*:                               CfgTie-filever.
* *Obj* object:                          CfgTie-Cfgfile.
* *Sep*:                                 CfgTie-filever.
* *text*::                               CfgTie-TieAliases.
* Adding or overiding methods for user records: CfgTie-TieUser.
* Adding, Changing, or Removing Entries.: CfgNamed.
* Adding, changing, removing entries:    CfgNamed.
* Adding, changing, removing, or retrieving entries: CfgAliases.
* Adding, Changing, Removing, or Retrieving Entries.: CfgAliases.
* Additional Routines <1>:               CfgTie-TieUser.
* Additional Routines <2>:               CfgTie-TieShadow.
* Additional Routines:                   CfgTie-TieGroup.
* Any element (of an entry) that matches the pattern will be removed: CfgTie-Cfgfile.
* Author <1>:                            CfgNamed.
* Author:                                CfgAliases.
* basic structure of a primary name space table: CfgTie-TieNamed.
* basic structure of the named configuration table: CfgTie-TieNamed.
* CAVAETS <1>:                           CfgTie-TieServ.
* CAVAETS:                               CfgTie-TieNamed.
* CAVEATS <1>:                           CfgTie-TieUser.
* CAVEATS <2>:                           CfgTie-TieShadow.
* CAVEATS <3>:                           CfgTie-TieRCService.
* CAVEATS <4>:                           CfgTie-TieProto.
* CAVEATS <5>:                           CfgTie-TieNet.
* CAVEATS <6>:                           CfgTie-TieHost.
* CAVEATS <7>:                           CfgTie-TieGroup.
* CAVEATS <8>:                           CfgTie-TieAliases.
* CAVEATS:                               CfgTie-Cfgfile.
* Change the contents of the keys, possibly removing portions: CfgTie-Cfgfile.
* Cleanliness:                           CfgNamed.
* COMMAND LINE PARAMETERS <1>:           CfgNamed.
* COMMAND LINE PARAMETERS:               CfgAliases.
* Configuration Variables:               CfgTie-TieUser.
* Every key in the table that matches the pattern will be removed: CfgTie-Cfgfile.
* Examples:                              CfgTie-TieNamed.
* Exit value:                            CfgTie-CfgArgs.
* Extra methods for the configuration table: CfgTie-TieNamed.
* Extra methods table:                   CfgTie-TieNamed.
* File's_Rotate (*$Old, $New*):          CfgTie-filever.
* filepath:                              CfgTie-Cfgfile.
* find_by_user:                          CfgTie-filever.
* Format of the /etc/aliases file:       CfgTie-TieAliases.
* How other ties are automatically bound: CfgTie-TieGeneric.
* If it is something already linked to it, that thingy is automatically returned (of course).: CfgTie-TieGeneric.
* If the key is more complex, like /OS3/Config, we will try to see if OS3 is already tied (and try to tie it, like above, if not).  If that works, we will just look up Config in that hash.  If it does not work, we will try to use and tie OS3::Config, OS3::TieConfig, and OS3::ConfigTie.  If any of those work, we return the results.: CfgTie-TieGeneric.
* If the key is simple, like AABot, we will try to use AABot; If that works we will tie it and return the results.: CfgTie-TieGeneric.
* Methods <1>:                           CfgTie-TiePh.
* Methods:                               CfgTie-TieAliases.
* Miscellaneous <1>:                     CfgTie-TieUser.
* Miscellaneous <2>:                     CfgTie-TieShadow.
* Miscellaneous:                         CfgTie-TieGroup.
* my_package_name:                       CfgTie-Cfgfile.
* Object methods you can use:            CfgTie-Cfgfile.
* Operations on variables:               CfgTie-CfgArgs.
* Other flags:                           CfgTie-CfgArgs.
* others...:                             CfgTie-TieGeneric.
* otherwise the list of file that matched: CfgTie-filever.
* Primary, or well-known, keys:          CfgTie-TieGeneric.
* RCS-Object:                            CfgTie-Cfgfile.
* RCS_path (*RCSObj*,*path*):            CfgTie-filever.
* Remove some entries, based upon their keys: CfgTie-Cfgfile.
* Rename the keys from some entries:     CfgTie-Cfgfile.
* Retrieving Entries:                    CfgNamed.
* Retrieving entries:                    CfgNamed.
* Return from parsing:                   CfgTie-CfgArgs.
* Roll(*path*,*depth*,*sep*):            CfgTie-filever.
* Scope controls and settings:           CfgTie-CfgArgs.
* Service hash reference:                CfgTie-TieRCService.
* Service Methods:                       CfgTie-TieRCService.
* Specifying groups, users, and people:  CfgAliases.
* Specifying Groups, Users, People:      CfgAliases.
* Structure of hash <1>:                 CfgTie-TieUser.
* Structure of hash <2>:                 CfgTie-TieShadow.
* Structure of hash <3>:                 CfgTie-TieServ.
* Structure of hash <4>:                 CfgTie-TieProto.
* Structure of hash <5>:                 CfgTie-TieNet.
* Structure of hash <6>:                 CfgTie-TieHost.
* Structure of hash:                     CfgTie-TieGroup.
* Subkeys for mail:                      CfgTie-TieGeneric.
* Subkeys for net:                       CfgTie-TieGeneric.
* SYNPOSIS:                              sys.cgi.
* Ties <1>:                              CfgTie-TieUser.
* Ties <2>:                              CfgTie-TieShadow.
* Ties <3>:                              CfgTie-TieServ.
* Ties <4>:                              CfgTie-TieProto.
* Ties <5>:                              CfgTie-TieNet.
* Ties <6>:                              CfgTie-TieHost.
* Ties:                                  CfgTie-TieGroup.
* When the changes are reflected to /etc/passwd: CfgTie-TieUser.



Tag Table:
Node: Top183
Node: Introduction637
Node: Overview2955
Node: SS10196
Node: CSS15255
Node: Modules17022
Node: bykind17171
Node: Examples17378
Node: Network17749
Node: Users17972
Node: bytype18168
Node: alphabetical18307
Node: bin18791
Node: CfgAliases18939
Node: CfgNamed21946
Node: mail-validate24854
Node: sys.cgi25340
Node: CfgTie25693
Node: CfgTie-CfgArgs26112
Node: CfgTie-Cfgfile29590
Node: CfgTie-filever34555
Node: CfgTie-TieAliases36914
Node: CfgTie-TieGeneric39347
Node: CfgTie-TieGroup42356
Node: CfgTie-TieHost45090
Node: CfgTie-TieNamed46756
Node: CfgTie-TieNet53858
Node: CfgTie-TiePh55303
Node: CfgTie-TieProto56302
Node: CfgTie-TieRCService57859
Node: CfgTie-TieRsrc60725
Node: CfgTie-TieServ61863
Node: CfgTie-TieShadow63398
Node: CfgTie-TieUser66104
Node: Related Work72000
Node: Function Index74733
Node: Variable Index75220
Node: Concept Index83589

End Tag Table
