search..
No manual entry for -- in section 5
PROCMAILEX(5)		      File Formats Manual		  PROCMAILEX(5)

NAME
       procmailex - procmail rcfile examples

SYNOPSIS
       $HOME/.procmailrc examples

DESCRIPTION
       For a description of the rcfile format see procmailrc(5).

       The  weighted  scoring  technique  is  described	 in detail in the proc-
       mailsc(5) man page.

       This man page shows several example recipes.  For examples  of  complete
       rcfiles	you  can check the NOTES section in procmail(1), or look at the
       example rcfiles in /usr/share/doc/procmail/examples.

EXAMPLES
       Sort out all mail coming from the scuba-dive mailing list into the mail-
       folder scubafile (uses the locallockfile scubafile.lock).

	      :0:
	      * ^TOscuba
	      scubafile

       Forward all mail from peter about compilers to william (and keep a  copy
       of it here in petcompil).

	      :0
	      * ^From.*peter
	      * ^Subject:.*compilers
	      {
		 :0 c
		 ! william@somewhere.edu

		 :0
		 petcompil
	      }

       An equivalent solution that accomplishes the same:

	      :0 c
	      * ^From.*peter
	      * ^Subject:.*compilers
	      ! william@somewhere.edu

		 :0 A
		 petcompil

       An equivalent, but slightly slower solution that accomplishes the same:

	      :0 c
	      * ^From.*peter
	      * ^Subject:.*compilers
	      ! william@somewhere.edu

	      :0
	      * ^From.*peter
	      * ^Subject:.*compilers
	      petcompil

       If you are fairly new to procmail and plan to experiment a little bit it
       often  helps to have a safety net of some sort.	Inserting the following
       two recipes above all other recipes will make sure that of all  arriving
       mail  always the last 32 messages will be preserved.  In order for it to
       work as intended, you have to  create  a	 directory  named  `backup'  in
       $MAILDIR prior to inserting these two recipes.

	      :0 c
	      backup

	      :0 ic
	      | cd backup && rm -f dummy `ls -t msg.* | sed -e 1,32d`

       If  your	 system doesn't generate or generates incorrect leading `From '
       lines on every mail, you can fix this by calling up  procmail  with  the
       -f-  option.  To fix the same problem by different means, you could have
       inserted the following two recipes above all other recipes in  your  rc-
       file.   They  will  filter  the header of any mail through formail which
       will strip any leading `From ', and automatically regenerates it	 subse-
       quently.

	      :0 fhw
	      | formail -I "From " -a "From "

       Add  the headers of all messages that didn't come from the postmaster to
       your private header collection (for statistics or mail  debugging);  and
       use  the	 lockfile  `headc.lock'.  In order to make sure the lockfile is
       not removed until the pipe has finished, you have to specify option `w';
       otherwise the lockfile would be removed as soon as the pipe has accepted
       the mail.

	      :0 hwc:
	      * !^FROM_MAILER
	      | uncompress headc.Z; cat >>headc; compress headc

       Or, if you would use the more efficient gzip instead of compress:

	      :0 hwc:
	      * !^FROM_MAILER
	      | gzip >>headc.gz

       Forward all mails shorter than 1000 bytes to my home address  (no  lock-
       file needed on this recipe).

	      :0
	      * < 1000
	      ! myname@home

       Split up incoming digests from the surfing mailing list into their indi-
       vidual  messages, and store them into surfing, using surfing.lock as the
       locallockfile.

	      :0:
	      * ^Subject:.*surfing.*Digest
	      | formail +1 -ds >>surfing

       Store everything coming	from  the  postmaster  or  mailer-daemon  (like
       bounced	mail)  into  the file postm, using postm.lock as the locallock-
       file.

	      :0:
	      * ^FROM_MAILER
	      postm

       A simple autoreply recipe.  It makes sure that  neither	mail  from  any
       daemon  (like bouncing mail or mail from mailing-lists), nor autoreplies
       coming from yourself will be autoreplied to.  If this  precaution  would
       not be taken, disaster could result (`ringing' mail).  In order for this
       recipe  to  autoreply to all the incoming mail, you should of course in-
       sert it before all other recipes in your rcfile.	 However, it is	 advis-
       able  to put it after any recipes that process the mails from subscribed
       mailinglists; it generally is not a good idea to generate autoreplies to
       mailinglists (yes, the !^FROM_DAEMON regexp should already catch	 those,
       but  if	the mailinglist doesn't follow accepted conventions, this might
       not be enough).

	      :0 h c
	      * !^FROM_DAEMON
	      * !^X-Loop: your@own.mail.address
	      | (formail -r -I"Precedence: junk" \
		  -A"X-Loop: your@own.mail.address" ; \
		 echo "Mail received.") | $SENDMAIL -t

       A more complicated  autoreply  recipe  that  implements	the  functional
       equivalent  of the well known vacation(1) program.  This recipe is based
       on the same principles as the last one (prevent `ringing' mail).	 In ad-
       dition to that however, it maintains a vacation database	 by  extracting
       the  name  of  the sender and inserting it in the vacation.cache file if
       the name was new (the vacation.cache file is maintained by formail which
       will make sure that it always contains the most recent names,  the  size
       of  the	file  is limited to a maximum of approximately 8192 bytes).  If
       the name was new, an autoreply will be sent.

       As you can see, the following recipe has	 comments  between  the	 condi-
       tions.  This is allowed.	 Do not put comments on the same line as a con-
       dition though.

	      SHELL=/bin/sh    # for other shells, this might need adjustment

	      :0 Whc: vacation.lock
	       # Perform a quick check to see if the mail was addressed to us
	      * $^To:.*\<$\LOGNAME\>
	       # Don't reply to daemons and mailinglists
	      * !^FROM_DAEMON
	       # Mail loops are evil
	      * !^X-Loop: your@own.mail.address
	      | formail -rD 8192 vacation.cache

		:0 ehc	       # if the name was not in the cache
		| (formail -rI"Precedence: junk" \
		     -A"X-Loop: your@own.mail.address" ; \
		   echo "I received your mail,"; \
		   echo "but I won't be back until Monday."; \
		   echo "-- "; cat $HOME/.signature \
		  ) | $SENDMAIL -oi -t

       Store  all  messages  concerning TeX in separate, unique filenames, in a
       directory named texmail (this directory has to exist); there is no  need
       to use lockfiles in this case, so we won't.

	      :0
	      * (^TO|^Subject:.*)TeX[^t]
	      texmail

       The  same  as above, except now we store the mails in numbered files (MH
       mail folder).

	      :0
	      * (^TO|^Subject:.*)TeX[^t]
	      texmail/.

       Or you could file the mail in several  directory	 folders  at  the  same
       time.   The following recipe will deliver the mail to two MH-folders and
       one directory folder.  It is actually  only  one	 file  with  two  extra
       hardlinks.

	      :0
	      * (^TO|^Subject:.*)TeX[^t]
	      texmail/. wordprocessing dtp/.

       Store all the messages about meetings in a folder that is in a directory
       that  changes  every  month.   E.g.  if it were January 1994, the folder
       would have the name  `94-01/meeting'  and  the  locallockfile  would  be
       `94-01/meeting.lock'.

	      :0:
	      * meeting
	      `date +%y-%m`/meeting

       The  same as above, but, if the `94-01' directory wouldn't have existed,
       it is created automatically:

	      MONTHFOLDER=`date +%y-%m`

	      :0 Wic
	      * ? test ! -d $MONTHFOLDER
	      | mkdir $MONTHFOLDER

	      :0:
	      * meeting
	      ${MONTHFOLDER}/meeting

       The same as above, but now by slightly different means:

	      MONTHFOLDER=`date +%y-%m`
	      DUMMY=`test -d $MONTHFOLDER || mkdir $MONTHFOLDER`

	      :0:
	      * meeting
	      ${MONTHFOLDER}/meeting

       If you are subscribed to several mailinglists and people	 cross-post  to
       some  of	 them,	you  usually  receive several duplicate mails (one from
       every list).  The following simple recipe  eliminates  duplicate	 mails.
       It  tells  formail  to keep an 8KB cache file in which it will store the
       Message-IDs of the most recent mails you	 received.   Since  Message-IDs
       are  guaranteed to be unique for every new mail, they are ideally suited
       to weed out duplicate mails.  Simply put the following recipe at the top
       of your rcfile, and no duplicate mail will get past it.

	      :0 Wh: msgid.lock
	      | formail -D 8192 msgid.cache

       Beware if you have delivery problems in recipes below this one and proc-
       mail tries to requeue the mail, then on the next queue  run,  this  mail
       will  be	 considered a duplicate and will be thrown away.  For those not
       quite so confident in their own scripting capabilities, you can use  the
       following  recipe  instead.  It puts duplicates in a separate folder in-
       stead of throwing them away.  It is up to you to periodically empty  the
       folder of course.

	      :0 Whc: msgid.lock
	      | formail -D 8192 msgid.cache

	      :0 a:
	      duplicates

       Procmail can deliver to MH folders directly, but, it does not update the
       unseen  sequences  the  real MH manages.	 If you want procmail to update
       those as well, use a recipe like the following which  will  file	 every-
       thing  that  contains  the  word spam in the body of the mail into an MH
       folder called spamfold.	Note the local lockfile, which	is  needed  be-
       cause  MH programs do not lock the sequences file.  Asynchronous invoca-
       tions of MH programs that change the sequences file may	therefore  cor-
       rupt  it	 or silently lose changes.  Unfortunately, the lockfile doesn't
       completely solve the problem as rcvstore could be invoked  while	 `show'
       or `mark' or some other MH program is running.  This problem is expected
       to be fixed in some future version of MH, but until then, you'll have to
       balance	the  risk  of lost or corrupt sequences against the benefits of
       the unseen sequence.

	      :0 :spamfold/$LOCKEXT
	      * B ?? spam
	      | rcvstore +spamfold

       When delivering to emacs folders (i.e., mailfolders managed by any emacs
       mail package, e.g., RMAIL or VM) directly, you should use emacs-compati-
       ble lockfiles.  The emacs mailers are a bit  braindamaged  in  that  re-
       spect, they get very upset if someone delivers to mailfolders which they
       already	have  in  their internal buffers.  The following recipe assumes
       that $HOME equals /home/john.

	      MAILDIR=Mail

	      :0:/usr/local/lib/emacs/lock/!home!john!Mail!mailbox
	      * ^Subject:.*whatever
	      mailbox

       Alternatively, you can have procmail deliver into its own set  of  mail-
       boxes,  which  you  then	 periodically empty and copy over to your emacs
       files using movemail.  Movemail uses mailbox.lock  local	 lockfiles  per
       mailbox.	  This	actually is the preferred mode of operation in conjunc-
       tion with procmail.

       To extract certain headers from a mail and  put	them  into  environment
       variables you can use any of the following constructs:

	      SUBJECT=`formail -xSubject:`    # regular field
	      FROM=`formail -rt -xTo:`	      # special case

	      :0 h			      # alternate method
	      KEYWORDS=| formail -xKeywords:

       If  you are using temporary files in a procmailrc file, and want to make
       sure that they are removed just before procmail	exits,	you  could  use
       something along the lines of:

	      TEMPORARY=$HOME/tmp/pmail.$$
	      TRAP="/bin/rm -f $TEMPORARY"

       The  TRAP  keyword  can also be used to change the exitcode of procmail.
       I.e. if you want procmail to return an exitcode of `1'  instead	of  its
       regular exitcodes, you could use:

	      EXITCODE=""
	      TRAP="exit 1;"   # The trailing semi-colon is important
			       # since exit is not a standalone program

       Or, if the exitcode does not need to depend on the programs run from the
       TRAP, you can use a mere:

	      EXITCODE=1

       The  following recipe prints every incoming mail that looks like a post-
       script file.

	      :0 Bb
	      * ^^%!
	      | lpr

       The following recipe does the same, but is a  bit  more	selective.   It
       only  prints the postscript file if it comes from the print-server.  The
       first condition matches only if it is found in the header.   The	 second
       condition only matches at the start of the body.

	      :0 b
	      * ^From[ :].*print-server
	      * B ?? ^^%!
	      | lpr

       The same as above, but now by slightly different means:

	      :0
	      * ^From[ :].*print-server
	      {
		:0 B b
		* ^^%!
		| lpr
	      }

       Likewise:

	      :0 HB b
	      * ^^(.+$)*From[ :].*print-server
	      * ^^(.+$)*^%!
	      | lpr

       Suppose you have two accounts, you use both accounts regularly, but they
       are  in	very distinct places (i.e., you can only read mail that arrived
       at either one of the accounts).	You would like to forward mail arriving
       at account one to account two, and the  other  way  around.   The  first
       thing  that  comes  to  mind is using .forward files at both sites; this
       won't work of course, since you will be creating a mail loop.  This mail
       loop can be avoided by inserting the following recipe in	 front	of  all
       other recipes in the $HOME/.procmailrc files on both sites.  If you make
       sure  that  you	add  the same X-Loop: field at both sites, mail can now
       safely be forwarded to the other account from either of them.

	      :0 c
	      * !^X-Loop: yourname@your.main.mail.address
	      | formail -A "X-Loop: yourname@your.main.mail.address" | \
		 $SENDMAIL -oi yourname@the.other.account

       If someone sends you a mail with the word `retrieve' in the subject, the
       following will automatically send back the contents of info_file to  the
       sender.	 Like  in all recipes where we send mail, we watch out for mail
       loops.

	      :0
	      * !^From +YOUR_USERNAME
	      * !^Subject:.*Re:
	      * !^FROM_DAEMON
	      * ^Subject:.*retrieve
	      | (formail -r ; cat info_file) | $SENDMAIL -oi -t

       Now follows an example for a very simple fileserver accessible by  mail.
       For  more demanding applications, I suggest you take a look at SmartList
       (available from the  same  place	 as  the  procmail  distribution).   As
       listed,	this fileserver sends back at most one file per request, it ig-
       nores the body of incoming mails, the Subject: line  has	 to  look  like
       "Subject:  send file the_file_you_want" (the blanks are significant), it
       does not return files that have names starting with a dot, nor  does  it
       allow  files  to	 be retrieved that are outside the fileserver directory
       tree (if you decide to munge this example, make sure you do not inadver-
       tently loosen this last restriction).

	      :0
	      * ^Subject: send file [0-9a-z]
	      * !^X-Loop: yourname@your.main.mail.address
	      * !^Subject:.*Re:
	      * !^FROM_DAEMON
	      * !^Subject: send file .*[/.]\.
	      {
		MAILDIR=$HOME/fileserver # chdir to the fileserver directory

		:0 fhw			 # reverse mailheader and extract name
		* ^Subject: send file \/[^ ]*
		| formail -rA "X-Loop: yourname@your.main.mail.address"

		FILE="$MATCH"		 # the requested filename

		:0 ah
		| cat - ./$FILE 2>&1 | $SENDMAIL -oi -t
	      }

       The following example preconverts all plain-text mail arriving  in  cer-
       tain  encoded MIME formats into a more compact 8-bit format which can be
       used and displayed more easily by most programs.	 The mimencode(1)  pro-
       gram is part of Nathaniel Borenstein's metamail package.

	      :0
	      * ^Content-Type: *text/plain
	      {
		:0 fbw
		* ^Content-Transfer-Encoding: *quoted-printable
		| mimencode -u -q

		   :0 Afhw
		   | formail -I "Content-Transfer-Encoding: 8bit"

		:0 fbw
		* ^Content-Transfer-Encoding: *base64
		| mimencode -u -b

		   :0 Afhw
		   | formail -I "Content-Transfer-Encoding: 8bit"
	      }

       The  following one is rather exotic, but it only serves to demonstrate a
       feature.	 Suppose you have a file in your HOME  directory  called  ".ur-
       gent",  and  the (one) person named in that file is the sender of an in-
       coming mail, you'd like that mail to be stored  in  $MAILDIR/urgent  in-
       stead  of in any of the normal mailfolders it would have been sorted in.
       Then this is what you could do (beware, the filelength of  $HOME/.urgent
       should be well below $LINEBUF, increase LINEBUF if necessary):

	      URGMATCH=`cat $HOME/.urgent`

	      :0:
	      * $^From.*${URGMATCH}
	      urgent

       An entirely different application for procmail would be to conditionally
       apply  filters  to a certain (outgoing) text or mail.  A typical example
       would be a filter through which you pipe all outgoing mail, in order  to
       make  sure that it will be MIME encoded only if it needs to be.	I.e. in
       this case you could start procmail in the middle of a pipe like:

	      cat newtext | procmail ./mimeconvert | mail chris@where.ever

       The mimeconvert rcfile could contain  something	like  (the  =0x80=  and
       =0xff= should be substituted with the real 8-bit characters):

	      DEFAULT=|	    # pipe to stdout instead of
			    # delivering mail as usual
	      :0 Bfbw
	      * [=0x80=-=0xff=]
	      | mimencode -q

		:0 Afhw
		| formail -I 'MIME-Version: 1.0' \
		   -I 'Content-Type: text/plain; charset=ISO-8859-1' \
		   -I 'Content-Transfer-Encoding: quoted-printable'

SEE ALSO
       procmail(1), procmailrc(5), procmailsc(5), sh(1), csh(1), mail(1),
       mailx(1), uucp(1), aliases(5), sendmail(8), egrep(1), grep(1), biff(1),
       comsat(8), mimencode(1), lockfile(1), formail(1)

AUTHORS
       Stephen R. van den Berg
	      <srb@cuci.nl>
       Philip A. Guenther
	      <guenther@sendmail.com>

BuGless				   2001/08/04			  PROCMAILEX(5)