/****************************************************************
* 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.mailet.base;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.internet.ContentType;
import java.io.IOException;
/**
* <p>Manages texts encoded as <code>text/plain; format=flowed</code>.</p>
* <p>As a reference see:</p>
* <ul>
* <li><a href='http://www.rfc-editor.org/rfc/rfc2646.txt'>RFC2646</a></li>
* <li><a href='http://www.rfc-editor.org/rfc/rfc3676.txt'>RFC3676</a> (new method with DelSP support).
* </ul>
* <h4>Note</h4>
* <ul>
* <li>In order to decode, the input text must belong to a mail with headers similar to:
* Content-Type: text/plain; charset="CHARSET"; [delsp="yes|no"; ]format="flowed"
* (the quotes around CHARSET are not mandatory).
* Furthermore the header Content-Transfer-Encoding MUST NOT BE Quoted-Printable
* (see RFC3676 paragraph 4.2).(In fact this happens often for non 7bit messages).
* </li>
* <li>When encoding the input text will be changed eliminating every space found before CRLF,
* otherwise it won't be possible to recognize hard breaks from soft breaks.
* In this scenario encoding and decoding a message will not return a message identical to
* the original (lines with hard breaks will be trimmed)
* </li>
* </ul>
*/
public final class FlowedMessageUtils {
public static final char RFC2646_SPACE = ' ';
public static final char RFC2646_QUOTE = '>';
public static final String RFC2646_SIGNATURE = "-- ";
public static final String RFC2646_CRLF = "\r\n";
public static final String RFC2646_FROM = "From ";
public static final int RFC2646_WIDTH = 78;
private FlowedMessageUtils() {
// this class cannot be instantiated
}
/**
* Decodes a text previously wrapped using "format=flowed".
*/
public static String deflow(String text, boolean delSp) {
String[] lines = text.split("\r\n|\n", -1);
StringBuffer result = null;
StringBuffer resultLine = new StringBuffer();
int resultLineQuoteDepth = 0;
boolean resultLineFlowed = false;
// One more cycle, to close the last line
for (int i = 0; i <= lines.length; i++) {
String line = i < lines.length ? lines[i] : null;
int actualQuoteDepth = 0;
if (line != null && line.length() > 0) {
if (line.equals(RFC2646_SIGNATURE))
// signature handling (the previous line is not flowed)
resultLineFlowed = false;
else if (line.charAt(0) == RFC2646_QUOTE) {
// Quote
actualQuoteDepth = 1;
while (actualQuoteDepth < line.length() && line.charAt(actualQuoteDepth) == RFC2646_QUOTE) actualQuoteDepth ++;
// if quote-depth changes wrt the previous line then this is not flowed
if (resultLineQuoteDepth != actualQuoteDepth) resultLineFlowed = false;
line = line.substring(actualQuoteDepth);
} else {
// id quote-depth changes wrt the first line then this is not flowed
if (resultLineQuoteDepth > 0) resultLineFlowed = false;
}
if (line.length() > 0 && line.charAt(0) == RFC2646_SPACE)
// Line space-stuffed
line = line.substring(1);
// if the previous was the last then it was not flowed
} else if (line == null) resultLineFlowed = false;
// Add the PREVIOUS line.
// This often will find the flow looking for a space as the last char of the line.
// With quote changes or signatures it could be the followinf line to void the flow.
if (!resultLineFlowed && i > 0) {
if (resultLineQuoteDepth > 0) resultLine.insert(0, RFC2646_SPACE);
for (int j = 0; j < resultLineQuoteDepth; j++) resultLine.insert(0, RFC2646_QUOTE);
if (result == null) result = new StringBuffer();
else result.append(RFC2646_CRLF);
result.append(resultLine.toString());
resultLine = new StringBuffer();
resultLineFlowed = false;
}
resultLineQuoteDepth = actualQuoteDepth;
if (line != null) {
if (!line.equals(RFC2646_SIGNATURE) && line.endsWith("" + RFC2646_SPACE) && i < lines.length - 1) {
// Line flowed (NOTE: for the split operation the line having i == lines.length is the last that does not end with RFC2646_CRLF)
if (delSp) line = line.substring(0, line.length() - 1);
resultLineFlowed = true;
}
else resultLineFlowed = false;
resultLine.append(line);
}
}
return result.toString();
}
/**
* Obtains the content of the encoded message, if previously encoded as <code>format=flowed</code>.
*/
public static String deflow(Message m) throws IOException, MessagingException {
ContentType ct = new ContentType(m.getContentType());
String format = ct.getParameter("format");
if (ct.getBaseType().equals("text/plain") && format != null && format.equalsIgnoreCase("flowed")) {
String delSp = ct.getParameter("delsp");
return deflow((String) m.getContent(), delSp != null && delSp.equalsIgnoreCase("yes"));
} else if (ct.getPrimaryType().equals("text")) return (String) m.getContent();
else return null;
}
/**
* If the message is <code>format=flowed</code>
* set the encoded version as message content.
*/
public static void deflowMessage(Message m) throws MessagingException, IOException {
ContentType ct = new ContentType(m.getContentType());
String format = ct.getParameter("format");
if (ct.getBaseType().equals("text/plain") && format != null && format.equalsIgnoreCase("flowed")) {
String delSp = ct.getParameter("delsp");
String deflowed = deflow((String) m.getContent(), delSp != null && delSp.equalsIgnoreCase("yes"));
ct.getParameterList().remove("format");
ct.getParameterList().remove("delsp");
if (ct.toString().indexOf("flowed") >= 0)
System.out.println("\n\n*************************\n* ERROR!!! FlowedMessageUtils dind't remove the flowed correctly!\n******************\n\n" + ct.toString() + " \n " + ct.toString() + "\n");
m.setContent(deflowed, ct.toString());
m.saveChanges();
}
}
/**
* Encodes a text (using standard with).
*/
public static String flow(String text, boolean delSp) {
return flow(text, delSp, RFC2646_WIDTH);
}
/**
* Decodes a text.
*/
public static String flow(String text, boolean delSp, int width) {
StringBuffer result = new StringBuffer();
String[] lines = text.split("\r\n|\n", -1);
for (int i = 0; i < lines.length; i ++) {
String line = lines[i];
boolean notempty = line.length() > 0;
int quoteDepth = 0;
while (quoteDepth < line.length() && line.charAt(quoteDepth) == RFC2646_QUOTE) quoteDepth ++;
if (quoteDepth > 0) {
if (quoteDepth + 1 < line.length() && line.charAt(quoteDepth) == RFC2646_SPACE) line = line.substring(quoteDepth + 1);
else line = line.substring(quoteDepth);
}
while (notempty) {
int extra = 0;
if (quoteDepth == 0) {
if (line.startsWith("" + RFC2646_SPACE) || line.startsWith("" + RFC2646_QUOTE) || line.startsWith(RFC2646_FROM)) {
line = "" + RFC2646_SPACE + line;
extra = 1;
}
} else {
line = RFC2646_SPACE + line;
for (int j = 0; j < quoteDepth; j++) line = "" + RFC2646_QUOTE + line;
extra = quoteDepth + 1;
}
int j = width - 1;
if (j >= line.length()) j = line.length() - 1;
else {
while (j >= extra && ((delSp && isAlphaChar(text, j)) || (!delSp && line.charAt(j) != RFC2646_SPACE))) j --;
if (j < extra) {
// Not able to cut a word: skip to word end even if greater than the max width
j = width - 1;
while (j < line.length() - 1 && ((delSp && isAlphaChar(text, j)) || (!delSp && line.charAt(j) != RFC2646_SPACE))) j ++;
}
}
result.append(line.substring(0, j + 1));
if (j < line.length() - 1) {
if (delSp) result.append(RFC2646_SPACE);
result.append(RFC2646_CRLF);
}
line = line.substring(j + 1);
notempty = line.length() > 0;
}
if (i < lines.length - 1) {
// NOTE: Have to trim the spaces before, otherwise it won't recognize soft-break from hard break.
// Deflow of flowed message will not be identical to the original.
while (result.length() > 0 && result.charAt(result.length() - 1) == RFC2646_SPACE) result.deleteCharAt(result.length() - 1);
result.append(RFC2646_CRLF);
}
}
return result.toString();
}
/**
* Encodes the input text and sets it as the new message content.
*/
public static void setFlowedContent(Message m, String text, boolean delSp) throws MessagingException {
setFlowedContent(m, text, delSp, RFC2646_WIDTH, true, null);
}
/**
* Encodes the input text and sets it as the new message content.
*/
public static void setFlowedContent(Message m, String text, boolean delSp, int width, boolean preserveCharset, String charset) throws MessagingException {
String coded = flow(text, delSp, width);
if (preserveCharset) {
ContentType ct = new ContentType(m.getContentType());
charset = ct.getParameter("charset");
}
ContentType ct = new ContentType();
ct.setPrimaryType("text");
ct.setSubType("plain");
if (charset != null) ct.setParameter("charset", charset);
ct.setParameter("format", "flowed");
if (delSp) ct.setParameter("delsp", "yes");
m.setContent(coded, ct.toString());
m.saveChanges();
}
/**
* Encodes the message content (if text/plain).
*/
public static void flowMessage(Message m, boolean delSp) throws MessagingException, IOException {
flowMessage(m, delSp, RFC2646_WIDTH);
}
/**
* Encodes the message content (if text/plain).
*/
public static void flowMessage(Message m, boolean delSp, int width) throws MessagingException, IOException {
ContentType ct = new ContentType(m.getContentType());
if (!ct.getBaseType().equals("text/plain")) return;
String format = ct.getParameter("format");
String text = format != null && format.equals("flowed") ? deflow(m) : (String) m.getContent();
String coded = flow(text, delSp, width);
ct.setParameter("format", "flowed");
if (delSp) ct.setParameter("delsp", "yes");
m.setContent(coded, ct.toString());
m.saveChanges();
}
/**
* Checks whether the char is part of a word.
* <p>RFC assert a word cannot be splitted (even if the length is greater than the maximum length).
*/
public static boolean isAlphaChar(String text, int index) {
// Note: a list of chars is available here:
// http://www.zvon.org/tmRFC/RFC2646/Output/index.html
char c = text.charAt(index);
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
}
/**
* Checks whether the input message is <code>format=flowed</code>.
*/
public static boolean isFlowedTextMessage(Message m) throws MessagingException {
ContentType ct = new ContentType(m.getContentType());
String format = ct.getParameter("format");
return ct.getBaseType().equals("text/plain") && format != null && format.equalsIgnoreCase("flowed");
}
}