Generates a response to the Return-Path address, or the * address of the message's sender if the Return-Path is not * available. Note that this is different than a mail-client's * reply, which would use the Reply-To or From header.
*Bounced messages are attached in their entirety (headers and * content) and the resulting MIME part type is "message/rfc822".
*The Return-Path header of the response is set to "empty" ("<>"), * meaning that no reply should be sent.
*The layout of the bounce message is the same as the NotifySender.
*You can optionally specify a sender of the error * message. If you do not specify one, it will use the postmaster's address. *
Supports passThrough (default is false).
* *Sample configuration:
*
* <mailet match="All" class="NotifySender">
* <sendingAddress>an address or postmaster</sendingAddress>
* <attachStackTrace>true or false, default=false</attachStackTrace>
* <notice>notice attached to the message (optional)</notice>
* <passThrough>true or false, default=false</passThrough>
* </mailet>
* The behaviour of this mailet is equivalent to using Redirect with the following * configuration:
*
* <mailet match="All" class="Redirect">
* <sender>an address or postmaster</sender>
* <attachError>true or false, default=false</attachError>
* <message>dynamically built</message>
* <passThrough>true or false, default=false)</passThrough>
* <recipients>sender</recipients>
* <returnPath>empty</returnPath>
* <inline>none</inline>
* <attachment>message</attachment>
* <isReply>true</isReply>
* <static>true</static>
* </mailet>
* NONE
*/
protected int getInLineType() {
return NONE;
}
/**
* @return MESSAGE
*/
protected int getAttachmentType() {
return MESSAGE;
}
/**
* @return the notice init parameter
*/
protected String getMessage() {
if(getInitParameter("notice") == null) {
return "We were unable to deliver the attached message because of an error in the mail server.";
} else {
return getInitParameter("notice");
}
}
/**
* @return the full message to append, built from the Mail object
*/
protected String getMessage(Mail originalMail) throws MessagingException {
MimeMessage message = originalMail.getMessage();
StringWriter sout = new StringWriter();
PrintWriter out = new PrintWriter(sout, true);
// First add the "local" notice
// (either from conf or generic error message)
out.println(getMessage());
// And then the message from other mailets
if (originalMail.getErrorMessage() != null) {
out.println();
out.println("Error message below:");
out.println(originalMail.getErrorMessage());
}
out.println();
out.println("Message details:");
if (message.getSubject() != null) {
out.println(" Subject: " + message.getSubject());
}
if (message.getSentDate() != null) {
out.println(" Sent date: " + message.getSentDate());
}
String[] rcpts = null;
rcpts = message.getHeader(RFC2822Headers.TO);
if (rcpts != null) {
out.print(" To: ");
for (int i = 0; i < rcpts.length; i++) {
out.print(rcpts[i] + " ");
}
out.println();
}
rcpts = message.getHeader(RFC2822Headers.CC);
if (rcpts != null) {
out.print(" CC: ");
for (int i = 0; i < rcpts.length; i++) {
out.print(rcpts[i] + " ");
}
out.println();
}
out.println(" Size (in bytes): " + message.getSize());
if (message.getLineCount() >= 0) {
out.println(" Number of lines: " + message.getLineCount());
}
return sout.toString();
}
/**
* @return null, because it's all dynamic
*/
protected Collection getRecipients() {
return null;
}
/**
* @return the original return path, or the sender if missing
*/
protected Collection getRecipients(Mail originalMail) throws MessagingException {
// TODO: use magic RETURN_PATH
Collection recipients = new ArrayList(1);
recipients.add(getExistingReturnPath(originalMail));
if (recipients != null && recipients.size() == 1) {
if (recipients.contains(SpecialAddress.SENDER)) {
recipients = new ArrayList();
recipients.add(originalMail.getSender());
} else if (recipients.contains(SpecialAddress.NULL)) {
// should never get here
throw new MessagingException("SpecialAddress.NULL found getting recipients");
}
}
return recipients;
}
/**
* @return null, because it's all dynamic
*/
protected InternetAddress[] getTo() {
return null;
}
/**
* @return null, indicating to reply to the sender of this reply
*/
protected MailAddress getReplyTo() {
return null;
}
/**
* @return EMPTY (the meaning of bounce)
*/
protected MailAddress getReturnPath() {
return SpecialAddress.NULL;
}
/**
* @return the value of the sendingAddress init parameter if not null,
* the postmaster address otherwise
*/
protected MailAddress getSender() throws MessagingException {
if (getInitParameter("sendingAddress") == null) {
return getMailetContext().getPostmaster();
} else {
return new MailAddress(getInitParameter("sendingAddress"));
}
}
/**
* @return "" (no prefix)
*/
protected String getSubjectPrefix() {
return "";
}
/**
* @return the attachStackTrace init parameter
*/
protected boolean attachError() {
boolean attachStackTrace = false;
try {
attachStackTrace = new Boolean(getInitParameter("attachStackTrace")).booleanValue();
} catch (Exception e) {
// Ignore exception, default to false
}
return attachStackTrace;
}
/**
* @return true
*/
protected boolean isReply() {
return true;
}
/**
* Return a string describing this mailet.
*
* @return a string describing this mailet
*/
public String getMailetInfo() {
return "NotifySender Mailet";
}
/**
* Service does the hard work,and redirects the originalMail in the form specified.
* Checks that the original return path is not empty,
* and then calls super.service(originalMail), otherwise just returns.
*
* @param originalMail the mail to process and redirect
* @throws MessagingException if a problem arises formulating the redirected mail
*/
public void service(Mail originalMail) throws MessagingException {
MailAddress returnAddress = getExistingReturnPath(originalMail);
if (returnAddress == SpecialAddress.NULL) {
if (isDebug)
log("Processing a bounce request for a message with an empty return path. No bounce will be sent.");
return;
} else if (returnAddress == SpecialAddress.SENDER) {
log("WARNING: Mail to be bounced does not contain a Return-Path header.");
} else {
if (isDebug)
log("Processing a bounce request for a message with a return path header. The bounce will be sent to " + returnAddress);
}
super.service(originalMail);
}
/**
* Gets the MailAddress corresponding to the existing "Return-Path" header of
* mail.
* If empty returns EMPTY, if missind return SENDER.
*/
private MailAddress getExistingReturnPath(Mail mail) throws MessagingException {
MailAddress mailAddress = SpecialAddress.SENDER;
String[] returnPathHeaders = mail.getMessage().getHeader(RFC2822Headers.RETURN_PATH);
String returnPathHeader = null;
if (returnPathHeaders != null) {
returnPathHeader = returnPathHeaders[0];
if (returnPathHeader != null) {
returnPathHeader = returnPathHeader.trim();
if (returnPathHeader.equals("<>")) {
mailAddress = SpecialAddress.NULL;
} else {
mailAddress = new MailAddress(new InternetAddress(returnPathHeader));
}
}
}
return mailAddress;
}
}