SMAILTRNS(5)

NAME
/usr/local/etc/smail/transports - smail transports configuration

THE TRANSPORTS FILE
The transports file describes the various possible ways, of delivering mail. For example, some possibilities are to call a program such as uux(1) to deliver mail to a remote host, to connect over TCP/IP to a remote host and converse using an SMTP protocol, or to deliver local mail by appending to a user's mailbox file.

NOTE: Unlike the routers and directors files, a locally supplied transports file does not replace all compiled-in transports. Rather, entries in the local transports file override existing entries of the same name, or add new entries. Thus, if you wish to add or replace one new transport definition, you need only provide the new definition, and do not need to duplicate all of the existing entries.

The following list describes the possible generic attributes for transport file entries:

bsmtp
    type: boolean

    Use a batched SMTP format, where the message is enclosed in an envelope of SMTP commands. This is not the same format commonly used on BITNET, as it does not contain FORTRAN carriage control characters. This can be used to send mail to remote hosts using SMTP formats even when direct two-way connections are not feasible. For example, this will work over UUCP and eliminates difficulties with sending arbitrary addresses as arguments to uux. Use of bsmtp also turns on the dots attribute. When used with the uucp attribute, UUCP-style !-path addresses are used in the SMTP envelope.

crlf
    type: boolean

    If set, then each line of the header and message will end in carriage-return/line-feed rather than a single newline character. This is not typically useful, as the SMTP transport, which requires this as a part of the interactive protocol always does this anyway.

debug
    type: boolean

    If set, replaces the body of the message with debugging information. This can be used, for example, as a shadow transport to watch the flow of mail for a while for debugging purposes. This essentially allows for debugging without the ethical and space problems of saving the personal correspondence of others.

dots
    type: boolean

    If set, then use the hidden dot protocol. All output lines which begin with dot will have one more dot prepended. All of the various SMTP modes imply this behaviour.

driver
    type: string

    The driver attribute names a specific set of low-level functions which will do the work of delivering mail. This attribute is always required.

error_transport
    type: string

    names another transport that the message should be sent to, if the first transport returns failure.

from
    type: boolean

    If set, then supply a ``From<<space>>'' line before the message when delivering with this transport. If this is a remote transport (i.e., the local_xform attribute is not turned on) then this line will end with ``remote from hostname'' where hostname is the UUCP name for the local host. This is useful for delivery over UUCP and for delivery to standard mailbox files, which require this format.

hbsmtp
    type: boolean

    ``Half-baked'', or batched, SMTP. This is batched SMTP mode without an initial ``HELO'' greeting command or an ending ``QUIT'' command. This can be used for creating files which will be concatenated together at a later time to form one batch of SMTP commands containing multiple messages. Use of the hbsmtp attribute also turns on the dots attribute.

local_xform
    type: boolean

    If set, the form of the header and envelope information will be setup for delivery to the local host. This performs no changes to existing header fields, other than insertion of commas into fields containing sender and recipient addresses. This also affects the form of any generated ``From<<space>>'' line and the form of envelope addresses used in SMTP commands.

    This can be used with remote delivery, if delivery is to a remote smail3.1 site, which is useful within a domain that maintains consistent user forwarding information. This leaves messages in unqualified format until leaving the domain through a gateway.

local
    type: boolean

    This implies local_xform, but implies that delivery really is final delivery to a user, file, or program on the local host. This disables generation of a bounce message resulting from an excessive message hop-count.

max_addrs
    type: number

    This states the maximum number of recipient addresses that can be given in one call to the transport. If this is turned off then there is no maximum number. The default number is 1 and typically this is either left as 1 or turned off.

max_chars
    type: number

    This states the maximum number of characters in recipient addresses that can be given in one call to the transport. If this is turned off then there is no maximum number. The default number is about one third of the number characters that can be passed as arguments to a program. When using SMTP transports this should be turned off unless a remote host is known to be unable to handle a large number of addresses. For delivery over UUCP to a remote rmail program, this should be around 200 or 250, to avoid buffer overruns at the remote site. UUCP generally has small buffers to hold argument information.

    If smail is given an address whose length exceeds this number, then the address will be passed with one call to the transport. Thus, this limit is not strictly enforced.

max_hosts
    type: number

    This states the maximum number of different hosts that can be given in one call to the transport. If this is turned off, using the form -max_hosts then there is no maximum number. The default number is 1 and typically this is not changed.

received
    type: boolean

    If set, then a Received: header field is inserted for mail being delivered with this transport. The form of this field is taken from the received_field attribute. This attribute is on by default.

return_path
    type: boolean

    If set, then a Return-Path: field is inserted for mail being delivered with this transport. The form of this field is taken from the return_path_field attribute. This should only be used for transports which perform final delivery to local destinations.

shadow
    type: string

    This names another transport that the message should be sent to. This could be used to, for example, to create a local copy of all e-mail carried by the primary transport. The shadow transport is called only if the primary transport successfully performs delivery.

strict
    type: boolean

    If this flag is set, then some effort is done to transform mail which does not conform to RFC 822 standards. This is potentially useful for sites which gateway between the UUCP zone and the Internet. In general, it is not a good idea to turn this on as it changes the contents of headers fields.

    This should only be done when it is known that some remote hosts only understand mail which conforms to the RFC 822 standard.

unix_from_hack
    type: boolean

    If set then any line in the body of the message which begins with ``From<space>'' will have the character `>' inserted at the beginning. This is required for local delivery to mailbox files that are in the standard Unix mailbox form.

uucp
    type: boolean

    If set then outgoing recipient addresses will be converted into UUCP-style paths of the form hosta!hostb!hostc!user. An exception is that any use of `%' as an address operator is preserved. Thus, an envelope address of user%hostb@hosta would be converted to hosta!user%hostb. This only affects envelope addresses and does not affect the message header fields.

inet
    type: boolean

    If set then outgoing recipient addresses will be conform into to internet specifications. This is not the same as the strict attribute, since the transformations apply only to the envelope addresses, and not to headers. If inet is defined, then route-addr addresses will be generated when routing to remote destinations, rather than !-style addresses. Thus, if smail is given the address user%host@gateway and gateway is reached through the path hosta!hostb!hostc, then smail will generate the address @hostb,@hostc:user%host@gateway to be sent to the host @hosta.

retry_dir
    type: string

    The subdirectory under /var/spool/smail/retry to use for managing host retry intervals for this transport. By default, the name of the transport is used. However, multiple transports can share a retry directory by setting retry_dir for several transports to the same value. For example, by default all of the default TCP/IP SMTP transports (inet_zone_smtp, uucp_zone_smtp, and local_smtp set retry_dir to ``smtp'').

remove_header
    type: string

    Identify a header field that will be removed from the message for transport. This is an expansion string, so header removal can be made dependent upon some conditions. If expansion of the string results in an empty string, then no header is removed. Any number of remove_header attributes can be specified.

insert_header

append_header
    type: string

    Add the given header field at the beginning (with insert_header) or end (with append_header) of the message header for transport. These are expansion strings, so the header (and the existence of the header) can be made dependent on some conditions. If expansion of the string results in an empty string, then no header is added. Any number of insert_header and append_header attributes can be specified.

    As an example of the manipulation of headers, consider the addition of an ``Organization'' header for all locally generated mail that does not already have an Organization header. This can be done with:

        append_header="${if and{{origin:local}{!header:organization}} \
                       Organization: ACME Explosives Corp.}"
    To configure a ``Content-Length'' field, which some systems use to identify the length of a message within a mailbox file rather than keying on lines starting with ``<newline>From<space>'', use:

        remove_header="Content-Length",
        append_header="Content-Length: $body_size"

THE TRANSPORT DRIVERS
This section details the usage and driver-specific attributes for all of the transport drivers distributed with smail.

  The Pipe Driver
The pipe driver is the most general form of transport. Its job is to send mail messages to another program, such as uux(1) or sh(1).

The driver attributes for the pipe driver are:

cmd
    type: string

    The program to be run and the arguments to be passed. This is string expanded using some special rules. To handle multiple addresses being given to a transport, the forms ``$('' and ``$)'' can be used to bracket a section of the command string which is to be repeated for each address given to the transport. Single quotes ('), double quotes (") and backslash (\) work as with /bin/sh. Variables are expanded as described in smail(5). It is a configuration error for this variable to be unset or for string expansion to fail or for the resulting command not to specified with an absolute pathname.

defer_child_errors
    type: boolean

    Generally, only child failures from the signal SIGTERM are re-attempted at a later time. If this is set, then retries are performed at a later time if the exit code is non-zero, or if the write failed on the pipe. This is useful for treating errors from UUCP as configuration or as temporary filespace problems.

group
    type: string

    The name of the group to set-group-ID to within the child process. If not set then the default group-ID of the user specified in the user attribute is used. Useful only if the mailer is running as root.

ignore_status
    type: boolean

    If set, the exit status of the child process is ignored. If this is not set, an exit value other than 0 is noted and mail is sent to the postmaster stating this. See also status_to_sender described below.

ignore_write_errors
    type: boolean

    If set, write errors are ignored. This is useful for running programs that may not actually read their standard input. If this is not set, a write error will cause mail to be returned to the sender.

log_output
    type: boolean

    The standard output and standard error files of a command are logged and returned to the sender in case of problems. The current implementation is not very good as it actually returns the logs for all such transports in the event that any transports fail. This attribute is on by default.

parent_env
    type: boolean

    Stuff the environment with data taken from the parent of the input address, rather than the input address itself. This is useful for the transport specifically named pipe which is used by smail for delivery to shell-command addresses. Here the recipient address stored into the environment will then be the address that produced the shell-command address, rather than the shell-command address itself.

pipe_as_sender
    type: boolean

    If set, the child process' UID is taken from the real UID at the time the message was read by smail. This does not affect the group id for the child. This overrides the UID obtained from the pipe_as_user attribute.

pipe_as_user
    type: boolean

    Obtain a UID and, if group attribute is not given, a GID associated with the address (such as the user for a ~/.forward file). Then set these via setuid(2) and setgid(2) in the child process.

    NOTE: This attribute is on by default.

status_to_sender
    type: boolean

    This flag modifies the ignore_status attribute so that any errors resulting in a non-zero status are reported to the sender rather than the postmaster. It is of use if a transport is required (for example) to send an informative message back to the sender detailing local addresses that did not correspond to local users. This would be done using the smartuser director to pass addresses directly to this transport, and then setting -ignore_status, +status_to_sender, and +log_output to send a more detailed error message to the sender, possibly giving details of close matches for the incorrect mailboxes(s).

umask
    type: number

    file creation mask for the child process.

user
    type: string

    The name of the user to set-user-ID to within the child process. Also sets the group ID if the group attribute is not set using the default group-ID of the specified user. Useful only if the mailer is running as root.

The environment of the child process is entirely initialised and loaded with variables which may be useful in shell scripts or intelligent mail processing programs. Exactly one environment variable is passed through from the environment handed to smail: the TZ variable defining the time zone. The following portion of the environment is independent of the recipient addresses:

BASENAME
    the basename for the spool file

GRADE
    the grade character

MESSAGE_ID
    the message-ID as assigned by smail

PATH
    command search path, usually just ``/bin:/usr/bin''

PRIMARY_NAME
    the official name for the host

SENDER
    the sender address

SHELL
    system shell, usually ``/bin/sh''

SPOOL_FILE
    the complete name for the spool file

UUCP_NAME
    the name for the host on the uucp network

VISIBLE_NAME
    the name for the host used in addresses

    The rest of the environment is loaded from the input address, or from the parent of the input address:

ADDR
    The recipient address (or one of the recipient addresses, if more than one is given to the driver).

HOME
    The home directory (or one of home directories, if more than one recipient address is given to the driver). If no home directory is associated with an address, ``/'' is used.

HOST
    The recipient hostname (or one of the recipient hosts, if more than one host is given to the driver).

USER
LOGNAME
    These two variables are loaded with the name of a user on the local host, if one is found with some association to the address.

Examples of the use of the pipe driver are:

    # transport used for delivery to shell-command addresses
    pipe:
        from,
        local,
        return_path,
        unix_from_hack,
        driver=pipe;
        cmd="/bin/sh -c $user",
        # if the system supports #! interpreter file execution
        # the cmd above could be given as just:
        #cmd="$user",
        pipe_as_user,
        -ignore_status,
        -ignore_write_errors,
        parent_env,
        log_output,
    # delivery to a remote rmail(8) program using uux(1)
    uux:
        max_addrs=5,
        max_chars=200,
        from, received,
        driver=pipe;
        cmd="/usr/bin/uux - -r -g$grade $host!rmail $((${strip:user})$)",
        # see ``String expansion'' above
        pipe_as_sender,

  The Appendfile Driver
The appendfile driver creates or appends to files. It can either write to a filename derived from the recipient address, or it write a unique file into a directory. This latter capability can be used to implement a primitive output queue for some purposes.

The driver-specific attributes are:

append_as_user
    type: boolean

    Get the UID and, perhaps, the GID from the user-ID and group-ID associated with the address. For example, the user associated with a forward file might be used. This attribute is on by default.

check_user
    type: boolean

    Reject an address if the $user variable would contain a `/'. This prevents a $user expansion from accessing a different directory.

dir type: string

    Defines a directory in which to write unique files. Files written to this directory always begin with the letter `q', while temporary files used in the creation process begin with ``temp''. This string is expanded similarly to the file attribute. It is a configuration error for any string expansion to fail.

expand_user
    type: boolean

    If set the value for $user value is string expanded before the value for the file or dir attribute is expanded. This is useful if a local-form address may require `~' or `$' expansions.

file
    type: string

    Defines a file to append messages to. This string is expanded, and the variables $user and $host are set from the recipient address. It is a configuration error for this string expansion to fail.

group
    type: string

    become this group. Similar to the user attribute.

mode
    type: number

    When creating a file use this access mode. The default is 0666.

notify_comsat
    type: boolean

    Notify the COMSAT daemon of the message delivery, so that users can be notified that they received mail. This has no effect if your system does not support the COMSAT daemon. This should be used for delivery to user mailbox files.

prefix
    type: string

    This prefix is inserted in the file before the message. This string is expanded, with $user and $host being available from the recipient address. It is a configuration error for this string expansion to fail.

suffix
    type: string

    This suffix is appended to the file after the message. This string is expanded, with $user and $host being available from the recipient address. It is a configuration error for this string expansion to fail.

user
    type: string

    This become this user (effectively at least) when opening or creating the file. Access permissions are checked relative to this user, and the user will own the file if it did not previously exist.

To better understand the use of some of these attributes, consider the transport file entry:

    file:
        driver=appendfile,
        from,
        return_path,
        local;
        file=$user,
        suffix="\n",
        expand_user,
        append_as_user,
        mode=0664
This transport will be called when a file address is produced by a director. Such addresses should be expanded, because they may require `~' expansions. Also, to keep standard many user agents happy, an extra newline is inserted after each message. The append_as_user attribute is set to ensure that addresses produced from, say, a forward file are only created or appended to if the associated user has permissions to do so.

When given an address of ``~/Incoming,'' with an associated home directory of ``/u/joe-user'' and an associated user of ``joe-user'', the following steps occur:

1.  The $user variable is expanded to ``/u/joeuser/Incoming.''

2.  The file attribute is also expanded to ``/u/joeuser/Incoming.''

3.  The directories ``/'', ``/u'' and ``/u/joe-user'' are all checked for accessibility by the user ``joe-user''. If any of these is not searchable by that user, then delivery fails.

4.  The file ``/u/joe-user/Incoming'' is opened for append access. If it does not exist, it is created, will be owned by ``joe-user'' and will have mode 0664. Creation will of course fail if ``joe-user'' cannot write the directory.

5.  The message is written with a local-form ``From<space>'' line.

6.  An extra newline is appended to the file, after the message.

NOTE: Smail will follow the local conventions on locking protocols for mailbox files, which may involve creating a ``.lock'' file or using a file lock system call, such as lockf(3) or lock(2).

Next, lets examine:

    local:
        driver=appendfile,
        local,
        from,
        return_path;
        file=/var/mail/$user,
        append_as_user,
        check_user,
        mode=0600,
        notify_comsat
In this example, the $user value is not expanded before expanding the file attribute. Also, just to make sure, $user is verified to not contain a `/'. Given an input address of ``jane-doe,'' associated with the user ``jane-doe'', mail will be appended to the file ``/var/mail/jane-doe''. If it did not previously exist, it will be owned by ``jane-doe'' and will have a mode of 0600.

  The TCPSMTP Driver
Support exists in smail for delivery using SMTP over TCP/IP, for systems that have BSD compatible networking.

The smtp driver can be used for delivery of any number of addresses to one remote host, where the remote host can be specified either in form of a hostname known by the networking software or by an internet number in square brackets, such as ``[192.0.2.142]''. For example, the routing drivers gethostbyaddr and gethostbyname are suitable for matching addresses to be delivered using the SMTP driver.

The attributes for the tcpsmtp driver are:

short_timeout
    type: interval

    This defines the response timeout for operations that are assumed to be short, such as protocol startup and protocol exit. This can use suffix letters of `s', `m', `h', and `d' to mean seconds, minutes, hours or days, with no suffix signifying seconds. Times can be added through direct concatenation. For example, the value `5m30s' signifies 5 minutes and 30 seconds. The default value is 5 minutes.

long_timeout
    type: interval

    This defines the response timeout for long operations, i.e., those that might require processing on the remote end. Suffix letters can be used in the same manner as with short_timeout. The default value is 5 hours.

service
    type: string_or_number

    This attribute identifies a TCP/IP port number, either directly as a number, or as a name to be searched for in the /etc/services file. This port number will be used in connecting to the remote host. The default is ``smtp''.

use_bind
    type: boolean

    Use DNS name resolution, if supported, to locate and use MX and A records associated with the target and MX hosts. Without this option, the gethostbyname(3n) function is used to locate the address to use for delivery. If the target host was matched with the bind router driver, then MX and A records found by the bind router will be used independent of the use_bind attribute.

    If use_bind is specified, the defer_no_connect, local_mx_okay, defnames, ignore_domains, domain_required, and mx_only attributes control the behaviour of the tcpsmtp transport's use of DNS resolution. See the documentation for the bind router in smailrtrs(5) for an explanation of these attributes.

The tcpsmtp driver attempts to connect immediately and deliver a single message. If access to the remote host is currently not possible, the driver will tell smail that delivery should be attempted at a later time.

An example of the use of the tcpsmtp driver is the entry:

    # deliver using SMTP over TCP/IP to the remote host
    tcpsmtp:
        -max_chars,
        -max_addrs,
        driver=smtp
If your site is on the Internet and gateways from the UUCP zone, it may be reasonable to set the strict attribute. Otherwise, this is probably not a good idea.

If the local attribute is set (see the generic transport attributes), then mail will be transmitted in a form that contains little reference to the transmitting host.

This can be used within a local network to make all mail transmitted within the network look like local mail (i.e., local addresses will not be qualified with the domain name). This is often convenient in environments that use a central host for processing all mailing lists and user addresses, but where mail can originate and be delivered anywhere in the network, and where user names are consistent throughout the network.

When mail is transmitted outside of the local network, a tcpsmtp transport with the local attribute turned off will qualify any mail sent from anywhere inside the network.

The SMTP transport is also affected by the inet and uucp generic transport attributes. If inet is set, then sender and recipient addresses transmitted in the protocol envelope will strictly conform to the RFC 821 and RFC 1123 protocol specifications. However, route-addr addresses may be generated, despite the recommendations of RFC 1123 against such practice. Note that networks connected completely by domain name servers will not result in generation of route-addr addresses, although they will be honoured if received.

If the uucp transport attribute is set, then sender and recipient addresses will conform to the envelope specifications of RFC 976, and will thus use !-style routes. Addresses transmitted to the remote host will consist only of ! and % operators. % operators will never be generated, but may be included if they were present in the original sender or recipient addresses.

If neither the uucp nor the inet attributes are specified, then an intermediate form will be used that nearly eliminates route-addr addresses. This form uses RFC 976 !-style addresses when routing is necessary, but otherwise stays within the formal SMTP specification.

The tcpsmtp driver always sets the crlf and dots transport attributes.

DEFAULT CONFIGURATION
NOTE: A transports file, unlike routers and directors files, does not replace all compiled-in transport definitions. Rather, entries in the transports file override existing entries of the same name, or add new entries. Thus, if you wish to add or replace transport definitions, you need only create a transports file containing the new definition, and you do not need to duplicate all of the compiled-in entries.

The default internal transports configuration can be viewed by typing smail -oT /no-such-file -v -bP TRANSPORTS

The default transport configuration defines:

local
    deliver mail to local users. Usually, delivery is accomplished by writing directly to user mailbox files (either in /usr/mail, /usr/spool/mail, or in /var/mail). Alternately, mail may be delivered by calling a program, such as /bin/mail, /bin/lmail, or /usr/libexec/mail.local to perform delivery using system-dependent conventions.

pipe
    deliver mail to shell command addresses. Shell command addresses begin with a pipe character (`|'). The pipe character is stripped from the address and the remainder of the address is passed as a command to /bin/sh. Shell-command addresses can be generated by mailing lists or forwarding files, but cannot be specified as input to smail.

file
    deliver mail to file addresses. File addresses begin with a `/' or `~' character. If a file address begins with the `~' character followed by the name of a local user, then the `~' and username is replaced by the user's home directory. If a file address begins with ``~/'', then the ``~/'' sequence is replaced by a home directory that is appropriate to the context of the address. Normally ``~/'' is used within the context of addresses specified in a user's ~/.forward file.

uux invoke uux to deliver mail to a remote rmail program. The ``-r'' option is given to uux to prevent an immediate poll.

demand
    this is similar to the uux transport, except that the ``-r'' is not supplied. This will request that UUCP attempt to poll the remote site immediately.

uusmtp
demand_uusmtp
    invoke uux to deliver mail to a remote rsmtp program (supplied in the Smail distribution).

    The transmitted message will be encapsulated in an envelope of SMTP directives, with addresses passed in through the SMTP envelope rather than in the argument list to uux. This works better than the standard ``rmail'' protocol, because quoted addresses can pass through unscathed, and because no limits are given on the number of addresses that can be given in a single transfer. This last point can significantly reduce the number of UUCP transfers needed for large mailing lists, since the normal method of using rmail is limited by uux's internal limit of (usually) 300 characters of worth of arguments.

    Note that the uusmtp transports are not likely to be useful unless both the receiving host also uses Smail-3.

    The uusmtp transport passes the ``-r'' option to uux, while the demand_uusmtp transport does not.

    Also, the uucp generic transport attribute is used by uusmtp and demand_uusmtp to transfer addresses in accordance with the RFC 976 specification. This violates the RFC821 and RFC1123 specifications, but is none-the-less useful between sites operating in the UUCP zone.

inet_uusmtp
inet_demand_uusmtp
    These transports are identical to the uusmtp and demand_uusmtp transports, except that the inet transport attribute is enabled, and the uucp attribute is disabled. This causes mail addresses to be transferred in accordance with the SMTP specifications.

    If routing is required to reach a destination, then route-addr addresses are generated (e.g., <@host1,@host2:user@destination>).

smtp
uucp_zone_smtp
inet_zone_smtp
    deliver mail to a remote host by using the SMTP protocol over a TCP/IP connection. If used in conjunction with the bind router, MX records will be handled in accordance with RFC 974 and RFC 1123.

    The uucp_zone_smtp transport has the uucp transport attribute set, causing transferred addresses to use !-style addresses, as specified in RFC 976. This can often be useful when using SMTP within the UUCP zone, but is otherwise inappropriate.

    The inet_zone_smtp transport has the inet transport attribute set, causing transferred addresses to conform to the RFC 821 and RFC 1123 specifications for SMTP. This is necessary for correct operation with arbitrary nodes on the Internet. Both the uucp_zone_smtp and inet_zone_smtp transports will handle generated routes (from paths files) correctly between nodes running Smail-3. The inet_zone_smtp transport will use route-addr addresses for routing despite RFC 1123's recommendations against such a practice. However, generated routes should never be necessary on the Internet with fully connected DNS and proper MX records.

    The smtp transport is identical to either the uucp_zone_smtp transport or the inet_zone_smtp transport, depending upon local configuration information specified when the smail program is compiled, namely the setting of the ``UUCP_ZONE'' attribute in the conf/EDITME file.

local_uux
local_demand
local_uusmtp
local_demand_uusmtp
local_smtp
    These transports are identical to the uux, demand, uusmtp, demand_uusmtp, and smtp transports, except that they have the local_xform generic transport attribute enabled, and the uucp and inet attributes disabled. This causes mail to be transferred to the remote site without qualifying local addresses. This is useful within closely coordinated networks where usernames and central mailing lists are kept consistent or are processed by central nodes.

FILES

/usr/local/etc/smail/transports
    Optional configuration for smail transports; i.e., configured methods of mail delivery. This file replaces the compiled-in transport configuration.

/var/log/smail/logfile
    A log of smail transactions.

/var/log/smail/paniclog
    A log of configuration or system errors encountered by smail.

SEE ALSO
smail(5). smailconf(5), smaildrct(5), smailmeth(5), smailqual(5), smailrtrs(5), smailrtry(5), smail(8). Smail Administration and Installation Guide. DARPA Internet Requests for Comments RFC 821, RFC 822, RFC 974, RFC 976, and RFC 1123.

BUGS
Colons cannot be included in the value of a list element.

Database files cannot contain ``#'' in the left-hand field.

COPYRIGHT
Copyright (C) 1987, 1988 Ronald S. Karr and Landon Curt Noll Copyright (C) 1992 Ronald S. Karr

See a file COPYING, distributed with the source code, or type smail -bc, to view distribution rights and restrictions associated with this software.