Provided by: courier-mta_0.47-13ubuntu5_i386 bug


       courieruucp - Sample Courier mail filter




       The  Courier  mail  server is capable of sending and receiving mail via
       UUCP.  Courier does not  implement  UUCP  directly,  but  instead  uses
       third-party UUCP software, which you must install separately. Courier’s
       UUCP support is provided automatically by the courieruucp module, which
       is compiled and installed by default.

       Courier sends mail via UUCP by issuing a request via uux to execute the
       rmail command on the remote UUCP  node.   Courier  passes  the  message
       envelope  sender  to  rmail  via  the  -f  flag,  and lists the message
       envelope  recipients  as  the  remaining  arguments.  Message  envelope
       addresses  and  E-mail  addresses in the headers of the message will be
       appropriately rewritten.

       Courier will only send mail via UUCP if it knows about the  recipient’s
       UUCP  node.   The  configuration  file  /etc/courier/uucpneighbors is a
       plain text configuration file.  The makeuucpneighbors  script  compiles
       this configuration file into a binary database that is read by Courier.
       Changes  to  /etc/courier/uucpneighbors  do  not  take   effect   until
       makeuucpneighbors is executed, and Courier is restarted.

       /etc/courier/uucpneighbors  may  also  be  a  subdirectory instead of a
       plain text file, in which case the contents of all text files  in  this
       subdirectory  is  automatically  concatenated  by the makeuucpneighbors

       This configuration file must be initialized to contain  the  UUCP  node
       name    that   this   machine   is   known   to   its   neighbors.   If
       /etc/courier/uucpme does not exist, Courier uses the first node name of
       the hostname specified by the /etc/courier/me configuration file.

       Note that in addition to creating this configuration file you must also
       configure your UUCP software to appropriately route UUCP  mail  to  the
       specified  nodes,  which  is a completely separate task. Blank lines in
       this file are ignored.  Lines that  start  with  the  #  character  are
       comments,  and  are  also  ignored.  The  remaining  lines  are  in the
       following format:


       node is a UUCP node, such as "apple" or "food!fruits!apple".  <TAB>  is
       a  single  tab character, and flags is zero or more of single character
       flags described below.  The tab character can be ommited if  there  are
       no flags.

       If  there  is  an  entry  for  node  in /etc/courier/uucpneighbors then
       Courier will accept mail for any address of the form  "node!user",  but
       not  "node!nodule!user". In order to accept mail for "node!nodule!user"
       you must enter both "node" and "node!nodule", unless you use the  F  or
       the G flag.

       The flags are as follows:

       F      Unrestricted  forwarding.   This  flag will accept any UUCP path
              that starts with the specified node.  Example:


              This  will  accept  "food!fruits!apple",   "food!fruits!banana",
              "food!drinks!orangejuice",  and  so  on. You may simply list all
              your immediate UUCP neighbors using the F flag, and accept  mail
              to any address that’s reachable via any neighbor.

       G      This is a gateway.  This flag is identical to the F flag, except
              that rmail is executed on the specified node.  Normally, Courier
              will  issue  a  uux  request  to run rmail on the last node, for
              example "uux food!fruits!rmail apple".  Using  G  instead  of  F
              will  run  rmail on the listed node, for example "uux food!rmail

       R      This is a relay.  This flag is used where neither F or  G  flags
              are  appropriate,  but  you  want to run rmail on this node. For


              In this example mail to "food!fruits!apple" is sent by executing
              "uux  food!rmail fruits!apple".  If the R flag is not specified,
              then Courier will request "uux food!fruits!rmail apple".

       This is the standard Courier module configuration file.

              Maximum simultaneous UUCP deliveries.  This  setting  is  a  bit
              misleading.   From Courier’s viewpoint, a delivery consists only
              of running uux to queue  up  the  message  via  UUCP.  Once  uux
              returns,  the  message  is  delivered,  as  far  as  Courier  is
              concerned.  UUCP is responsible for getting the message the rest
              of  the way. Therefore, UUCP deliveries tend to be fairly quick,
              and  it  is  not  necessary  to  configure  a  large  number  of
              concurrent  courieruucp processes, since each one will terminate
              quickly. Once uux terminates, the UUCP software  is  responsible
              for queueing and sending the message.

              Maximum  simultaneous  UUCP  deliveries  to  the same UUCP node.
              Since UUCP deliveries tend to be fairly quick, it is not usually
              necessary  to  use MAXHOST to limit concurrent deliveries to the
              same UUCP node, so MAXHOST should generally be set to  the  same
              value as MAXDELS.

              Maximum  recipients  per message.  When the same message is sent
              to multiple recipients on the same UUCP node, Courier is capable
              of  asking to run rmail only one, and listing all the recipients
              together. MAXRCPT specifies the upper limit  on  the  number  of
              recipients  that  are  batched together. You want to set a limit
              based on any limitations on the length of command  lines  that’s
              imposed  by  the  operating  system. Sending the same message to
              different UUCP nodes is always handled as separate deliveries.


       Courier is certainly capable of relaying mail between  the  Internet  -
       via   ESMTP   -   and   UUCP-land,   rewriting  headers  and  addresses
       appropriately. The address rewriting rules are   fixed,  but  they  are
       expected  to  work  in  nearly every case. If you find yourself in some
       oddball situation, you’ll just have to invest the time  to  add  custom
       header rewriting code.

       If   you   are,  and  your  UUCP  node  is  example,  then
       <> gets rewritten as example!user.

       Internet mail may be sent via ESMTP to your UUCP neighbor apple!john by
       sending it to <apple!>.  When that’s forwarded via UUCP
       the  return  address  of  <>  will  be  rewritten  as

       apple!john  will get the mail with this return address, which should be
       repliable back to the sender. Courier’s UUCP module  will  receive  the
       UUCP   address!someone,   and   translate   it   back   as


       Courier  does  not  support  defining  multiple  UUCP  node  names   in


       esmtpd(8), couriertcpd(8), courier(8).