Maximum size in the number of bytes of the entire spool message containing both the transport envelope, and the actual message. That is, if the max-size is too low, and there are a lot of addresses, the message may entirely become undeliverable..

This sets system default value, and overrides commandline “-M” option.

In case the message envelope is an error envelope (MAIL FROM:<>), the don't accept more than this many separate recipient addresses for it. The default value is 3, which should be enough for most cases. (Some SPAMs claim to be error messages, and then provide a huge number of recipient addresses… Of course as spam-spewers learn, they begin just sending single recipients per message — less efficient, but working still…)

(Effective only on daemon-mode server — not on “-i”, nor “-n” modes.) Sometimes some systems set up multiple parallel connections to same host (qmail ones especially, not that ZMailer has entirely clean papers on this either — at least up to 2.99.X series), we won't accept more than this many connections from the same IP source address open in parallel.

The default value for this limit is 10.

The principal reason for this has been authors experience at nic.funet.fi, where some MS-Windows users have caused huge numbers of parallel connections to some services. So huge, that the system did in fact run out of swap due to that, and caused all manner of other nasty things to occur too… All this simply because some windows client had opened 800+ parallel sessions, and each server process consumed separate blocks of swap space… To avoid the system to succumb under such an accidental denial-of-service attack at the overall system, this parallel limit was created.

This sets setsockopt(SO_RCVBUF) value, in case the system default is not suitable for some reason.

This sets setsockopt(SO_SNDBUF) value, in case the system default is not suitable for some reason.

This relates to newer systems where the listen(2) system call can define higher limits, than the traditional/original 5. This limit tells how many nascent TCP streams we can have in SYN_RCVD state before the socket stops answering to incoming SYN packets requesting opening of a connection. Such sockets have not opened sufficiently to reach a state where bi-directional communication has been established, thus they won't appear to accept(2) yet for the server to pick them up!

There are entirely deliberate denial-of-service attacks based on flooding to some server many SYNS on which it can't send replies back (because the target machines don't have network connectivity, for example), and thus filling the back-queue of nascent sockets.

This can also happen accidentally, as the connectivity in between the client host, and the server host may have a black hole into which the SYN-ACK packets disappear, and the client thus will not be able to get the TCP startup three-way handshake completed.

Most modern systems can have this value upped to thousands to improve systems resiliency against malicious attacks, and most likely to provide complete immunity against the accidental “attack” by the failing network routing.

Do consult your system specific information on how much memory each nascent (and matured) socket will require before you commence upping this very much. You might commit heaps of unswappable memory to useless waste.

This one adds yet another string (no quotes are used) into those that are presented to the client when it asks for “HELP” in the SMTP session.

Enables “DEBUG” command in the server. This command turns on various trace functions which ruin the protocol from standards compliant client, but may help interactive debuggers.

Enables “EXPN” command in the server.

Enables “VRFY” command in the server.

This defines the database type, and file path prefix to the binary database containing policy processing information. Actual binary database file names are formed by appending type specific suffixes to the path prefix. For example NDBM database appends “.pag” and “.dir”, while BSD-Btree appends only “.db”. (And the latter has only one file, while the first has two.)

More information below, and at newdb at Section 24.3

When present, this parameter will not convert input of form <@aa,@bb:cc@dd> into source-route-less form of <cc@dd> Instead it carries the original source-route into the system as is.

Run the given argument as a shell command script.

Automatically export new or changed shell variables.

Exit on non-zero status return of any command.

Disables filename generation.

Hash and cache the location of Unix commands. The option is set by default.

This shell is interactive, meaning prompts are printed when ready for more input, SIGTERM signal is ignored, and the shell does not exit easily. This flag is automatically set if stdin and stderr are both attached to a /dev/tty.

Read commands but do not execute them.

Read commands from stdin. If there are non-option arguments to the shell, the first of these will be interpreted as a shell script to open on stdin, and the rest as arguments to the script.

Exit after running one command.

Unset variables produce an error on substitution.

Print shell input as it is read.

Print commands as they are executed.

Print code generation output onto stdout. If this option is doubled, the non-optimized code is printed out instead.

Print runtime interpreter activity onto /dev/tty.

Print lexer output onto stdout.

Optimize the compiled script. If this option is doubled, the optimized code is also printed out.

Print parser output (S/SL trace output) onto stdout.

Print I/O actions onto /dev/tty.

Print scanner output (token assembly) onto stdout.

Open /dev/tty for internal debugging use.

: <SPC> anything else forming a command pipeline

none

0

none

none

. scriptfilename

include scriptfilename

Exit status of script evaluation, or specifically:

none

This puts the running script to read more script from given filename.

[ test parameters ]

test test parameters

• File testing unary prefix functions:

  -b file

  True if file exists and is block special.

  -c file

  True if file exists and is character special.

  -d file

  True if file exists and is a directory.

  -f file

  True if file exists and is a regular file.

  -g file

  True if file exists and is set-group-id.

  -k file

  True if file has its "sticky" bit set.

  -p file

  True if file exists and is a named pipe.

  -r file

  True if file exists and is readable.

  -s file

  True if file exists and has a size greater than zero.

  -t [fd]

  True if fd is opened on a terminal. If fd is omitted, it defaults to 1 (standard output).

  -u file

  True if file exists and its set-user-id bit is set.

  -w file

  True if file exists and is writable.

  -x file

  True if file exists and is executable.

  
  
  

• String testing binary functions:

  str1 = str2

  True if the strings are equal.

  The "str1" must not begin with a hyphen "-" character! (Actually they must not be any of the magic prefix-, or infix keyword operators, nor "(", "!", or ")". )

  Suggested test setup:

  [ "x$varname" = "xliteral" ] ...

  
  
  

  str1 != str2

  True if the strings are not equal.

  The "str1" must not begin with a hyphen "-" character! (Actually they must not be any of the magic prefix-, or infix keyword operators, nor "(", "!", or ")". )

  Suggested test setup:

  [ "x$varname" != "xliteral" ] ...

  
  
  

  
  
  

• Integer value testing binary functions:

  iexpr -eq iexpr

  True if integer values are equal.

  The iexpr intermediate products are strings for the purposes of this scanners input, but then they are internally treated as system local "integer" datatype.

  The second iexpr can be a pair of: "-l string-expr" which is evaluated as length of that string-expr.

  iexpr -ne iexpr

  True if integer values are not equal.

  The second iexpr can be a pair of: "-l string-expr" which is evaluated as length of that string-expr.

  iexpr -gt iexpr

  True if integer value1 is greater than integer value2.

  The second iexpr can be a pair of: "-l string-expr" which is evaluated as length of that string-expr.

  iexpr -ge iexpr

  True if integer value1 is greater or equal than integer value2.

  The second iexpr can be a pair of: "-l string-expr" which is evaluated as length of that string-expr.

  iexpr -lt iexpr

  True if integer value1 is less than integer value2.

  The second iexpr can be a pair of: "-l string-expr" which is evaluated as length of that string-expr.

  iexpr -le iexpr

  True if integer value1 is less or equal than integer value2.

  The second iexpr can be a pair of: "-l string-expr" which is evaluated as length of that string-expr.

  
  
  

• File comparison binary functions:

  file1 -nt file2

  True if file1's mtime is newer than file2's.

  Filenames are best to be either absolute paths (begins with "/"), or dot-relative (begins with "./" pair). Unqualified names are hazardous, e.g. "-file-name-".

  file1 -ot file2

  True if file1's mtime is older than file2's. (See comment above.)

  file1 -ef file2

  True if both files have same inode, and device. (See comment above.)

  
  
  

• Logical functions:

  ! expr

  Unary NOT

  expr -a expr

  Binary AND

  expr -o expr

  Binary OR

  ( expr )

  Parenthesis

  
  
  

This is basically the shell "[" a.k.a. "test" program.

Do note that unlike more usual bourne-shells, this does not short-circuit logical evaluations, e.g. falseness of the left side of an AND does not eliminate evaluation of the right side!

Usual "test" precautions with things like parameter data prefixing with some character so that it will not become treated as one of the control options.

Not:
  [ "$(funcname ...)" ]
  [ "$varname" = "value" ]

Ok:
  [ "z$(funcname ...)" ]
  [ "z$varname" = "zvalue" ]

attributes object-reference

The property list symbol (4th) component of an address quad.

none

none

basename pathname [suffix]

If a suffix is given and matches the filename, the suffix too is stripped from the filename.

There are no "-"-type options.

Prints the base filename of the pathname.

none

none

NOT IMPLEMENTED!

builtin {builtin command name, and its params}

none

NOT IMPLEMENTED!

Ensures that named command is builtin within the scheduler, and not a) external, b) script based.

car object-reference

Pointer to copied lisp-object of object-reference's car operation.

none

This command is synonymous to the channel (at Section 21.5.12), and first (at Section 21.5.25) functions.

This version name is for die-hard LISP fans ;-)

cat filenames...

Output into stdout, which can be piped ZMailer router script internally to next receiver in a pipeline.

none

The filenames to be "cat:ed" together need to be regular files.

cd [directory]

none

none

cdr object-reference

Pointer to copied lisp-object of object-reference's cdr operation.

none

This command is synonymous to the rest function (at Section 21.5.51).

This version name is for die-hard LISP fans ;-)

channel object-reference

The channel (1st) component of an address quad.

none

The car (at Section 21.5.8), and first (at Section 21.5.25) functions are synonymous to this one.

continue

none

This affects control flow by returning it into beginning of enclosing loop construction.

Usage examples:

  while ...
  do
     if ... something ...
     then
       ... something too ...
       continue
     fi
     ... more something ...
  done

daemon

none

Starts the router running in daemon mode, scanning the $POSTOFFICE/router/ directory every few seconds for message files to process. This function is invoked automatically by other code in the router program and has no other purpose.

db add database key value
db flush database
db owner database
db print database
db remove database key
db count database
db toc

Does lookup via relation defined dblookup vector:

dblookup key [ [ -: defaultkey] -- %subst1 %subst2 ... %subst9 ]

dblookup key [ [ -: defaultkey] -- %subst2 %subst2 ... %subst9 ]

The '-:' does supply the "final case" lookup key in cases where various domain shortening lookups reach their end (and have the builtin ultimate default lookup of ".").

  relation -lm%:t $DBTYPE -f $MAILVAR/db/routes$DBEXT routesdb
   ...
  a=$(routesdb $lookupkey -: .:ERROR -- $subst1 $subst2)

With those things the "routes" database can now contain data like:

  .:ERROR  smtp!
  cust.1   smtp!%0
  cust.2   smtp!%0!%1

With "subst*" values below, results would be:

  subst1="foo1"
  subst2="foo2"

  smtp!
  smtp!foo1
  smtp!foo1!foo2

Note: The %subst things are used only if the relation definition has -% option flag set!

The access function to the database facilities in the router.

FIXME! Notes about %[0-9] substitution rules, and their controls. (That is: relation's -% option! Section 21.5.50)

A complete example of "-:" usage from p-routes.cf:

routes_neighbour (domain, address, A) {
    local tmp

    # We have Alternate default-lookup for cases of locally generated
    # ERROR MESSAGES -- for case where the dot (.) leads to error!
    # and we want to reply with DIFFERENT address, thus:  '.:ERROR' key.

    $(iserrormsg) &&
        tmp=$(routesdb "$domain" -: '.:ERROR') &&
            tmp=$(routes_spec "$tmp" "$address" $A) &&
                returns $tmp

    tmp=$(routesdb "$domain") &&
        tmp=$(routes_spec "$tmp" "$address" $A) &&
            returns $tmp

#| The routes_spec function interprets the return value from the
#| routesdb lookup.

    return 1
}

echo [-n] [-- string-expressions... ]

none

elements lisp-object

lisp-object

none

This does a side-effect on input list, which is need in "for" loops:

  for loopvar in $(elements $listvar)
  do
    ...
  done

envars

none

A debug tool to print internal variable tree.

erraddron [file]

Optional filename.

Without a filename this dissociates the possible pre-existing logging file definition.

With a filename option this specifies a filename into which the router appends all address parsing error messages. This is primarily for curious postmasters or other collectors of address trivia.

This is a debug tool; usage examples:

  erraddron $POSTOFFICE/postman/ERRADDRLOG

  erraddron

eval expression

status

none

This is the generic workhorse for self-modifying code execution within the zmsh, it creates the workhorse of following code-fragment:

# Usage: newattribute <oldattribute> <key1> <value1> [ <key2> <value2> ] ...
#
# Returns a new attribute list symbol with the <keyN> <valueN>
# attributes added to the contents of the <oldattribute> list.

newattribute (oldattribute) {
        local a null value

        a=$(gensym)
        eval $a=\$$oldattribute
        while [ "$#" != 0 ];
        do
                lreplace $a "$1" "$2"
                shift ; shift
        done
        echo -- "$a"
}

exit

does not return, does exit(2) for the shell/router..

none

Exit from the shell/router with exit code.

export [variable-name...]

none

Exports variable name(s). If no variables are given, export prints a list of which variables have been exported.

filepriv file [uid]

none

Prints the numeric user id of the least privileged account that can modify the specified file.

This is determined by an approximation that pessimistically assumes that any file or directory writable by group or others is insecure, and optimistically assumes that it is enough to check a file and its parent directory instead of all the way to the filesystem root. The reason for the latter is that if grandparent directories are insecure, the system is likely to have just as bad potential problems as can be created by using mail to run processes with forged powers (besides, doing the full check would be quite expensive).

If a second argument is given, it is the numeric user id to assume for the file. This means only the parent directory will be checked for nonwritability and for having the same (or a 0) uid.

first object-reference

Pointer to copied lisp-object of object-reference's car operation.

none

This command is synonymous to the car (at Section 21.5.8), and channel (at Section 21.5.12) commands.

gensym

none

Generates and prints a new symbol name in the sequence g0 to gN every time it is called. The sequence is reset and any symbol values destroyed after the router has processed a message. This function is used to generate new symbols, to hold attached address property lists, during alias expansion.

Code-fragment showing a way how it is used inside the router scripts:

# Usage: newattribute <oldattribute> <key1> <value1> [ <key2> <value2> ] ...
#
# Returns a new attribute list symbol with the <keyN> <valueN>
# attributes added to the contents of the <oldattribute> list.

newattribute (oldattribute) {
        local a null value

        a=$(gensym)
        eval $a=\$$oldattribute
        while [ "$#" != 0 ];
        do
                lreplace $a "$1" "$2"
                shift ; shift
        done
        echo -- "$a"
}

get property-list keyname
get property-list-varname keyname

property-list

none

Returns a property-list corresponding to key string:

  listvar=(key1 value1 keyname value key3 value3)
  result1=$(get  listvar keyname)
  result2=$(get $listvar keyname)

getopts optstring-name [arguments...]

none

Never used inside the zmsh scripts, usefullness questionable, and usage documentation missing.

grind lisp-object

Pointer to list of varcell.

none

This is a debug tool.

The side-effect is to output the text form of the lisp-object.

groupmembers groupname

none

Prints the accounts that are listed as members of a group in the system groups file, one per line. Note that accounts with the same login group id, but that are not listed in the groups file, will not appear in this list.

hash [-r] [command names]

This is a part of the "zmsh" shell-script interpreter in good SH-tradition, but is not used in the ZMailer router in any way.

homedirectory user

none

Prints the home directory of the specified user account.

host object-reference

The host (2nd) component of an address quad.

none

none

hostname [name]

none

Sets the router's idea of the system hostname. Without an argument the name is retrieved from the system and printed. The router has no preconceived notion of what the hostname is, so "Message-Id:" and "Received:' headers will only be generated if a "hostname" has been set using this function.

ifssplit any-string

split list

none

This splits given input string per IFS environment variable, and produces a list of substrings ready for further use.

lappend varname anyvalue

NULL; actually error cases output to stderr, all others are handled silently.

none

This appends content of list object (anyvalue) to named varname variable:

#
# From  aliases.cf  of system standard scripts.
#

maprrouter (attribute, localpart, origaddr, plustail, domain) {
    local shh al

    al=()
    while read address
    do
        case "$address" in
        ") shh=(((error expansion "$localpart")))
            lappend al $shh
            continue
            ;;
        esac

        defer="
        shh=$(rrouter "$address" "$origaddr" $attribute \
             "$plustail" "$domain")
        [ -n "$defer" ] &&
            shh=(((hold "$defer" "$address" $attribute)))
        defer="
        lappend al $shh
    done
    returns $al
}

last lisp-object

Return a pointer to last cell of varcell's list.

none

This is actually a unused relict from way way back..

length lisp-object

String of decimal numbers representing the number of varcell's in the lisp-object primary chain.

none

This counts the number of elements in the chain, not length of any string.

list objects...

List-wrapped lisp-object.

none

listaddresses [-e error-address] [-E errors-to-address] [-c comment]

The stdin feeds in the list of addresses.

Filters an RFC822 address list on standard input to produce one normal form (no non-address tokens) address per line on its output. This function can be used to parse the alias file or .forward files or similar.

listexpand [-c comment] [-e error-address] [-E errors-to-address] [-p privilege-integer] [-N notary-string] $attribute $localpart $origaddr [$plustail [$domain]]

lisp-list (or NULL)

This implements the most common pipeline where listaddresses (at Section 21.5.40) was used with more efficient memory consumption handling. (System memory usage internals have changed over the time, and now this is no longer especially great memory expenditure saver.)

The stdin will feed addresses from a file for parsing, and parameter mapping + routing.

Comparison of previous listaddresses (at Section 21.5.40) -script implemented code, and new one using the listexpand:

Old:

    l="$preowner$(basename "$lcuser" -mod)$postowner"
    nattr=$(newattribute $attr privilege $priv sender "$l")
    $(zapDSNnotify $nattr delivered "$sender" "$lcuser$domain")
    a=$(runas $priv cat "$a" | \
        listaddresses       -E "$l$domain"          \
                            -e "$l"                 \
                            -c "$a file expansion" |
        maprrouter $nattr "$a" "$host" "$plustail"  \
                    "$domain")
    postzapDSNnotify a
    returns $a

New:

    l="$preowner$(basename "$lcuser" -mod)$postowner"
    if priv=$(getpriv "664" $priv "$a" maillist) &&
       nattr=$(newattribute $attr privilege $priv sender "$l") ; then
        $(zapDSNnotify $nattr delivered "$sender" "$lcuser$domain")
        a=$(runas $priv cat "$a" | \
            listexpand      -E "$l" -e "$l" -p $priv        \
                            -c "$a file expansion"          \
                            $nattr  "$a" "$host" "" "$domain" )
        postzapDSNnotify a
        returns $a
    fi

login2uid username

none

Prints the uid associated with the specified account name, if any. A side-effect is to add the GECOS name field of the account to the fullname in-core database, to add the login name to uid mapping to the pwnam in-core database, and to add the uid to login name mapping to the pwuid in-core database.

lreplace varname indexnum anyvalue

lreplace varname fieldname anyvalue

none

none

This replaces designated field on varname variable containing list-like data with anyvalue value.

The field designation can be given in numeric form, where the field index can be numeric (first field is zero), or keyname on key/value pair list.

If a key is not found (with key/value pairs), then designated pair is added to the list.

  z$ tt=(aa 11 bb 22 cc 33 dd 44)
  z$ grind $tt
  (aa 11 bb 22 cc 33 dd 44)
  z$ lreplace tt bb zz
  z$ grind $tt
  (aa 11 bb zz cc 33 dd 44)
  z$ lreplace tt 0 aaa
  z$ grind $tt
  (aaa 11 bb 22 cc 33 dd 44)
  z$ lreplace tt zz aa
  z$ grind $tt
  (aaa 11 bb 22 cc 33 dd 44 zz aa)

This is an example of "lreplace" use in the scripts:

# Usage: newattribute <oldattribute> <key1> <value1> [ <key2> <value2> ] ...
#
# Returns a new attribute list symbol with the <keyN> <valueN>
# attributes added to the contents of the <oldattribute> list.

newattribute (oldattribute) {
        local a null value

        a=$(gensym)
        eval $a=\$$oldattribute
        while [ "$#" != 0 ];
        do
                lreplace $a "$1" "$2"
                shift ; shift
        done
        echo -- "$a"
}

A fragment of code from inside the crossbar.cf shows different usages:

....
    usenet)
        lreplace from 2 "$(uucproute "$(user $from)")"
        tsift $(user $from) in
        $hostname!.*    ;;
        .*    
            lreplace from 2 $hostname!$(user $from)
            ;;
        tfist
        # newsgroup name only
        lreplace to 2 "$(localpart "$(user $to)")"
        ;;
....

none

none

ZMSH Debugging thing.

printaliases [-v] [-o indexoutputfile] file

process messagefile

none

The protocol switch function. It is called by the "daemon" function (at Section 21.5.14) to process a message found in the $POSTOFFICE/router/ directory.

This function will in turn call an internal protocol-specific function which knows the syntax and semantics of the message file. The current version knows about messages submitted using the MSG_RFC822 parameter to mail_open(3). For that case, the protocol function is called "rfc822".

router has a bit more complex directory semantics, than is stated above. See "zmailer(3)" for details.

Although the "process" function is provided built in, it is usually overridden by a defined function in the router configuration file. (See process.cf, and the entrypoint text at Section 21.4.1)

read variable...

none

The read will get one line of input, and if there are more than one variable name parameter, split it at the whitespaces (IFS chars).

There appears to be a bug when there are less IFS separated sequences than there are varnames: The extra varnames do get things at a bit random.. (2001-Oct-15)

If input line is zero length (or all IFS chars), the read will read another input line.

If the input line ends with character: "\" as its very last, the line gets a catenation of next input line effectively unfolding multiline coded string.

z# echo "1 2 3 4 5" | read v1 v2
z# echo $?
0
z# echo $v1
1
z# echo $v2
2 3 4 5
z# echo "11111" | read v1 v2
z# echo $?
0
z# echo $v1
11111
z# echo $v2
11111

recase [-u | -l | -p] -- string

A case-mapping function that prints the parameter string in either all-uppercase, all-lowercase, or capitalized (pretty).

The input to be converted is expected to be single string, e.g. not multiple strings.

Due to internal use of "getopt" for parameter pickup, if there is even the slightest change that the string begins with a hyphen (minus) character, invocation must use the -- pair to end the options, and to protect the parameter.

Typical use in the router scripts:

   lcuser="$(recase -l -- "$user")"

recipient

none

A boolean function that returns the value of the statement "executing a header rewriting function and the address is a recipient address in a message header".

Generic:

relation [-i] [-T] -t dbtype [/subtype] [-f file] [-e #] [-s #] [-:%blmnu] [-d driver] [-C configfile] name

More specific versions:

relation -t yp,yp-mapname -f yp-domain [-e #] [-s #] [-:%blmnu] [-d driver] name
relation -t bind/query-type [-f file] [-e #] [-s #] [-:%blmnu] [-d driver] name
relation -i -t ordered,filepath2 -f filepath1 [-e #] [-s #] [-:%blmnu] [-d driver] name
relation -i -t unordered,filepath2 -f filepath1 [-e #] [-s #] [-:%blmnu] [-d driver] name
relation -t ordered -f filepath [-e #] [-s #] [-:%blmnu] [-d driver] name
relation -t unordered -f filepath [-e #] [-s #] [-:%blmnu] [-d driver] name
relation -t dbtype [-f file] [-e #] [-s #] [-:%blmnu] [-d driver] name

Special support for testing of presence of support for given dbtype:

relation -T -t dbtype dummy_name

Options are listed below. name is the name of the relation that is wanted to be created. Examples:

relation -t bind,mx mxhost
relation -t ordered -f $MAILVAR/db/routes routes
relation -t ordered -b -f /usr/lib/news/active.sorted newsgroups

On systems with USE_MMAP the ordered, and unordered databases are r/o mapped into memory, and for ordered case, a special line-index is generated for speeding up the binary search. (Makes less system calls that way.)

rest object-reference

Pointer to copied lisp-object of object-reference's cdr operation.

none

This command is synonymous to the cdr command (at Section 21.5.11).

return lisp-object

none

The system has a weird dichtomy on returning numeric vs. other results.

Presume a function call with two different possible results, failure indication, and successfull (arbitrary) string result:

  tmp=$(funcnnn args..) && returns $tmp
  return $tmp  # error code return!

returns lisp-object

none

See notes of "return" above.

rfc822 messagefile

status

none

This function controls the parsing and processing of the message file in RFC822/976/2822 format. It is called by the process function (at Section 21.5.46). .

rfc822date

none

Prints the current time in RFC822/2822 format.

rfc822syntax address

none

This is a simple interface to the address parser. If the command line argument is a syntactically valid RFC822/976/2822 address, this command is silent and returns 0 as status. If there is a parse error, a verbose error message is printed to stdout and the function yields a non-zero return status.

runas user function [arguments...]

Any of the values yielded by the executed "function", or:

none

Changes the current effective user id of the router process to that given (which may be numeric or an account name), then runs the specified function with the specified arguments, then switches the effective user id of the process back (to root).

sender

none

A boolean function that returns the value of the statement "executing a header rewriting function and the address is a sender address in a message header".

set [-a | -e | -f | -h | -n | -t | -u | -v | -x | -L | -C | -P | -S | -k] [-] [variable]

Pointer to copied structure of car operation.

none

shift [number]

none

Modifies caller's argument vector by shifting left one (or specified number) of argument(s) in current ARGV.

sleep number

none

Does not tell if the sleep has been interrupted somehow.

squirrel [-]event

Sets the kinds of events that cause a message to be copied into the $POSTOFFICE/postman/ directory. Whether or not a "-" is necessary for an event depends on the current state of the event's flag.

The usage message will indicate what to do to toggle the event flag:

z# squirrel
Usage: squirrel [ breakin | -badheader | illheader | nochannel | nosender ]

stability [on | off]

none

Determines whether the router will process incoming messages in arrival order (when on), or in random order determined by position in the router directory. The router will by default do the first queue scan in stable mode, and subsequent scans in unstable mode. The name of this command is the name for a similar characteristic of sorting algorithms.

times

none

Prints to stdout the spent usermode time for process itself, and to all of its children.

Sample output:

    12m33s  22m59s

trace key1 ... keyN
untrace key1 ... keyN

Authors most common "trace" incantation has been wrapped into standard script routine:

#|
#|  I kept typing in this trace command so frequently, that eventually
#|  I just had to make for it into a single command... /Matti Aarnio
#|

rtrace () {
        trace all except rfc822 regexp
}

trap [ [script trap_nro] ...]

none

If no parameters are given, trap prints all known traps.

In all aspects this is quite alike any bourne-shell "trap" function.

Set, and unset a trap:

  trap "db flush aliasesdb ; log flushed aliases" 16
  trap "" 16

type [command...]

none

uid2login uid

none

Prints the first account name associated with a specified numeric user id, if any, or "uid#uid" if no account exists with that user id. It has the same side-effects as the login2uid function (at Section 21.5.42).

umask [octal-number-mask]

none

Without parameters the new default mask is 077, and old is printed.

unset [variable...]

none

This throws away named variables from all variable scopes.

z# echo $TERM
xterm
z# unset TERM
z# echo "'$TERM'"
''

trace key1 ... keyN
untrace key1 ... keyN

See the trace function (at Section 21.5.66) for valid keywords.

See the trace function (at Section 21.5.66) for valid keywords.

user object-reference

The next-address (3rd) component of and address quad.

none

This is essentially same as:

   $(cdr $(cdr $(cdr $addrquad)))

wait [pid]

Besides of the return codes of processes being waited, this can yield:

none

none

Default is to randomize the order of tasks at the queue, when it is started, with this the order is that of the original spool-file MTIME. Oldest first.

is a keyword (with no associated value) that tells the scheduler that the transport agent specified in the command will only process destination addresses that match the first destination channel it encounters. This is automatically set when the string “$channel” occurs in the command, but may also be specified manually by this keyword. This is rarely used.

is the command line used to start a transport agent to process the address. The program pathname is specified relative to the $MAILBIN/ta/ directory.

The string “$channel” is replaced by the current matched channel, and “$host” replaced by the current matched host, from the destination address.

It is strongly recommended that the “$host” is not to be used on a command definition, as it limits the re-usability of idled transporter.

It is possible to place environment-string setting statements into the beginning of the line:

  command="MALLOC_DEBUG_=1 OTHER=var cmdname cmdparams"

specifies the maximum age of an address in the scheduler queue before a repeatedly deferred address is bounced with an expiration error. The actual report is produced when all addresses have been processed.

is the group id of a transport agent processing the address. The value is either numeric (a gid) or a group name.

When a transport agent runs out of jobs, they are moved to idle pool, and if a TA spends more than idlemax time in there, it is terminated.

specifies the primary retry interval, which determines how frequently a transport agent should be scheduled for an address. The value is a delta time specification. This value, and the retries=… value mentioned below, are combined to determine the interval between each retry attempt.

if retrying an address would cause the number of simultaneously active transport agents processing mail for the same channel to exceed the specified value, the retry is postponed. The check is repeated frequently so the address may be retried as soon as possible after the scheduled retry interval. If the value is 0, a value of 1000 is used instead.

Recipients are groupped into threads, and similar threads are groupped into thread-rings, where same transport agent can be switched over from one recipient to another. This defines how many transport agents can be running at any time at the ring.

if retrying an address would cause the number of simultaneously active transport agents to exceed the specified value, the retry is postponed. The check is repeated frequently so the address may be retried as soon as possible after the scheduled retry interval. If the value is 0, a value of 1000[1] is used instead.

This limits the number of parallel transport agents within each thread; that is, using higher value than default “1”

Defines relative priority value for transport-agent process. Default is not to use this. Value range in between -40 to 40.

Max number of tasks to feed from the thread to the transporter agent when feeding jobs to it. The scheduler main-loop at the mux() is a bit sluggish, thus with this we can keep the transporters busy.

The default is defined at the */* clause.

Defines absolute priority value for transport-agent process. Default is not to use this. Value range in between -20 to 20.

a clause with queueonly flag does not auto-start at the arrival of a message, instead it must be started by means of smtpserver(8) command ETRN through an SMTP connection.

To have message expiration working, following additional entries are suggested:

  interval=1h
  retries="24"

Placeholder for DELAYED reporting mechanism.

specifies the retry interval policy of the scheduler for an address. The value must be a sequence of positive integers, these being multiples of the primary interval before a retry is scheduled. The scheduler starts by going through the sequence as an address is repeatedly deferred. When the end of the sequence is reached, the scheduler will jump into the sequence at a random spot and continue towards the end. This allows various retry strategies to be specified easily:

• brute force (or "jackhammer"):

  retries=0

  
  
  

• constant primary interval:

  retries=1

  
  
  

• instant backoff:

  retries="1 50 50 50 50 50 50 50 50 50 50 50 50"

  
  
  

• slow increasing (fibonacci) sequence:

  retries="1 1 2 3 5 8 13 21 34"

  
  
  

• s-curve sequence:

  retries="1 1 2 3 5 10 20 25 28 29 30"

  
  
  

• exponential sequence:

  retries="1 2 4 8 16 32 64 128 256"

  
  
  

• etc.

Leftover of earlier scheduler internal algorithms, does not make sense anymore.

Can be used (if desired) at the */* clause to set relative niceness for the scheduler process, and all of its children.

Can be used (if desired) at the */* clause to set absolute priority for the scheduler process, and all of its children.

is the user id of a transport agent processing the address. The value is either numeric (a uid) or an account name.

Start only one instance of handling processes, never mind what other settings say.

will activate BSMTP-type wrapping with a “hidden-dot” algorithm; e.g. quite ordinary SMTP stream, but in “batch mode”.

The first “B” turns on similar BSMTP wrapping as “b”, but adds SIZE and, if the sm is started with option “-8”, also 8BITMIME options. The second “B” adds there also DSN (Delivery Status Notification) parameters.

will prepend “>” to any message body line starting with “From ”. (Read: “From-space”)

adds “-f sender” arguments to the delivery program.

will not prepend a “From ”-line (normal mailbox separator line) to the message.

adds “-r sender” arguments to the delivery program.

will run the delivery program with the same real and effective uid as the sm process. If this flag is not set, the delivery program will be run with the real uid of the sm process. This may be useful if sm is setuid.

informs sm that each instance of the delivery program can deliver to many destinations. This affects $u expansion in the argument list, see below.

prepends a “Return-Path:” header to the message.

will prepend a “From ”-line, with a “remote from myuucpname” at the end, to the message. This is what is expected by remote rmail(1) programs for incoming UUCP mail.

use CRLF sequence as end-of-line sequence. Without it, will use LF-only end-of-line sequence.

does SMTP-like “hidden-dot” algorithm of doubling all dots that are at the start of the line.

will strip (set to 0) the 8th bit of every character in the message.

which is replaced by the sender address.

which is replaced by the destination host.

which is replaced by the recipient address. If the “m” mailer flag is set and there are several recipients for this message, the argument containing the “$u” will be replicated as necessary for each recipient.