Anonymous Contact Service software v1.1, Part04/08

[Dave Mack]

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 at 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 at 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 at 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 at 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 at 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 at 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, at b, at c:user at 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 at 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 at 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