Scroll to navigation

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 procmailsc(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 mailfolder 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 rcfile.
    They will filter the header of any mail through formail which will strip any
    leading `From ', and automatically regenerates it subsequently.






: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
    lockfile needed on this recipe).






:0
* < 1000
! myname@home






Split up incoming digests from the surfing mailing list into their
    individual 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
  locallockfile.






: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 insert it before
    all other recipes in your rcfile. However, it is advisable 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
    addition 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 conditions. This is allowed. Do not put comments on the same line
    as a condition 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 procmail 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 instead 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
    everything that contains the word spam in the body of the mail into an MH
    folder called spamfold. Note the local lockfile, which is needed because MH
    programs do not lock the sequences file. Asynchronous invocations of MH
    programs that change the sequences file may therefore corrupt 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-compatible lockfiles. The emacs mailers are a bit braindamaged in that
    respect, 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
    mailboxes, 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 conjunction
    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
    postscript 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 ignores 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
    inadvertently 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
    certain encoded MIME formats into a more compact 8-bit format which can be
    used and displayed more easily by most programs. The mimencode(1)
    program 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
    ".urgent", and the (one) person named in that file is the sender
    of an incoming mail, you'd like that mail to be stored in $MAILDIR/urgent
    instead 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>











  

    2001/08/04
    BuGless