snetd.options(4)

NAME
     snetd.options - network configuration file

DESCRIPTION
     The snetd.options file describes the configuration of the STREAMS network
     constructed by snetd(1M).

     The file is in two sections, separated by a line consisting of the
     character sequence '%%'.  Blank lines may be used freely throughout the
     file, and a token (see below) beginning with an unquoted '#' (hash)
     denotes a comment which lasts till the end of the line.  In addition, a
     backslash (\) immediately preceding the end of a line results in the
     newline being treated as whitespace (except at the end of comment lines).

     Tokens consist either of

     a)   a single occurrence of the special characters { '=', '{', ',', '}' }

     (Note:  '=' is not a special character within the brace-enclosed argument
     list of a control message; ',' is only a special character in this
     position.)

     b)   strings of arbitrary characters enclosed in single or double quotes
          (''' or '"'), but not containing a newline - each quoting character
          quotes the other, for example, "foo 'bar'" or '"foo" bar'

     (Newlines occurring within quoted strings will silently terminate the
     string.)

     c)   sequences of non-whitespace characters not including any of the
          special characters or quotes

     All strings are case-sensitive, and are silently truncated to 200
     characters.

     The modules section describes the individual modules and drivers from
     which the STREAMS network configuration will be built.

     tcp    dc    /dev/tcp
     arp    m     arp
     x25    dc    /dev/x25
     lapb0  dc    /dev/lapb0

     Each line (such as the examples above) consists of three tokens
     (separated by whitespace) as follows.

     The module identifier is the name by which the module or driver will be
     known in the streams section (see below).

     The module type is a sequence of character flags describing the module or
     driver.  The flag 'd' describes a STREAMS driver , whereas 'm' describes
     a module. The 'c' flag specifies a driver to be cloneable. (See the
     STREAMS Programmer's Guide for a detailed description of modules and
     drivers.)

     The module name is the character device name for a driver, or the
     pushable module name for a module.

     The streams section describes the architecture of the network in terms of
     how the previously defined modules and drivers are to be combined (by
     means of the appropriate PUSHes and LINKs) into streams.  Multiplexing
     and cloning are handled automatically by the snetd(1M) utility.

     ip    arp      IP_NET=89.0.0.3
     x25   lapb0    SHELL="x25tune -P -s A def.dte.x25" \
                    X25_SET_SNID={A, LC_LAPBDTE, , }

     Lines in this section (such as the above examples) are of the following
     form.

     The first two tokens on a line are names (module identifiers as defined
     in the previous section) of drivers or modules which are to form the
     upstream and downstream components respectively of a STREAMS link.

     Each link performed between token 1 and token 2 generates a mux_id
     (multiplexing identifier) which is associated with that link.  It is
     possible to override the generated link by replacing token 2 with an
     explicit mux_id, for example:

     lapb0    1     LL_SET_SNID=A \
                    SHELL="lltune -P -p lapb -s B -d /dev/lapb0 def.lapb"

     This sets the mux_id associated with the link to 1 .

     These names may be qualified by a suffix consisting of a colon (:) and a
     number (for example arp:1) to signify a particular instantiation of a
     module.  (An uninstantiated name is an abbreviation for name:0.)  Each
     instantiation of a module can be thought of as a separate block in a
     STREAMS Architecture diagram.  Separate instantiations would be
     appropriate for, say, a module pushed above more than one driver, but not
     for a cloneable multiplexed driver.

     Instantiations are used in the 'streams' section only, to instantiate
     modules defined in the 'modules' section.  The following networking
     example would run IP over two distinct networks:

     ip       dc     /dev/ip
     arp      m      arp
     ethr0    dc     /dev/ethr0
     ethr1    dc     /dev/ethr1

     %%

     ip      arp:0   IP_NET=89.0.0.1
     arp:0   ethr0   ARP_TYPE

     ip      arp:1   IP_NET=89.0.0.2
     arp:1   ethr1   ARP_TYPE

     The remainder of each line consists of a (possibly null) sequence of
     control actions to be performed on completion of the link in the order
     specified.

     Each control action is of the form function = argument-list, where the
     argument-list is either a single string argument or a comma-separated
     list enclosed in braces ({ and }).  Control actions requiring no
     arguments may consist simply of the function component.  Arguments
     containing whitespace or any of the special characters listed above must
     be quoted.

     A special dummy link exists, where no link is formed, but the control
     action is executed.  This occurs when token 2 is a hyphen ( '-' ) .

     For example:

     x25     -       SHELL="pvcmap -P"

     which is simply a shell call to execute pvcmap .

FILES
     /etc/config/snetd.options

SEE ALSO
     snetd(1M), hosts(4).
     The STREAMS Programmer's Guide .