/****************************************************************
* 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. *
****************************************************************/
package org.apache.james.transport.mailets;
import org.apache.james.core.MailImpl;
import org.apache.james.util.XMLResources;
import org.apache.mailet.GenericMailet;
import org.apache.mailet.Mail;
import org.apache.mailet.MailAddress;
import org.apache.oro.text.regex.MatchResult;
import org.apache.oro.text.regex.Pattern;
import org.apache.oro.text.regex.Perl5Compiler;
import org.apache.oro.text.regex.Perl5Matcher;
import javax.mail.MessagingException;
import javax.mail.internet.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
/**
* Provides an abstraction of common functionality needed for implementing
* a Virtual User Table. Override the <code>mapRecipients</code> method to
* map virtual recipients to real recipients.
*/
public abstract class AbstractVirtualUserTable extends GenericMailet
{
static private final String MARKER = "org.apache.james.transport.mailets.AbstractVirtualUserTable.mapped";
/**
* Checks the recipient list of the email for user mappings. Maps recipients as
* appropriate, modifying the recipient list of the mail and sends mail to any new
* non-local recipients.
*
* @param mail the mail to process
*/
public void service(Mail mail) throws MessagingException
{
if (mail.getAttribute(MARKER) != null) {
mail.removeAttribute(MARKER);
return;
}
Collection recipientsToRemove = new HashSet();
Collection recipientsToAddLocal = new ArrayList();
Collection recipientsToAddForward = new ArrayList();
Collection recipients = mail.getRecipients();
Map recipientsMap = new HashMap(recipients.size());
for (Iterator iter = recipients.iterator(); iter.hasNext(); ) {
MailAddress address = (MailAddress)iter.next();
// Assume all addresses are non-virtual at start
recipientsMap.put(address, null);
}
mapRecipients(recipientsMap);
for (Iterator iter = recipientsMap.keySet().iterator(); iter.hasNext(); ) {
MailAddress source = (MailAddress)iter.next();
String targetString = (String)recipientsMap.get(source);
// Only non-null mappings are translated
if(targetString != null) {
if (targetString.startsWith("error:")) {
//Mark this source address as an address to remove from the recipient list
recipientsToRemove.add(source);
processDSN(mail, source, targetString);
} else {
StringTokenizer tokenizer = new StringTokenizer(targetString, getSeparator(targetString));
while (tokenizer.hasMoreTokens()) {
String targetAddress = tokenizer.nextToken().trim();
// log("Attempting to map from " + source + " to " + targetAddress);
if (targetAddress.startsWith("regex:")) {
targetAddress = regexMap(mail, source, targetAddress);
if (targetAddress == null) continue;
}
try {
MailAddress target = (targetAddress.indexOf('@') < 0) ? new MailAddress(targetAddress, "localhost")
: new MailAddress(targetAddress);
//Mark this source address as an address to remove from the recipient list
recipientsToRemove.add(source);
// We need to separate local and remote
// recipients. This is explained below.
if (getMailetContext().isLocalServer(target.getHost())) {
recipientsToAddLocal.add(target);
} else {
recipientsToAddForward.add(target);
}
StringBuffer buf = new StringBuffer().append("Translating virtual user ")
.append(source)
.append(" to ")
.append(target);
log(buf.toString());
} catch (ParseException pe) {
//Don't map this address... there's an invalid address mapping here
StringBuffer exceptionBuffer =
new StringBuffer(128)
.append("There is an invalid map from ")
.append(source)
.append(" to ")
.append(targetAddress);
log(exceptionBuffer.toString());
continue;
}
}
}
}
}
// Remove mapped recipients
recipients.removeAll(recipientsToRemove);
// Add mapped recipients that are local
recipients.addAll(recipientsToAddLocal);
// We consider an address that we map to be, by definition, a
// local address. Therefore if we mapped to a remote address,
// then we want to make sure that the mail can be relayed.
// However, the original e-mail would typically be subjected to
// relay testing. By posting a new mail back through the
// system, we have a locally generated mail, which will not be
// subjected to relay testing.
// Forward to mapped recipients that are remote
if (recipientsToAddForward.size() != 0) {
// Can't use this ... some mappings could lead to an infinite loop
// getMailetContext().sendMail(mail.getSender(), recipientsToAddForward, mail.getMessage());
// duplicates the Mail object, to be able to modify the new mail keeping the original untouched
MailImpl newMail = new MailImpl(mail,newName(mail));
try {
try {
newMail.setRemoteAddr(java.net.InetAddress.getLocalHost().getHostAddress());
newMail.setRemoteHost(java.net.InetAddress.getLocalHost().getHostName());
} catch (java.net.UnknownHostException _) {
newMail.setRemoteAddr("127.0.0.1");
newMail.setRemoteHost("localhost");
}
newMail.setRecipients(recipientsToAddForward);
newMail.setAttribute(MARKER, Boolean.TRUE);
getMailetContext().sendMail(newMail);
} finally {
newMail.dispose();
}
}
// If there are no recipients left, Ghost the message
if (recipients.size() == 0) {
mail.setState(Mail.GHOST);
}
}
/**
* Override to map virtual recipients to real recipients, both local and non-local.
* Each key in the provided map corresponds to a potential virtual recipient, stored as
* a <code>MailAddress</code> object.
*
* Translate virtual recipients to real recipients by mapping a string containing the
* address of the real recipient as a value to a key. Leave the value <code>null<code>
* if no mapping should be performed. Multiple recipients may be specified by delineating
* the mapped string with commas, semi-colons or colons.
*
* @param recipientsMap the mapping of virtual to real recipients, as
* <code>MailAddress</code>es to <code>String</code>s.
*/
protected abstract void mapRecipients(Map recipientsMap) throws MessagingException;
/**
* Sends the message for DSN processing
*
* @param mail the Mail instance being processed
* @param address the MailAddress causing the DSN
* @param error a String in the form "error:<code> <msg>"
*/
private void processDSN(Mail mail, MailAddress address, String error) {
// parse "error:<code> <msg>"
int msgPos = error.indexOf(' ');
try {
Integer code = Integer.valueOf(error.substring("error:".length(),msgPos));
} catch (NumberFormatException e) {
log("Cannot send DSN. Exception parsing DSN code from: " + error, e);
return;
}
String msg = error.substring(msgPos + 1);
// process bounce for "source" address
try {
getMailetContext().bounce(mail, error);
}
catch (MessagingException me) {
log("Cannot send DSN. Exception during DSN processing: ", me);
}
}
/**
* Processes regex virtual user mapping
*
* If a mapped target string begins with the prefix regex:, it must be
* formatted as regex:<regular-expression>:<parameterized-string>,
* e.g., regex:(.*)@(.*):${1}@tld
*
* @param mail the Mail instance being processed
* @param address the MailAddress to be mapped
* @param targetString a String specifying the mapping
*/
private String regexMap(Mail mail, MailAddress address, String targetString) {
String result = null;
try {
int msgPos = targetString.indexOf(':', "regex:".length() + 1);
// log("regex: targetString = " + targetString);
// log("regex: msgPos = " + msgPos);
// log("regex: compile " + targetString.substring("regex:".length(), msgPos));
// log("regex: address = " + address.toString());
// log("regex: replace = " + targetString.substring(msgPos + 1));
Pattern pattern = new Perl5Compiler().compile(targetString.substring("regex:".length(), msgPos));
Perl5Matcher matcher = new Perl5Matcher();
if (matcher.matches(address.toString(), pattern)) {
MatchResult match = matcher.getMatch();
Map parameters = new HashMap(match.groups());
for (int i = 1; i < match.groups(); i++) {
parameters.put(Integer.toString(i), match.group(i));
}
result = XMLResources.replaceParameters(targetString.substring(msgPos + 1), parameters);
}
}
catch (Exception e) {
log("Exception during regexMap processing: ", e);
}
// log("regex: result = " + result);
return result;
}
/**
* Returns the character used to delineate multiple addresses.
*
* @param targetString the string to parse
* @return the character to tokenize on
*/
private String getSeparator(String targetString) {
return (targetString.indexOf(',') > -1 ? "," : (targetString.indexOf(';') > -1 ? ";" : (targetString.indexOf("regex:") > -1? "" : ":" )));
}
private static final java.util.Random random = new java.util.Random(); // Used to generate new mail names
/**
* Create a unique new primary key name.
*
* @param mail the mail to use as the basis for the new mail name
* @return a new name
*/
private String newName(Mail mail) throws MessagingException {
String oldName = mail.getName();
// Checking if the original mail name is too long, perhaps because of a
// loop caused by a configuration error.
// it could cause a "null pointer exception" in AvalonMailRepository much
// harder to understand.
if (oldName.length() > 76) {
int count = 0;
int index = 0;
while ((index = oldName.indexOf('!', index + 1)) >= 0) {
count++;
}
// It looks like a configuration loop. It's better to stop.
if (count > 7) {
throw new MessagingException("Unable to create a new message name: too long. Possible loop in config.xml.");
}
else {
oldName = oldName.substring(0, 76);
}
}
StringBuffer nameBuffer =
new StringBuffer(64)
.append(oldName)
.append("-!")
.append(random.nextInt(1048576));
return nameBuffer.toString();
}
}
|
