Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/1/1583

Internet Message Format | 1990-12-28 | 25.9 KB

From: [e-mail] (Dave Mack)
Newsgroups: alt.sources
Subject: Anonymous Contact Service software v1.1, Part04/08
Message-ID: <[e-mail]>
Date: 15 Jul 90 17:08:02 GMT

This is the second distribution of the Anonymous Contact Service
software. The distribution consists of 8 shar files. This will
(hopefully) be the last full distribution of the system - all
future versions will be distributed as patches. The patchlevel of
this version is 1.

The ACS software provides a mechanism for posting anonymous articles,
for receiving replies to those articles which are also anonymous, and
permits prolonged anonymous conversations in which neither writer knows
the other's actual e-mail address.

This software is currently being used to provide an anonymous personals
service in alt.personals.

Dave Mack
[e-mail]

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 4 (of 8)."
# Contents:  mailer/Read.Me mailer/resolve.c mailer/template.cf
# Wrapped by csu@alembic on Sun Jul 15 12:46:48 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'mailer/Read.Me' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'mailer/Read.Me'\"
else
echo shar: Extracting \"'mailer/Read.Me'\" \(6735 characters\)
sed "s/^X//" >'mailer/Read.Me' <<'END_OF_FILE'
X        Read.Me - Updated 9/15/87
X
XWhat smail does:
X
X  smail is capable of handling UUCP syntax (bang paths, bang
X  domains, and at domains are supported) mail transportation
X  over UUCP/uux/rmail channels.  It will support machines that
X  only have UUCP connections, and machines with UUCP links to
X  the outside world plus a small number of local machines that
X  are reached via SMTP.  The domain intelligence is embedded
X  in the smail database (e.g. the pathalias output), not the
X  sendmail.cf file, so if you have a fancier domain structure
X  that involves SMTP or anything other than uux in the domain
X  structure, you'll want to modify the sendmail.cf file here or
X  merge pieces of the enclosed sendmail.cf into your own.
X
X  smail runs under 4.2BSD and System V, as a back end to sendmail;
X  and under System V without sendmail.  It also replaces rmail, which
X  becomes a link to smail.  In a sendmail environment, smail depends on
X  sendmail to crack the headers, as smail just deals with the envelope.
X  smail makes your host capable of using the INTERNET definition in the
X  Usenet software.
X
X  Features of smail include:
X
X  (1) Using pathalias data to choose the best route to your destination.
X  (2) Handling of user@domain, domain!user, and host!user syntax.
X  (3) Generation of domain!user syntax to be forwarded by other systems.
X  (4) Logging of traffic through your machine, by sender, recipient, and
X      size of message, so you can, track use and detect abuse of your
X      machine.
X  (5) Mail being forwarded through your machine to another uux link is
X      passed from rmail directly to uux, so there's less overhead on
X      your machine (sendmail stays out of the loop.)
X  (6) Sendmail-like alias capability for hosts without sendmail.
X  (7) Generation of RFC822 required headers for locally generated mail.
X  (8) Robust delivery scheme that reroutes only if stated path is inaccessible.
X  (8) Mail that is undeliverable is returned to sender.
X  (9) Simplicity.
X
XPrerequisites:
X
X  A copy of a recent posting of pathalias.  (The one posted
X  by Peter Honeyman in January 1986 is recommended.)
X
X  A current copy of the UUCP map, or at least a copy of the
X  appropriate part of it that you're interested in.
X
X  A properly registered domain name for your organization, such
X  as ATT.COM.  (It is possible to run smail using a domain name
X  under .UUCP, but since this can't be officially registered,
X  it is appropriate only for testing.)
X
X  You can get pathalias from the mod.sources Usenet archive
X  (contact [e-mail] or uunet!sources-request)
X
X  You can get a UUCP map each month from Usenet newsgroup mod.map.
X  The UUCP map is quite large (currently about 2MB) so please don't ask
X  to have a copy mailed to you - get a copy from a nearby Usenet site.
X
X  You can get a domain name by joining the UUCP Zone.  There are
X  low membership dues for this, and a registration process that
X  will take 2-8 weeks.  This Read.Me file may be out of date by
X  the time you read it, so we ask you to contact us for current
X  dues rates and procedures.  Contact [e-mail] or
X  cbosgd!stargate!uucp-query and ask for the UUCP Zone information
X  packet.  (If you already belong to a network such as CSNET, DDN,
X  or BITNET, your organization may already have a domain name.  If
X  you are also on UUCP, it is recommended that you also join the
X  UUCP Zone at the lower rate for organizations whose primary
X  affiliation is with another network.  See the file "Registry"
X  for more information.
X
XOverall structure:
X
X  smail is installed in /bin/smail with a link in /bin/rmail.  Uuxqt
X  calls rmail, which either forwards the message on to the next hop
X  directly or, on a sysetm with sendmail, calls sendmail.  sendmail
X  may decide the message should be delivered by UUCP, and invoke smail,
X  which will look up a route and invoke uux.  (Note that the choice
X  about when to invoke sendmail and when to process a message directly
X  can be configured in smail.)
X
X  smail uses a database which is generated from pathalias.  You take the
X  current UUCP map, add some local information and topology data (to tell
X  it about the domain tree) and run pathalias.  The result is sorted and
X  installed in /usr/lib/uucp/paths.  There is no hashing done on this
X  file - when smail looks up a name it uses a binary search.
X
XConfiguration considerations:
X
X  You'll note two configuration options in defs.h: HANDLE and ROUTING.
X  These control which sorts of addresses smail/rmail will handle, and
X  which type of routing they will do.  The HANDLE define only affects
X  rmail, since smail sets it implicitly.  In any case, we recommend
X  that you leave HANDLE alone, unless you are making major changes.
X
X  ROUTING has three choices: JUSTDOMAIN, ALWAYS, and REROUTE.  rmail
X  will run as JUSTDOMAIN, the defs.h default.  This means rmail will
X  only apply routing if it sees "rmail user@domain", and will just call
X  uux if it sees "rmail host!user".  (If the uux fails, it will call
X  smail -r, which will apply ALWAYS routing to try to get the mail
X  there anyway.  If the ALWAYS routing fails, then REROUTE routing is
X  applied.  This has the advantage of being low overhead on your
X  system, not second guessing a route someone else asked for, and still
X  recovering nicely from the mistakes of another system.  Your host
X  becomes a "smart host" that can get mail anywhere.)
X
X  Many people will note huge paths going through their machine.  These
X  paths are generated by replies to netnews messages, and tend to be 10
X  or 20 hops long - far longer than necessary.  If you are a bit aggressive,
X  you can change -r to -R, which will cause such failed mail to be rerouted,
X  thus, mail to a!b!c!d!e!f!g!user will look up a route to g, and send the
X  mail to route!g!user.  (If it can't find g, it will try f, then e, and
X  so on until it finds someone it recognizes.)  If you are REALLY aggressive,
X  you can change ROUTING to REROUTE in defs.h, to get the same effect for
X  ALL rmail being passed through your machine.  This may help cut phone
X  bills, but it has some disadvantages.  It can lengthen a path sometimes,
X  e.g. mail to tektronix!user might turn into ihnp4!tektronix!user if your
X  routing database says mail to tektronix goes through ihnp4.  It makes it
X  hard to route around a dead host, or to redirect traffic from a mailing
X  list to several different directions.  It may also make mail go a different
X  path than what your user thought it was, and it affects other hosts that
X  route mail through you if you set ROUTING to REROUTE in defs.h.  So only
X  do this if you know what you are doing, and are willing to live with the
X  disadvantages.
X
X#
X#@(#)Read.Me    2.5 (smail) 9/15/87
X#
END_OF_FILE
if test 6735 -ne `wc -c <'mailer/Read.Me'`; then
    echo shar: \"'mailer/Read.Me'\" unpacked with wrong size!
fi
# end of 'mailer/Read.Me'
fi
if test -f 'mailer/resolve.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'mailer/resolve.c'\"
else
echo shar: Extracting \"'mailer/resolve.c'\" \(7634 characters\)
sed "s/^X//" >'mailer/resolve.c' <<'END_OF_FILE'
X/*
X**
X**  Resolve.c
X**
X**  Routes then resolves addresses into UUCP or LOCAL.
X**
X*/
X#ifndef lint
Xstatic char     *sccsid="@(#)resolve.c    2.5 (smail) 9/15/87";
X#endif
X
X#include    <ctype.h>
X#include    <stdio.h>
X#include    "defs.h"
X
Xextern int exitstat;        /* set if address doesn't resolve     */
Xextern enum ehandle handle;    /* what mail we can handle        */
Xextern enum edebug debug;    /* verbose and debug modes        */
Xextern enum erouting routing;    /* when to route addresses        */
Xextern char hostdomain[];    /* */
Xextern char hostname[];        /* */
Xextern char *pathfile;        /* location of path database        */
Xextern int getcost;        /* get path cost even if not routing    */
X
Xchar *sform();
X
X/*
X**
X**  rsvp(): how to resolve addresses.
X**
X**  After parsing an address into <form>, the resolved form will be
X**  rsvp( form ).  If == ROUTE, we route the parsed address and parse again.
X**
X*/
X
X# define rsvp(a) table[(int)a][(int)handle]
X
Xenum eform table[5][3] = {
X/*    all        justuucp    none */
X{    ERROR,         ERROR,         ERROR },     /* error */
X{    LOCAL,         LOCAL,         LOCAL },     /* local */
X{    ROUTE,         LOCAL,         LOCAL },     /* domain */
X{    UUCP,         UUCP,         LOCAL },     /* uucp */
X{    ERROR,         ERROR,         ERROR }};    /* route */
X
X/*
X**
X**  resolve(): resolve addresses to <host, user, form>.
X**
X**  This is a gnarly piece of code, but it does it all.  Each section
X**  is documented.
X**
X*/
X
Xenum eform
Xresolve( address, domain, user , cost)
Xchar *address;                /* the input address     */
Xchar *domain;                /* the returned domain     */
Xchar *user;                /* the returned user     */
Xint *cost;                /* the returned cost     */
X{
X    enum eform form;        /* the returned form    */
X    enum eform parse();        /* to crack addresses    */
X    int parts;            /* to ssplit addresses    */
X    char *partv[MAXPATH];        /* "  "      "        */
X    char temp[SMLBUF];        /* "  "      "        */
X    int i;
X
X
X/*
X**  If we set REROUTE and are prepared to deliver UUCP mail, we split the
X**  address apart at !'s and try to resolve successively larger righthand
X**  substrings until we succeed.  Otherwise, we just resolve the whole thing
X**  once.
X*/
X    if ((routing == REROUTE) && (rsvp( UUCP ) == UUCP)) {
X        parts = ssplit( address, '!', partv );
X    } else {
X        parts = 1;
X        partv[0] = address;
X    }
X/*
X**  This for(i) loop selects successively larger
X**  righthand substrings of the address.
X*/
X    for( i = parts - 1; i >= 0; i-- ) {
X/*
X**  Parse the address.
X*/
X        (void) strcpy( temp, partv[i] );
X        form = parse( temp, domain, user );
X
XDEBUG("resolve: parse address '%s' = '%s' @ '%s' (%s)\n",
X    temp,user,domain,sform(form));
X
X/*
X**  If we are looking at a substring (that's not the entire string)
X**  which parses to a LOCAL address, we skip to the next larger substring.
X*/
X        if((i != 0) && (form == LOCAL))
X            continue;
X/*
X**  Routing, when required, is the next step.
X**  We route the address if we have a ROUTE form
X**  or if we have a UUCP form and we are told to
X**  route ALWAYS or REROUTE (i.e., routing != JUSTDOMAIN)
X*/
X        if((rsvp( form ) == ROUTE)
X         ||((rsvp( form ) == UUCP) && (routing != JUSTDOMAIN ))) {
X
X            int look_smart = 0;
X
X            if((routing == REROUTE) && (i == 0)) {
X                look_smart = 1; /* last chance */
X            }
X
X            /* route() puts the new route in 'temp' */
X            if(route(domain,user,look_smart,temp,cost) != EX_OK) {
X                continue;    /* If routing fails, try
X                        /* next larger substring.
X                        /* */
X            }
X/*
X**  After routing, reparse the new route into domain and user.
X*/
X            form = parse( temp, domain, user );
X
XDEBUG("resolve: parse route '%s' = '%s' @ '%s' (%s)\n",
X    temp,user,domain,sform(form));
X
X        } else if((getcost) && (rsvp(form) == UUCP)) {
X            /* get the cost of the route
X            ** even if we're not going route the mail.
X            ** this allows smart decisions about using
X            ** the -r flag to uux when we're not routing.
X            */
X            char junk[SMLBUF];
X            if(route(domain,user,0,junk,cost) != EX_OK) {
X                continue;    /* If routing fails, try
X                        /* next larger substring.
X                        /* */
X            }
X        }
X        break;    /* route is resolved */
X    }
X/*
X**  For LOCAL mail in non-local format, we rewrite the full address into
X**  <user> and leave <domain> blank.
X*/
X    if ((rsvp( form ) == LOCAL) && (form != LOCAL )) {
X        build( domain, user, form, temp );
X        (void) strcpy( user, temp );
X        (void) strcpy( domain, "" );
X        form = LOCAL;
X    }
X/*
X**  If we were supposed to route an address but failed (form == ERROR),
X**  or after routing we are left with an address that still needs to
X**  be routed (rsvp( form ) == ROUTE), complain.
X*/
X    if ((form == ERROR) || (rsvp( form ) == ROUTE )) {
X        exitstat = EX_NOHOST;
X        ADVISE("resolve failed '%s' = '%s' @ '%s' (%s)\n",
X            address, user, domain, sform(form));
X        form = ERROR;
X    } else {
X        ADVISE("resolve '%s' = '%s' @ '%s' (%s)\n",
X            address, user, domain, sform(form));
X    }
X    return ( form );
X}
X
X/*
X**
X**  route(): route domain, plug in user.
X**
X**  Less complicated than it looks.  Each section is documented.
X**
X*/
X
Xroute(domain, user, look_smart, result, cost)
Xchar *domain;            /* domain or host name     */
Xchar *user;            /* user name         */
Xint look_smart;            /* do we try to route through a smarter host? */
Xchar *result;            /* output route     */
Xint *cost;            /* cost of output route */
X{
X    int    uucpdom = 0;
X    int    domains, step;            /* to split domain    */
X    char    *domainv[MAXDOMS];        /* "  "     "        */
X    char    temp[SMLBUF], path[SMLBUF];
X
X/*
X**  Fully qualify the domain, and then strip the last (top level domain)
X**  component off, so that we look it up separately.
X*/
X    temp[0] = '.';
X    (void) strcpy(temp+1, domain );
X
X    domains = ssplit( temp+1, '.', domainv );
X
X/*
X** check target domain for the local host name and host domain.
X** if it matches, then skip the lookup in the database.
X** this prevents mail loops for cases where SMARTHOST is defined
X** in the routing table, but the local host is not.  It also is
X** a little faster when the local host is the target domain.
X*/
X    if((strcmpic(domain, hostname) == 0)
X    || (strcmpic(domain, hostdomain) == 0)) {
X        step = 0;
X        *cost = 0;
X        (void) strcpy(path, "%s");
XDEBUG("route: '%s' is local\n", domain);
X        goto route_complete;
X    }
X
X    /* If the domain ends in .UUCP, trim that off. */
X    if((domains > 0) && isuucp(domainv[domains-1])) {
X        domains--;
X        domainv[domains][-1] = '\0';
X        uucpdom = 1;
X    }
X/*
X**  Try to get the path for successive components of the domain.
X**  Example for osgd.cb.att.uucp:
X**    osgd.cb.att
X**    cb.att
X**    att
X**    uucp ( remember stripping top level? )
X**    SMARTHOST
X**  Returns with error if we find no path.
X*/
X    for(step = 0; (step < domains); step++) {
X        if((getpath(domainv[step]-1, path, cost) == EX_OK) /* w/ dot */
X        || (getpath(domainv[step]  , path, cost) == EX_OK))/* no dot */
X            break;
X    }
X
X    if(step == domains) {
X    /*
X    ** we've looked at each component of the domain without success
X    */
X        /*
X        ** If domain is a UUCP address, look for a UUCP gateway.
X        */
X        if((uucpdom == 0) || (getpath(".UUCP", path, cost) != EX_OK)) {
X            /*
X            ** The domain not is a UUCP address, or we can't
X            ** find a UUCP gateway.  If this is our last chance,
X            ** look for a smarter host to deliver the mail.
X            */
X            if((look_smart == 0)
X            || (getpath(SMARTHOST, path, cost) != EX_OK)) {
X                /*
X                ** All our efforts have been in vain.
X                ** Tell them the bad news.
X                */
X                DEBUG("route '%s' failed\n", domain);
X                return( EX_NOHOST );
X            }
X        }
X    }
X
Xroute_complete:
X
XDEBUG("route:  '%s' (%s) = '%s' (%d)\n", domain, domainv[step]?domainv[step]:"NULL", path, *cost);
X
X/*
X**  If we matched on the entire domain name, this address is fully resolved,
X**  and we plug <user> into it.  If we matched on only part of the domain
X**  name, we plug <domain>!<user> in.
X*/
X    build(domain, user, (step == 0) ? LOCAL : UUCP, temp);
X    (void) sprintf(result, path, temp);
X    return( EX_OK );
X}
END_OF_FILE
if test 7634 -ne `wc -c <'mailer/resolve.c'`; then
    echo shar: \"'mailer/resolve.c'\" unpacked with wrong size!
fi
# end of 'mailer/resolve.c'
fi
if test -f 'mailer/template.cf' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'mailer/template.cf'\"
else
echo shar: Extracting \"'mailer/template.cf'\" \(8435 characters\)
sed "s/^X//" >'mailer/template.cf' <<'END_OF_FILE'
X############################################################
X#
X#    SENDMAIL CONFIGURATION FILE
X#
X#    supports internet style addressing
X#    over UUCP and ethernet links.
X#
X#    A product of the UUCP Project.
X#
X#    @(#)template.cf    2.5 (smail) 9/15/87
X#
X############################################################
X
X
X############################################################
X#
X#  Local configuration options - HINTS
X#
X# Host name and domain name macros.
X#
X#    Dw sets $w
X#    DD sets $D
X#    CD sets $=D
X#
X# $D and $=D list all domains in which this host sits.
X# $D goes into outbound addresses, i.e. "user@$w.$D".
X# $A is another domain for which this host is 'authoritative'
X# it will will be turned into $D.
X
XCF_HOST
XCF_DOMAIN
XCF_AUTHORITY
XCF_DCLASS
X
X# Preemptive ether connections.  We prefer these connections
X# over both designated transport mechanisms and the general depository.
X# You can add more classes (here and in S0).
X
X# /etc/hosts.smtp might be a link to /etc/hosts
X#
XCF_SMTP
X
X# Mock top-level domain names.  These name designate a transport mechanism
X# and appear internally only, set in S3, used in S0, and removed in S4 and
X# (possibly) the ruleset for the particular mailer.
X
XCTETHER UUX
X
X# Relay host.  Used at the end of S0 as the general depository for
X# addresses which didn't resolve locally.
X
XDRrelay
X
X#
X#  End Local configuration options
X#
X############################################################
X
X############################################################
X#
X#    General configuration information
X#
X############################################################
X
XDVsmail2.5/CF_DATE
X
X##########################
X#     Special macros     #
X##########################
X
X# official hostname
XDj$w.$D
X# my name
XDnMAILER-DAEMON
X# UNIX header format
XDlFrom $g  $d
X# delimiter (operator) characters
XDo.:%@!^=/[]
X# format of a total name
XDq$g$?x ($x)$.
X# SMTP login message
XDe$j Sendmail $v/$V ready at $b
X
X
X###################
X#     Options     #
X###################
X
X# location of alias file
XOA/usr/lib/aliases
X# default delivery mode (deliver in background)
XOdbackground
X# (don't) connect to "expensive" mailers
X#Oc
X# temporary file mode
XOF0644
X# default GID
XOg1
X# location of help file
XOH/usr/lib/sendmail.hf
X# log level
XOL9
X# default messages to old style
XOo
X# queue directory
XOQ/usr/spool/mqueue
X# read timeout -- violates protocols
XOr2h
X# status file
XOS/usr/lib/sendmail.st
X# queue up everything before starting transmission
XOs
X# default timeout interval
XOT3d
X# time zone names (V6 only)
XOtPST,PDT
X# default UID
XOu1
X# wizard's password
XOWvoidpasswords
X
X###############################
X#     Message precedences     #
X###############################
X
XPfirst-class=0
XPspecial-delivery=100
XPjunk=-100
X
X#########################
X#     Trusted users     #
X#########################
X
XTroot
XTdaemon
XTuucp
XTnetwork
X
X#############################
X#     Format of headers     #
X#############################
X
X#H?P?Return-Path: <$g>
XHReceived: $?sfrom $s
X    $.by $j ($v/$V)
X    id $i; $b
XH?D?Resent-Date: $a
XH?D?Date: $a
XH?F?Resent-From: $q
XH?F?From: $q
XH?x?Full-Name: $x
XHSubject:
X# HPosted-Date: $a
X# H?l?Received-Date: $b
XH?M?Resent-Message-Id: <$t.$i@$j>
XH?M?Message-Id: <$t.$i@$j>
X
X############################################################
X#
X#        REWRITING RULES
X#
X
X
X###########################
X#              #
X#  Name Canonicalization  #
X#              #
X###########################
XS3
X
X# basic textual canonicalization
XR<>            $@@                turn into magic token
XR$*<$+>$*        $2                basic RFC821/822 parsing
XR$+ at $+        $1@$2                "at" -> "@" for RFC 822
XR$*<$*>$*        $1$2$3                in case recursive
X
X# handle route-addr <@a,@b,@c:user@d>
XR@$+,$+            @$1:$2                change all "," to ":"
XR@$+:$+            $@<@$1>:$2            handle <route-addr>
XR$+:$*;@$+        $@$1:$2;@$3            list syntax
X
X# Rewrite address into a domain-based address.  Any special mock domain names
X# (like UUX) should be defined on the CT line and removed (if necessary)
X# in S4.  You can use them in S0 for designated transport mechanisms.
X
X# Delimiters with precedence over @.  Add yours here.
X
X# The @ delimiter.  Leave this alone.
XR$+@$+            $:$1<@$2>            focus on domain
XR$+<$+@$+>        $1$2<@$3>            move gaze right
XR$+<@$+>        $@$1<@$2>            already canonical
X
X# Delimiters with precedence below @.  Add yours here.
XR$+^$+            $1!$2                convert ^ to !
XR$-!$+            $@$2<@$1.UUX>            resolve uucp names
XR$+.!$+            $@$2<@$1>            domain.!host
XR$+!$+            $@$2<@$1>            domain!host
X
X# % is a low precedence @.
XR$*%$*            $@$>3$1@$2            %->@ and retry
X
X############################################################
X#
X#            RULESET ZERO PREAMBLE
X#
X############################################################
X
XS0
X
X# first make canonical
XR$*<$*>$*        $1$2$3                defocus
XR$+            $:$>3$1                make canonical
X
X# handle special cases.....
XR@            $#local$:MAILER-DAEMON        handle <> form
XR$*<@[$+]>$*        $#ether$@[$2]$:$1@[$2]$3    numeric internet spec
X
X# strip local stuff
XR$*<@$-.$w.$D>$*    $1<@$2>$3            thishost.mydom
XCF_GATEWAYR$*<@$-.$D>$*    $1<@$2>$3            mydom
XR$*<@$-.$w.$=D>$*    $1<@$2>$4            thishost.anydom
XR$*<@$-.$w.$A>$*    $1<@$2>$3            thishost.anotherdom
XR$*<@$-.$A>$*        $1<@$2>$3            anotherdom
XR$*<@$-.$w.$=T>$*    $1<@$2>$4            thishost.mockdom
XCF_GATEWAYR$*<$*$w>$*    $1<$2>$3            thishost
XR$*<$*.>$*        $1<$2>$3            drop trailing dot
XR<@>:$+            $@$>0$1                strip null route, retry
XR$+<@>            $@$>0$1                strip null addr, retry
X
X
X###############################################
X#    Machine dependent part of ruleset zero   #
X###############################################
X
X# Preemption: for a host on a known link turn the domain spec into a
X# mock domain indicating the link.  One set of these rules for each of
X# the F classes listed in the local configuration options.
X
XR$*<$*$=E.$D>$*            $:$1<$2$3.ETHER>$4    etherhost.mydomain
XR$*<$*$=E.$=D>$*        $:$1<$2$3.ETHER>$5    etherhost.anydomain
XR$*<$*$=E.$A>$*            $:$1<$2$3.ETHER>$4    etherhost.anotherdomain
XR$*<$*$=E.$=T>$*        $:$1<$2$3.ETHER>$5    etherhost.mock-domain
XR$*<$*$=E>$*            $:$1<$2$3.ETHER>$4    etherhost
X
X# Designated delivery: use the indicated transport mechanism.  One of
X# these rules for each of the mock domains defined in $=T.  You can
X# remove these if you just want general disposition.  HINTS.
X
X# Designated delivery:
XR$*<@$=U.UUX>$*        $#uux$@$2$:$1$3            known uucphost
XR$*<@$=E$+.ETHER>$*    $#ether$@$2$:$1@$2$4        known etherhost
XR$*<@$+.ETHER>$*    $#ether$@$2$:$1@$2$3        etherhost
X
X# throw out mock domain name now
XR$*<$*.$=T>$*        $1<$2>$4
X
X# General disposition of remote mail (comment out all but one).  You
X# might add to this list, if you have other "smarter" mailers.  HINTS.
X
XR$*<@$->:$+        $#uux$@$2$:$1$3            forward to $2
XR$*<@$*>$*        $#uux$@$2$:$1$3            hand to uucp
X#R$*<@$*>$*        $#uux$@$R$:$1@$2$3        hand to uucp relay
X#R$*<@$*>$*        $#ether$@$R$:$1@$2$3        hand to ether relay
X#R$*<$*>$*        $#error$:unknown address $1$2$3    don't hand anywhere
X
X# local delivery
XR$+            $#local$:$1            user
X
X############################################################
X#
X#         Local and Program Mailer specification
X#
X############################################################
X
XCF_SVMAILMlocal, P=CF_LOCALMAIL, F=lsDFMhumSU, S=10, R=20, A=rmail $u
XCF_BSMAILMlocal, P=CF_LOCALMAIL, F=rlsDFMmn, S=10, R=20, A=mail -d $u
XMprog,    P=/bin/sh,   F=lsDFMe,   S=10, R=20, A=sh -c $u
X
XS10
XR@            MAILER-DAEMON    errors to mailer-daemon
XCF_HIDDENHOSTSR$+<@$+.$j>$*        $1<@$j>$3    hide anydom.$j under $j
X
XS20
X
X############################################################
X#
X#            UUCP Mailer specification
X#
X############################################################
X
XMuux,    P=/bin/smail, F=sDFMhum, S=14, R=24, M=100000,
X    A=smail -vH$j $h!$u
X
XS14
XR$+<@$=E>        $1            user@etherhost -> user
XR$*<@$+>$*        $@$1<@$2>$3        already ok
XCF_HIDDENHOSTSR$+<@$+.$j>$*        $1<@$j>$3        hide anydom.$j under $j
XR$+            $@$1<@$j>        add our full address
X
XS24
X
X############################################################
X#
X#            SMTP ethernet mailer
X#
X############################################################
X
XMether,    P=[IPC], F=msDFMuCXP, S=11, R=21, A=IPC $h
X
XS11
XR$*<@$+>$*        $@$1<@$2>$3        already ok
XR$+            $@$1<@$w>        add our hostname
X
XS21
X
X#################################
X#  Final Output Post-rewriting  #
X#################################
X
X# This rewrites the internal $=T mock domains into their external form.
X# The default is to replace the mock domain name with $D.
X# The last two lines are stock.
X
XS4
XR@            $@                handle <> error addr
XR$+<@$-.UUX>        $2!$1                [e-mail] => host!u
XR$*<$*$=T>$*        $:$1<$2$D>$4            change local info
XR$*<$+>$*        $1$2$3                defocus
XR@$+:$+:$+        @$1,$2:$3            <route-addr> canonical
END_OF_FILE
if test 8435 -ne `wc -c <'mailer/template.cf'`; then
    echo shar: \"'mailer/template.cf'\" unpacked with wrong size!
fi
# end of 'mailer/template.cf'
fi
echo shar: End of archive 4 \(of 8\).
cp /dev/null ark4isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 8 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0