NAME

DESCRIPTION

Let me first show you a sample block with a couple of keyword/value pairs to make the description a bit simpler to understand.

console simple { master localhost; type exec; rw *; }
    

This is actually a fully functional conserver.cf file (if certain conditions are met...and if you can list those conditions, you can probably can skip to the BLOCKS section).

Our example is made of up of a console-block named ``simple'' with three keyword/value pairs. What this does is define a console named ``simple'', makes the master of that console the host ``localhost'', makes the type an exec-style console, and gives every user read/write permission. This is the generic format of the file:

block-type block-name { keyword value; ... }
    

To show the addition of comments and whitespace, here is the example reformatted (but functionally equivalent):

# define a console named "simple"
console simple {
    # setting all required values...
    master localhost;
    type exec;  # exec-style console
    rw *;       # allow any username
}
    

PARSER

Word separation occurs when the parser encounters an unquoted token and, in certain cases, whitespace. Whitespace is only used as a word separator when the parser is looking for a block-type or keyword. When it's looking for a block-name or value, whitespace is like any other character, which allows you to embed whitespace in a block-name or value without having to quote it. Here is an example:

default my defs { rw *; include other defs  ; }
    

The block-type is ``default'', the block-name is ``my defs'', and the value for the keyword ``include'' is ``other defs''. Whitespace around tokens are ignored so you get ``other defs'' instead of ``other defs '' as the value.

The only way to use one of the special characters as part of a block-name or value is to quote it.

Quoting is a simple matter of prefixing a character with a backslash or surrounding a group of characters with double-quotes. If a character is prefixed by a backslash, the next character is a literal (so ``\\'' produces a ``\'', ``\"'' produces ``"'', ``\{'' produces a ``{'', etc.). For double-quoted strings, all characters are literal except for ``\"'', which embeds a double-quote.

Adding a variety of quotes to our example without changing the meaning of things, we have:

"defa"ult my\ defs { rw *; in\clude "other defs"  ; }
    

There is one special line the parser recognizes: a ``#include'' statement. It is of the form:

#include filename

Any whitespace around filename is ignored, but whitespace embedded inside is preserved. Everything in filename is taken literally, so none of the normal parser quoting applies. The #include must begin in ``column 0'' - no whitespace is allowed between it and the start of the physical line. There is an include file depth limit of 10 to prevent infinite recursion.

BLOCKS

access hostname|ipaddr

Define an access block for the host named hostname or using the address ipaddr. If the value of ``*'' is used, the access block will be applied to all conserver hosts. Access lists are used in a first match fashion (top down), so order is important.

break n

Define a break sequence where (1 <= n <= 9) or (a <= n <= z). Break sequences are accessed via the ``^Ecln'' client escape sequence.

config hostname|ipaddr

Define a configuration block for the host named hostname or using the address ipaddr. If the value of ``*'' is used, the configuration block will be applied to all conserver hosts.

console name

Define a console identified as name. The keywords are the same as the default block with the following addition.

default name

Define a block of defaults identified as name. If name is ``*'', the automatically applied default block is defined (basically all consoles have an implicit ``include "*";'' at the beginning of their definition).

group name

Define a user group identified as name.

task c

Define a task where c is a lowercase alphanumeric (0-9a-z). Tasks are invoked via the ``^Ec!c'' client escape sequence.

AUTHORS

SEE ALSO