<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.    
-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!-- Generated by Apache Maven Doxia at Apr 17, 2012 -->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>
  Apache James Server 3 - Provided Matchers</title>
    <style type="text/css" media="all">
      @import url("./css/james.css");
      @import url("./css/maven-base.css");
      @import url("./css/maven-theme.css");
      @import url("./css/site.css");
      @import url("./js/jquery/css/custom-theme/jquery-ui-1.8.5.custom.css");
      @import url("./js/jquery/css/print.css");
      @import url("./js/fancybox/jquery.fancybox-1.3.4.css");
    </style>
    <script type="text/javascript" src="./js/jquery/js/jquery-1.4.2.min.js"></script>
    <script type="text/javascript" src="./js/jquery/js/jquery-ui-1.8.5.custom.min.js"></script>
    <script type="text/javascript" src="./js/fancybox/jquery.fancybox-1.3.4.js"></script>
    <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
    <meta name="Date-Revision-yyyymmdd" content="20120417" />
    <meta http-equiv="Content-Language" content="en" />
                                                    
<link title="DOAP" rel="meta" type="application/rdf+xml" href="http://james.apache.org//doap_james-project.rdf"/>
                      
          <!-- Google Analytics -->
    <script type="text/javascript">
    
      var _gaq = _gaq || [];
      _gaq.push(['_setAccount', 'UA-1384591-1']);
      _gaq.push(['_trackPageview']);

      (function() {
        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
        var s = document.getElementsByTagName('script').item(0); s.parentNode.insertBefore(ga, s);
      })();

    </script>
    </head>
  <body class="composite">
    <div id="banner">
                                      <a href="../index.html" id="bannerLeft" title="james-server-logo.gif">
              
                                                                            
        <img src="images/logos/james-server-logo.gif" alt="Apache James Server 3.0" />
                </a>
                              <a href="http://www.apache.org/index.html" id="bannerRight">
              
                                        
        <img src="images/logos/asf-logo-reduced.gif" alt="The Apache Software Foundation" />
                </a>
            <div class="clear">
        <hr/>
      </div>
    </div>
    <div id="breadcrumbs">
            
                
                <div class="xleft">
        <span id="publishDate">Last Published: 2012-04-17</span>
                      </div>
            <div class="xright">                    <a href="../../index.html" title="Home">Home</a>
            |
                        <a href="../index.html" title="Server">Server</a>
            |
                        <a href="../../hupa/index.html" title="Hupa">Hupa</a>
            |
                        <a href="../../protocols/index.html" title="Protocols">Protocols</a>
            |
                        <a href="../../imap/index.html" title="IMAP">IMAP</a>
            |
                        <a href="../../mailet/index.html" title="Mailets">Mailets</a>
            |
                        <a href="../../mailbox/index.html" title="Mailbox">Mailbox</a>
            |
                        <a href="../../mime4j/index.html" title="Mime4J">Mime4J</a>
            |
                        <a href="../../jsieve/index.html" title="jSieve">jSieve</a>
            |
                        <a href="../../jspf/index.html" title="jSPF">jSPF</a>
            |
                        <a href="../../jdkim/index.html" title="jDKIM">jDKIM</a>
            |
                        <a href="../../mpt/index.html" title="MPT">MPT</a>
            |
                        <a href="../../postage/index.html" title="Postage">Postage</a>
              
                
      </div>
      <div class="clear">
        <hr/>
      </div>
    </div>
    <div id="leftColumn">
      <div id="navcolumn">
             
                
                                <h5>Overview</h5>
                  <ul>
                  <li class="none">
                          <a href="index.html" title="Introduction">Introduction</a>
            </li>
                  <li class="none">
                          <a href="release-notes.html" title="Release Notes">Release Notes</a>
            </li>
          </ul>
                       <h5>Features</h5>
                  <ul>
                  <li class="none">
                          <a href="feature-mailetcontainer.html" title="Mailet Container">Mailet Container</a>
            </li>
                  <li class="none">
                          <a href="feature-queue-priority.html" title="Queue Priority">Queue Priority</a>
            </li>
                  <li class="none">
                          <a href="feature-persistence.html" title="Persistence">Persistence</a>
            </li>
                  <li class="none">
                          <a href="feature-protocols.html" title="Protocols">Protocols</a>
            </li>
                  <li class="none">
                          <a href="feature-smtp-hooks.html" title="SMTP Hooks">SMTP Hooks</a>
            </li>
                  <li class="none">
                          <a href="feature-performance.html" title="Performance">Performance</a>
            </li>
                  <li class="none">
                          <a href="feature-security.html" title="Security">Security</a>
            </li>
          </ul>
                       <h5>User Manual</h5>
                  <ul>
                  <li class="none">
                          <a href="quick-start.html" title="1. Quick Start">1. Quick Start</a>
            </li>
                  <li class="none">
                          <a href="install.html" title="2. Install James">2. Install James</a>
            </li>
                                                                                                                                                                                                                                                                                                                                <li class="collapsed">
                          <a href="config.html" title="3. Configure James">3. Configure James</a>
                  </li>
                                                                                                        <li class="collapsed">
                          <a href="manage.html" title="4. Manage">4. Manage</a>
                  </li>
                                                                                                        <li class="collapsed">
                          <a href="monitor.html" title="5. Monitor">5. Monitor</a>
                  </li>
                                                                                      <li class="collapsed">
                          <a href="upgrade.html" title="6. Upgrade">6. Upgrade</a>
                  </li>
          </ul>
                       <h5>Developers Corner</h5>
                  <ul>
                  <li class="none">
                          <a href="dev.html" title="Architecture">Architecture</a>
            </li>
                  <li class="none">
                          <a href="dev-build.html" title="Build from source">Build from source</a>
            </li>
                  <li class="none">
                          <a href="dev-database-schema.html" title="Database Schema">Database Schema</a>
            </li>
                                                                                                        <li class="collapsed">
                          <a href="dev-extend.html" title="Develop Extensions">Develop Extensions</a>
                  </li>
                                                                                                                  <li class="expanded">
                          <a href="dev-provided.html" title="Provided Extensions">Provided Extensions</a>
                    <ul>
                      <li class="none">
                          <a href="dev-provided-mailets.html" title="Mailets">Mailets</a>
            </li>
                      <li class="none">
            <strong>Matchers</strong>
          </li>
                      <li class="none">
                          <a href="dev-provided-smtp-hooks.html" title="SMTP Hooks">SMTP Hooks</a>
            </li>
              </ul>
        </li>
                  <li class="none">
                          <a href="https://repository.apache.org/content/repositories/snapshots/org/apache/james/apache-james/" title="Nightly builds">Nightly builds</a>
            </li>
          </ul>
                       <h5>References</h5>
                  <ul>
                  <li class="none">
                          <a href="apidocs/index.html" title="Javadoc">Javadoc</a>
            </li>
                  <li class="none">
                          <a href="https://issues.apache.org/jira/browse/JAMES" title="Issue Tracker">Issue Tracker</a>
            </li>
          </ul>
                       <h5>About James</h5>
                  <ul>
                  <li class="none">
                          <a href="../../index.html" title="Overview">Overview</a>
            </li>
                  <li class="none">
                          <a href="../../newsarchive.html" title="News">News</a>
            </li>
                  <li class="none">
                          <a href="../../mail.html" title="Mailing Lists">Mailing Lists</a>
            </li>
                  <li class="none">
                          <a href="../../contribute.html" title="Contributing">Contributing</a>
            </li>
                  <li class="none">
                          <a href="../../guidelines.html" title="Guidelines">Guidelines</a>
            </li>
                  <li class="none">
                          <a href="http://wiki.apache.org/james" title="Wiki">Wiki</a>
            </li>
                  <li class="none">
                          <a href="../../team-list.html" title="Who We Are">Who We Are</a>
            </li>
                  <li class="none">
                          <a href="../../license.html" title="License">License</a>
            </li>
          </ul>
                       <h5>Download</h5>
                  <ul>
                  <li class="none">
                          <a href="../../download.cgi" title="Releases">Releases</a>
            </li>
                  <li class="none">
                          <a href="https://repository.apache.org/content/repositories/snapshots/org/apache/james/" title=""></a>
            </li>
          </ul>
        <h5>Apache Software Foundation</h5>
  <ul>
    <li>
      <strong>
        <a title="ASF" href="http://www.apache.org/">ASF</a>
      </strong>
    </li>
    <li>
      <a title="Get Involved" href="http://www.apache.org/foundation/getinvolved.html">Get Involved</a>
    </li>
    <li>
      <a title="FAQ" href="http://www.apache.org/foundation/faq.html">FAQ</a>
    </li>
    <li>
      <a title="License" href="http://www.apache.org/licenses/" >License</a>
    </li>
    <li>
      <a title="Sponsorship" href="http://www.apache.org/foundation/sponsorship.html">Sponsorship</a>
    </li>
    <li>
      <a title="Thanks" href="http://www.apache.org/foundation/thanks.html">Thanks</a>
    </li>
    <li>
      <a title="Security" href="http://www.apache.org/security/">Security</a>
    </li>
  </ul>
                       <a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy">
        <img class="poweredBy" alt="Built by Maven" src="./images/logos/maven-feather.png" />
      </a>
                   
                
            </div>
    </div>
    <div id="bodyColumn">
      <div id="contentBox">
        <!-- Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License. -->

 

<div class="section"><h2>Matchers<a name="Matchers"></a></h2>

<p>James provides a number of implemented Matchers for use by James administrators in their 
configurations.  These are primarily matchers that members of the James developer or user 
communities have found useful in their own configurations.  A description of how to configure 
Matchers and use them in the James SpoolManager can be found <a href="config-mailetcontainer.html">here</a>.</p>

<div class="section"><h3>All<a name="All"></a></h3>
<p>Description: This matcher is the trivial one - it matches all mails being processed. All recipients are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>AttachmentFileNameIs<a name="AttachmentFileNameIs"></a></h3>
<p>Description: It can be used to refuse emails with SCR, PIF, EXE etc. attachments.
It matches mails that has a file attachment with a file name meeting one of the supplied filters.
All recipients are returned.</p>
<p>Configuration string: A comma or space delimited list of file names. 
File names may start with a wildcard '*'. Example: *.scr,*.bat,*.pif,*.pi,*.com,*.exe
</p><div><pre><tt>
&lt;mailet match=&quot;AttachmentFileNameIs=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>CommandForListserv<a name="CommandForListserv"></a></h3>
<p>Description: The CommandForListserv matcher is used as a simple filter to recognize emails that are list server 
commands.  It will match any email addressed to the list server host, as well as any email that is addressed
to a user named &lt;prefix&gt;-on or &lt;prefix&gt;-off on any host.  Only those matching recipients will be returned.</p>
<p>Configuration string: An email address of the form &lt;prefix&gt;@&lt;host&gt;, where host is the hostname used for the listserver and prefix is the command prefix.
</p><div><pre><tt>
&lt;mailet match=&quot;CommandForListserv=james-on@list.working-dogs.com&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>CommandForListservManager<a name="CommandForListservManager"></a></h3>
<p>Description: CommandListservMatcher is the matcher that pairs with the CommandListservManager mailet. It checks to see if the request is 
intended for the ListservManager, but doesn't guarantee that it is a valid command.  Only those matching recipients will be returned.</p>
<p>Configuration string: An email address.
</p><div><pre><tt>
&lt;mailet match=&quot;CommandForListservManager=announce@localhost&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>CompareNumericHeaderValue<a name="CompareNumericHeaderValue"></a></h3>
<p>Description: Matches mails containing a header with a numeric value whose comparison with the specified value is true.
If the header is missing in the message, there will be <i>no match</i>. All recipients are returned.</p>
<p>Configuration string: The headerName, a comparison operator and the numeric headerValue
to compare with, <i>space or tab delimited</i>.
</p><div><pre><tt>
&lt;mailet match=&quot;CompareNumericHeaderValue= X-MessageIsSpamProbability &gt; 0.9&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>FetchedFrom<a name="FetchedFrom"></a></h3>
<p>Description: A matcher intended for use with the FetchMail server.  It matches a custom header (X-fetched-from) that is 
set by the FetchMail server.  FetchMail sets this header to the name of the FetchPOP task which originally fetched
the message.  All recipients are returned.</p>
<p>Configuration string: The name of the FetchMail task which originally fetched the message.
</p><div><pre><tt>
&lt;mailet match=&quot;FetchedFrom=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>FileRegexMatcher<a name="FileRegexMatcher"></a></h3>
<p>Description: A matcher which can be used to match on a attachment when the given regex match. All recipients are returned.</p>
<p>Configuration string: A regex for match attachmentname.
</p><div><pre><tt>
&lt;mailet match=&quot;FileRegexMatcher=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>HasAttachment<a name="HasAttachment"></a></h3>
<p>Description: Matches those messages with a MIME type of &quot;multipart/mixed&quot;.  All recipients are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>HasHabeasWarrantMark<a name="HasHabeasWarrantMark"></a></h3>
<p>Description: Matches mails that have the Habeas Warrant (see http://www.habeas.com for details).  All recipients are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>HasHeader<a name="HasHeader"></a></h3>
<p>Description: Matches mails that have the specified header.  All recipients are returned.</p>
<p>Configuration string: The name of the header whose presence determines the match.
</p><div><pre><tt>
&lt;mailet match=&quot;HasHeader=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>HasMailAttribute<a name="HasMailAttribute"></a></h3>
<p>Description: Matches mails that have the specified Mail Attribute.  All 
recipients are returned.</p>
<p>Configuration string: The name of the Mail Attribute to match. For example:<br />
</p><div><pre><tt>
&lt;mailet match=&quot;HasMailAttribute=name&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>HasMailAttributeWithValue<a name="HasMailAttributeWithValue"></a></h3>
<p>Description: Matches mails that have the specified Mail Attribute and the
specified MailAttribute value. All recipients are returned.</p>
<p>MailAttributes are types of Object whereas the value specified in the Matcher
condition is of type String. The toString() method is used to obtain a String
representation of the Mail Attribute value for matching. The 
String.equals(String) method tests for a match.</p>
<p>Configuration string: The name of the Mail Attribute to be matched,  a comma
and then the String value to be matched. For example:<br />
</p><div><pre><tt>
&lt;mailet match=&quot;HasMailAttributeWithValue=name, value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>HasMailAttributeWithValueRegex<a name="HasMailAttributeWithValueRegex"></a></h3>
<p>Description: Matches mails that have the specified Mail Attribute and 
a MailAttribute value that matches the specified regular expression.
All recipients are returned.</p>
<p>MailAttributes are types of Object whereas the value specified in the Matcher
condition is of type String. The toString() method is used to obtain a String
representation of the Mail Attribute value for matching. The regular
expression must follow Perl5 syntax.</p>
<p>Configuration string: The name of the Mail Attribute to be matched,  a comma
and then the regular expression used to match the value against. For example:<br />
</p><div><pre><tt>
&lt;mailet match=&quot;HasMailAttributeWithValueRegex=name, regex&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>HostIs<a name="HostIs"></a></h3>
<p>Description: Matches mails that are sent to email addresses on hosts that are in the configuration list.  Only 
recipients that are on one of the hosts are returned.</p>
<p>Configuration string: A list of host names, comma or space delimited.
</p><div><pre><tt>
&lt;mailet match=&quot;HostIs=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>HostIsLocal<a name="HostIsLocal"></a></h3>
<p>Description: Matches mails that are sent to email addresses on local hosts.  Only 
recipients that are on one of the local hosts are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>InSpammerBlacklist<a name="InSpammerBlacklist"></a></h3>
<p>Description: Checks the mail against one of a number of mail-abuse.org IP lists. All recipients are returned</p>
<p>Configuration string: One of three strings - &quot;blackholes.mail-abuse.org&quot;, &quot;relays.mail-abuse.org&quot;, or &quot;dialups.mail-abuse.org&quot;.</p>
</div>

<div class="section"><h3>IsInWhiteList<a name="IsInWhiteList"></a></h3>
<p>Description: Matches recipients having the mail sender in the recipient's private whitelist.
The recipient name is always converted to its primary name (handling aliases).</p>
<p>Configuration string: The database name containing the white list table.</p>
<div><pre><tt>
&lt;mailet match=&quot;IsInWhiteList=db://maildb&quot; class=&quot;ToProcessor&quot;&gt;
  &lt;processor&gt; transport &lt;/processor&gt;
&lt;/mailet&gt;
</tt></pre></div>
</div>

<div class="section"><h3>IsSingleRecipient<a name="IsSingleRecipient"></a></h3>
<p>Description: Matches those messages sent to only a single recipient.  The single recipient is returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>NESSpamCheck<a name="NESSpamCheck"></a></h3>
<p>Description: A matcher derived from a Netscape Mail Server spam filter.  If the matcher detects headers that 
indicate spam, the message is matched.  All recipients are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>RecipientIs<a name="RecipientIs"></a></h3>
<p>Description: Matches mails that are sent to one of the recipients on a specified list.  Only 
matching recipients are returned.</p>
<p>Configuration string: A list of recipient addresses, comma, tab, or space delimited.
</p><div><pre><tt>
&lt;mailet match=&quot;RecipientIs=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>RecipientIsLocal<a name="RecipientIsLocal"></a></h3>
<p>Description: Matches mails that are sent to email addresses on local hosts with users that have local acccunts.  Only 
matching recipients are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>RecipientIsOverFixedQuota<a name="RecipientIsOverFixedQuota"></a></h3>
<p>Description: Matches mails that are send to email addresses which are over the given quota. Only 
matching recipients are returned.</p>
<p>Configuration string: The quota
</p><div><pre><tt>
&lt;mailet match=&quot;RecipientIsOverFixedQuota=10m&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>RecipientIsRegex<a name="RecipientIsRegex"></a></h3>
<p>Description: Matches mails that are send to email addresses which are matched given regex. Only 
matching recipients are returned.</p>
<p>Configuration string: The quota
</p><div><pre><tt>
&lt;mailet match=&quot;RecipientIsRegex=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>


<div class="section"><h3>RelayLimit<a name="RelayLimit"></a></h3>
<p>Description: Counts the number of Received headers in the mail (each of which represents a server 
in the relay chain).  If the number equals or exceeds the specified limit, the mail is 
matched.  All recipients are returned.</p>
<p>Configuration string: a positive integer that is the limit on the number of relays.
</p><div><pre><tt>
&lt;mailet match=&quot;RelayLimit=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>RemoteAddrInNetwork<a name="RemoteAddrInNetwork"></a></h3>
<p>Description: Checks the remote address from which the mail was received against the configured list.  If the address matches one on the list, the matcher considers it a match.  
All recipients are returned.</p>
<p>Configuration string: A list of domain names, IP addresses, or wildcarded IP subnets of any class.  The 
list may be comma or space delimited.
</p><div><pre><tt>
&lt;mailet match=&quot;RemoteAddrInNetwork=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>RemoteAddrNotInNetwork<a name="RemoteAddrNotInNetwork"></a></h3>
<p>Description: Checks the remote address from which the mail was received against the configured list.  If the address doesn't match one on the list, the matcher considers it a match. 
All recipients are returned.</p>
<p>Configuration string: A list of domain names, IP addresses, or wildcarded IP subnets of any class.  The 
list may be comma or space delimited.
</p><div><pre><tt>
&lt;mailet match=&quot;RemoteAddrNotInNetwork=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>SenderHostIs<a name="SenderHostIs"></a></h3>
<p>Description: Matches mails where the host name in the address of the sender cannot be resolved.  All 
recipients are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>SenderInFakeDomain<a name="SenderInFakeDomain"></a></h3>
<p>Description: Matches mails where the host name in the address of the sender cannot be resolved.  All 
recipients are returned.</p>
<p>Configuration string: None.</p>
</div>

<div class="section"><h3>SenderIs<a name="SenderIs"></a></h3>
<p>Description: Matches mails that are sent by one of the senders on a specified list.  All 
recipients are returned.</p>
<p>Configuration string: A list of sender addresses, comma, tab, or space delimited.
</p><div><pre><tt>
&lt;mailet match=&quot;SenderIs=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>SenderIsNull<a name="SenderIsNull"></a></h3>
<p>Description: Matches mails that are sent by a null sender.</p>
<p>Configuration string: none.
</p><div><pre><tt>
&lt;mailet match=&quot;SenderIsNull&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>SenderIsRegex<a name="SenderIsRegex"></a></h3>
<p>Description: Matches mails that are sent by one of the senders matched the given regex.
All recipients are returned.</p>
<p>Configuration string: A regex.
</p><div><pre><tt>
&lt;mailet match=&quot;SenderIsRegex=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>SizeGreaterThan<a name="SizeGreaterThan"></a></h3>
<p>Description: Matches emails with a total message size (headers and body) greater than the specified limit.  
All recipients are returned.</p>
<p>Configuration string: a positive integer followed by an 'm' or a 'k'.  This is the maximum message size permitted 
specified in megabytes or kilobytes respectively.
</p><div><pre><tt>
&lt;mailet match=&quot;SizeGreaterThan=1m&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>SMTPAuthSuccessful<a name="SMTPAuthSuccessful"></a></h3>
<p>Description: Matches mails that are send from an authorized sender. All recipients are returned.</p>
<p>Configuration string: none.
</p><div><pre><tt>
&lt;mailet match=&quot;SMTPAuthSuccessful&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>SMTPAuthUserIs<a name="SMTPAuthUserIs"></a></h3>
<p>Description: Matches mails that are send from one of the given authorized senders. All recipients are returned.</p>
<p>Configuration string: none.
</p><div><pre><tt>
&lt;mailet match=&quot;SMTPAuthUserIs=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>


<div class="section"><h3>SubjectIs<a name="SubjectIs"></a></h3>
<p>Description: Matches emails with the specified subject.  All recipients are returned.</p>
<p>Configuration string: The string against which mail subject headers are matched.
</p><div><pre><tt>
&lt;mailet match=&quot;SubjectIs=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>SubjectStartsWith<a name="SubjectStartsWith"></a></h3>
<p>Description: Matches emails whose subject header starts with the specified string.  All recipients are returned.</p>
<p>Configuration string: The string against which mail subject headers are matched.
</p><div><pre><tt>
&lt;mailet match=&quot;SubjectStartsWith=value&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

<div class="section"><h3>UserIs<a name="UserIs"></a></h3>
<p>Description: Matches mails that are sent to email addresses that have userids that are in the configuration list.  Only 
matching recipients are returned.</p>
<p>Configuration string: A list of user names, comma or space delimited.
</p><div><pre><tt>
&lt;mailet match=&quot;UserIs=value, value, ..&quot; class=&quot;&lt;any-class&gt;&quot;&gt;
</tt></pre></div>

</div>

</div>


      </div>
    </div>
    <div class="clear">
      <hr/>
    </div>
    <div id="footer">
      <div class="xright">Copyright &#169;                    2002-2012
                        <a href="http://www.apache.org/">The Apache Software Foundation</a>.
            All Rights Reserved.      
                
      </div>
      <div class="clear">
        <hr/>
      </div>
    </div>
  </body>
</html>
