csu@alembic.acs.com (Dave Mack) (07/16/90)
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
csu@alembic.ACS.COM
#! /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 sources-request@uunet.uu.net 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 uucp-query@Stargate.COM 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 u@host.UUX => 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