| /* |
| * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @(#)MimeUtility.java 1.45 03/03/10 |
| */ |
| |
| |
| |
| package com.sun.xml.internal.messaging.saaj.packaging.mime.internet; |
| |
| import java.io.*; |
| import java.util.*; |
| |
| import javax.activation.DataHandler; |
| import javax.activation.DataSource; |
| |
| import com.sun.xml.internal.messaging.saaj.packaging.mime.MessagingException; |
| import com.sun.xml.internal.messaging.saaj.packaging.mime.util.*; |
| import com.sun.xml.internal.messaging.saaj.util.SAAJUtil; |
| |
| /** |
| * This is a utility class that provides various MIME related |
| * functionality. <p> |
| * |
| * There are a set of methods to encode and decode MIME headers as |
| * per RFC 2047. A brief description on handling such headers is |
| * given below: <p> |
| * |
| * RFC 822 mail headers <strong>must</strong> contain only US-ASCII |
| * characters. Headers that contain non US-ASCII characters must be |
| * encoded so that they contain only US-ASCII characters. Basically, |
| * this process involves using either BASE64 or QP to encode certain |
| * characters. RFC 2047 describes this in detail. <p> |
| * |
| * In Java, Strings contain (16 bit) Unicode characters. ASCII is a |
| * subset of Unicode (and occupies the range 0 - 127). A String |
| * that contains only ASCII characters is already mail-safe. If the |
| * String contains non US-ASCII characters, it must be encoded. An |
| * additional complexity in this step is that since Unicode is not |
| * yet a widely used charset, one might want to first charset-encode |
| * the String into another charset and then do the transfer-encoding. |
| * <p> |
| * Note that to get the actual bytes of a mail-safe String (say, |
| * for sending over SMTP), one must do |
| * <p><blockquote><pre> |
| * |
| * byte[] bytes = string.getBytes("iso-8859-1"); |
| * |
| * </pre></blockquote><p> |
| * |
| * The <code>setHeader</code> and <code>addHeader</code> methods |
| * on MimeMessage and MimeBodyPart assume that the given header values |
| * are Unicode strings that contain only US-ASCII characters. Hence |
| * the callers of those methods must insure that the values they pass |
| * do not contain non US-ASCII characters. The methods in this class |
| * help do this. <p> |
| * |
| * The <code>getHeader</code> family of methods on MimeMessage and |
| * MimeBodyPart return the raw header value. These might be encoded |
| * as per RFC 2047, and if so, must be decoded into Unicode Strings. |
| * The methods in this class help to do this. <p> |
| * |
| * Several System properties control strict conformance to the MIME |
| * spec. Note that these are not session properties but must be set |
| * globally as System properties. <p> |
| * |
| * The <code>mail.mime.decodetext.strict</code> property controls |
| * decoding of MIME encoded words. The MIME spec requires that encoded |
| * words start at the beginning of a whitespace separated word. Some |
| * mailers incorrectly include encoded words in the middle of a word. |
| * If the <code>mail.mime.decodetext.strict</code> System property is |
| * set to <code>"false"</code>, an attempt will be made to decode these |
| * illegal encoded words. The default is true. <p> |
| * |
| * The <code>mail.mime.encodeeol.strict</code> property controls the |
| * choice of Content-Transfer-Encoding for MIME parts that are not of |
| * type "text". Often such parts will contain textual data for which |
| * an encoding that allows normal end of line conventions is appropriate. |
| * In rare cases, such a part will appear to contain entirely textual |
| * data, but will require an encoding that preserves CR and LF characters |
| * without change. If the <code>mail.mime.decodetext.strict</code> |
| * System property is set to <code>"true"</code>, such an encoding will |
| * be used when necessary. The default is false. <p> |
| * |
| * In addition, the <code>mail.mime.charset</code> System property can |
| * be used to specify the default MIME charset to use for encoded words |
| * and text parts that don't otherwise specify a charset. Normally, the |
| * default MIME charset is derived from the default Java charset, as |
| * specified in the <code>file.encoding</code> System property. Most |
| * applications will have no need to explicitly set the default MIME |
| * charset. In cases where the default MIME charset to be used for |
| * mail messages is different than the charset used for files stored on |
| * the system, this property should be set. |
| * |
| * @version 1.45, 03/03/10 |
| * @author John Mani |
| * @author Bill Shannon |
| */ |
| |
| public class MimeUtility { |
| |
| // This class cannot be instantiated |
| private MimeUtility() { } |
| |
| public static final int ALL = -1; |
| |
| private static final int BUFFER_SIZE = 1024; |
| private static boolean decodeStrict = true; |
| private static boolean encodeEolStrict = false; |
| private static boolean foldEncodedWords = false; |
| private static boolean foldText = true; |
| |
| static { |
| try { |
| String s = SAAJUtil.getSystemProperty("mail.mime.decodetext.strict"); |
| // default to true |
| decodeStrict = s == null || !s.equalsIgnoreCase("false"); |
| s = SAAJUtil.getSystemProperty("mail.mime.encodeeol.strict"); |
| // default to false |
| encodeEolStrict = s != null && s.equalsIgnoreCase("true"); |
| s = SAAJUtil.getSystemProperty("mail.mime.foldencodedwords"); |
| // default to false |
| foldEncodedWords = s != null && s.equalsIgnoreCase("true"); |
| s = SAAJUtil.getSystemProperty("mail.mime.foldtext"); |
| // default to true |
| foldText = s == null || !s.equalsIgnoreCase("false"); |
| } catch (SecurityException sex) { |
| // ignore it |
| } |
| } |
| |
| |
| /** |
| * Get the content-transfer-encoding that should be applied |
| * to the input stream of this datasource, to make it mailsafe. <p> |
| * |
| * The algorithm used here is: <br> |
| * <ul> |
| * <li> |
| * If the primary type of this datasource is "text" and if all |
| * the bytes in its input stream are US-ASCII, then the encoding |
| * is "7bit". If more than half of the bytes are non-US-ASCII, then |
| * the encoding is "base64". If less than half of the bytes are |
| * non-US-ASCII, then the encoding is "quoted-printable". |
| * <li> |
| * If the primary type of this datasource is not "text", then if |
| * all the bytes of its input stream are US-ASCII, the encoding |
| * is "7bit". If there is even one non-US-ASCII character, the |
| * encoding is "base64". |
| * </ul> |
| * |
| * @param ds DataSource |
| * @return the encoding. This is either "7bit", |
| * "quoted-printable" or "base64" |
| */ |
| public static String getEncoding(DataSource ds) { |
| ContentType cType = null; |
| InputStream is = null; |
| String encoding = null; |
| |
| try { |
| cType = new ContentType(ds.getContentType()); |
| is = ds.getInputStream(); |
| } catch (Exception ex) { |
| return "base64"; // what else ?! |
| } |
| |
| boolean isText = cType.match("text/*"); |
| // if not text, stop processing when we see non-ASCII |
| int i = checkAscii(is, ALL, !isText); |
| switch (i) { |
| case ALL_ASCII: |
| encoding = "7bit"; // all ascii |
| break; |
| case MOSTLY_ASCII: |
| encoding = "quoted-printable"; // mostly ascii |
| break; |
| default: |
| encoding = "base64"; // mostly binary |
| break; |
| } |
| |
| // Close the input stream |
| try { |
| is.close(); |
| } catch (IOException ioex) { } |
| |
| return encoding; |
| } |
| |
| /** |
| * Same as <code>getEncoding(DataSource)</code> except that instead |
| * of reading the data from an <code>InputStream</code> it uses the |
| * <code>writeTo</code> method to examine the data. This is more |
| * efficient in the common case of a <code>DataHandler</code> |
| * created with an object and a MIME type (for example, a |
| * "text/plain" String) because all the I/O is done in this |
| * thread. In the case requiring an <code>InputStream</code> the |
| * <code>DataHandler</code> uses a thread, a pair of pipe streams, |
| * and the <code>writeTo</code> method to produce the data. <p> |
| * |
| * @since JavaMail 1.2 |
| */ |
| public static String getEncoding(DataHandler dh) { |
| ContentType cType = null; |
| String encoding = null; |
| |
| /* |
| * Try to pick the most efficient means of determining the |
| * encoding. If this DataHandler was created using a DataSource, |
| * the getEncoding(DataSource) method is typically faster. If |
| * the DataHandler was created with an object, this method is |
| * much faster. To distinguish the two cases, we use a heuristic. |
| * A DataHandler created with an object will always have a null name. |
| * A DataHandler created with a DataSource will usually have a |
| * non-null name. |
| * |
| * XXX - This is actually quite a disgusting hack, but it makes |
| * a common case run over twice as fast. |
| */ |
| if (dh.getName() != null) |
| return getEncoding(dh.getDataSource()); |
| |
| try { |
| cType = new ContentType(dh.getContentType()); |
| } catch (Exception ex) { |
| return "base64"; // what else ?! |
| } |
| |
| if (cType.match("text/*")) { |
| // Check all of the available bytes |
| AsciiOutputStream aos = new AsciiOutputStream(false, false); |
| try { |
| dh.writeTo(aos); |
| } catch (IOException ex) { } // ignore it |
| switch (aos.getAscii()) { |
| case ALL_ASCII: |
| encoding = "7bit"; // all ascii |
| break; |
| case MOSTLY_ASCII: |
| encoding = "quoted-printable"; // mostly ascii |
| break; |
| default: |
| encoding = "base64"; // mostly binary |
| break; |
| } |
| } else { // not "text" |
| // Check all of available bytes, break out if we find |
| // at least one non-US-ASCII character |
| AsciiOutputStream aos = |
| new AsciiOutputStream(true, encodeEolStrict); |
| try { |
| dh.writeTo(aos); |
| } catch (IOException ex) { } // ignore it |
| if (aos.getAscii() == ALL_ASCII) // all ascii |
| encoding = "7bit"; |
| else // found atleast one non-ascii character, use b64 |
| encoding = "base64"; |
| } |
| |
| return encoding; |
| } |
| |
| /** |
| * Decode the given input stream. The Input stream returned is |
| * the decoded input stream. All the encodings defined in RFC 2045 |
| * are supported here. They include "base64", "quoted-printable", |
| * "7bit", "8bit", and "binary". In addition, "uuencode" is also |
| * supported. |
| * |
| * @param is input stream |
| * @param encoding the encoding of the stream. |
| * @return decoded input stream. |
| */ |
| public static InputStream decode(InputStream is, String encoding) |
| throws MessagingException { |
| if (encoding.equalsIgnoreCase("base64")) |
| return new BASE64DecoderStream(is); |
| else if (encoding.equalsIgnoreCase("quoted-printable")) |
| return new QPDecoderStream(is); |
| else if (encoding.equalsIgnoreCase("uuencode") || |
| encoding.equalsIgnoreCase("x-uuencode") || |
| encoding.equalsIgnoreCase("x-uue")) |
| return new UUDecoderStream(is); |
| else if (encoding.equalsIgnoreCase("binary") || |
| encoding.equalsIgnoreCase("7bit") || |
| encoding.equalsIgnoreCase("8bit")) |
| return is; |
| else |
| throw new MessagingException("Unknown encoding: " + encoding); |
| } |
| |
| /** |
| * Wrap an encoder around the given output stream. |
| * All the encodings defined in RFC 2045 are supported here. |
| * They include "base64", "quoted-printable", "7bit", "8bit" and |
| * "binary". In addition, "uuencode" is also supported. |
| * |
| * @param os output stream |
| * @param encoding the encoding of the stream. |
| * @return output stream that applies the |
| * specified encoding. |
| */ |
| public static OutputStream encode(OutputStream os, String encoding) |
| throws MessagingException { |
| if (encoding == null) |
| return os; |
| else if (encoding.equalsIgnoreCase("base64")) |
| return new BASE64EncoderStream(os); |
| else if (encoding.equalsIgnoreCase("quoted-printable")) |
| return new QPEncoderStream(os); |
| else if (encoding.equalsIgnoreCase("uuencode") || |
| encoding.equalsIgnoreCase("x-uuencode") || |
| encoding.equalsIgnoreCase("x-uue")) |
| return new UUEncoderStream(os); |
| else if (encoding.equalsIgnoreCase("binary") || |
| encoding.equalsIgnoreCase("7bit") || |
| encoding.equalsIgnoreCase("8bit")) |
| return os; |
| else |
| throw new MessagingException("Unknown encoding: " +encoding); |
| } |
| |
| /** |
| * Wrap an encoder around the given output stream. |
| * All the encodings defined in RFC 2045 are supported here. |
| * They include "base64", "quoted-printable", "7bit", "8bit" and |
| * "binary". In addition, "uuencode" is also supported. |
| * The <code>filename</code> parameter is used with the "uuencode" |
| * encoding and is included in the encoded output. |
| * |
| * @param os output stream |
| * @param encoding the encoding of the stream. |
| * @param filename name for the file being encoded (only used |
| * with uuencode) |
| * @return output stream that applies the |
| * specified encoding. |
| * @since JavaMail 1.2 |
| */ |
| public static OutputStream encode(OutputStream os, String encoding, |
| String filename) |
| throws MessagingException { |
| if (encoding == null) |
| return os; |
| else if (encoding.equalsIgnoreCase("base64")) |
| return new BASE64EncoderStream(os); |
| else if (encoding.equalsIgnoreCase("quoted-printable")) |
| return new QPEncoderStream(os); |
| else if (encoding.equalsIgnoreCase("uuencode") || |
| encoding.equalsIgnoreCase("x-uuencode") || |
| encoding.equalsIgnoreCase("x-uue")) |
| return new UUEncoderStream(os, filename); |
| else if (encoding.equalsIgnoreCase("binary") || |
| encoding.equalsIgnoreCase("7bit") || |
| encoding.equalsIgnoreCase("8bit")) |
| return os; |
| else |
| throw new MessagingException("Unknown encoding: " +encoding); |
| } |
| |
| /** |
| * Encode a RFC 822 "text" token into mail-safe form as per |
| * RFC 2047. <p> |
| * |
| * The given Unicode string is examined for non US-ASCII |
| * characters. If the string contains only US-ASCII characters, |
| * it is returned as-is. If the string contains non US-ASCII |
| * characters, it is first character-encoded using the platform's |
| * default charset, then transfer-encoded using either the B or |
| * Q encoding. The resulting bytes are then returned as a Unicode |
| * string containing only ASCII characters. <p> |
| * |
| * Note that this method should be used to encode only |
| * "unstructured" RFC 822 headers. <p> |
| * |
| * Example of usage: |
| * <p><blockquote><pre> |
| * |
| * MimeBodyPart part = ... |
| * String rawvalue = "FooBar Mailer, Japanese version 1.1" |
| * try { |
| * // If we know for sure that rawvalue contains only US-ASCII |
| * // characters, we can skip the encoding part |
| * part.setHeader("X-mailer", MimeUtility.encodeText(rawvalue)); |
| * } catch (UnsupportedEncodingException e) { |
| * // encoding failure |
| * } catch (MessagingException me) { |
| * // setHeader() failure |
| * } |
| * |
| * </pre></blockquote><p> |
| * |
| * @param text unicode string |
| * @return Unicode string containing only US-ASCII characters |
| * @exception UnsupportedEncodingException if the encoding fails |
| */ |
| public static String encodeText(String text) |
| throws UnsupportedEncodingException { |
| return encodeText(text, null, null); |
| } |
| |
| /** |
| * Encode a RFC 822 "text" token into mail-safe form as per |
| * RFC 2047. <p> |
| * |
| * The given Unicode string is examined for non US-ASCII |
| * characters. If the string contains only US-ASCII characters, |
| * it is returned as-is. If the string contains non US-ASCII |
| * characters, it is first character-encoded using the specified |
| * charset, then transfer-encoded using either the B or Q encoding. |
| * The resulting bytes are then returned as a Unicode string |
| * containing only ASCII characters. <p> |
| * |
| * Note that this method should be used to encode only |
| * "unstructured" RFC 822 headers. |
| * |
| * @param text the header value |
| * @param charset the charset. If this parameter is null, the |
| * platform's default chatset is used. |
| * @param encoding the encoding to be used. Currently supported |
| * values are "B" and "Q". If this parameter is null, then |
| * the "Q" encoding is used if most of characters to be |
| * encoded are in the ASCII charset, otherwise "B" encoding |
| * is used. |
| * @return Unicode string containing only US-ASCII characters |
| */ |
| public static String encodeText(String text, String charset, |
| String encoding) |
| throws UnsupportedEncodingException { |
| return encodeWord(text, charset, encoding, false); |
| } |
| |
| /** |
| * Decode "unstructured" headers, that is, headers that are defined |
| * as '*text' as per RFC 822. <p> |
| * |
| * The string is decoded using the algorithm specified in |
| * RFC 2047, Section 6.1.1. If the charset-conversion fails |
| * for any sequence, an UnsupportedEncodingException is thrown. |
| * If the String is not an RFC 2047 style encoded header, it is |
| * returned as-is <p> |
| * |
| * Example of usage: |
| * <p><blockquote><pre> |
| * |
| * MimeBodyPart part = ... |
| * String rawvalue = null; |
| * String value = null; |
| * try { |
| * if ((rawvalue = part.getHeader("X-mailer")[0]) != null) |
| * value = MimeUtility.decodeText(rawvalue); |
| * } catch (UnsupportedEncodingException e) { |
| * // Don't care |
| * value = rawvalue; |
| * } catch (MessagingException me) { } |
| * |
| * return value; |
| * |
| * </pre></blockquote><p> |
| * |
| * @param etext the possibly encoded value |
| * @exception UnsupportedEncodingException if the charset |
| * conversion failed. |
| */ |
| public static String decodeText(String etext) |
| throws UnsupportedEncodingException { |
| /* |
| * We look for sequences separated by "linear-white-space". |
| * (as per RFC 2047, Section 6.1.1) |
| * RFC 822 defines "linear-white-space" as SPACE | HT | CR | NL. |
| */ |
| String lwsp = " \t\n\r"; |
| StringTokenizer st; |
| |
| /* |
| * First, lets do a quick run thru the string and check |
| * whether the sequence "=?" exists at all. If none exists, |
| * we know there are no encoded-words in here and we can just |
| * return the string as-is, without suffering thru the later |
| * decoding logic. |
| * This handles the most common case of unencoded headers |
| * efficiently. |
| */ |
| if (etext.indexOf("=?") == -1) |
| return etext; |
| |
| // Encoded words found. Start decoding ... |
| |
| st = new StringTokenizer(etext, lwsp, true); |
| StringBuffer sb = new StringBuffer(); // decode buffer |
| StringBuffer wsb = new StringBuffer(); // white space buffer |
| boolean prevWasEncoded = false; |
| |
| while (st.hasMoreTokens()) { |
| char c; |
| String s = st.nextToken(); |
| // If whitespace, append it to the whitespace buffer |
| if (((c = s.charAt(0)) == ' ') || (c == '\t') || |
| (c == '\r') || (c == '\n')) |
| wsb.append(c); |
| else { |
| // Check if token is an 'encoded-word' .. |
| String word; |
| try { |
| word = decodeWord(s); |
| // Yes, this IS an 'encoded-word'. |
| if (!prevWasEncoded && wsb.length() > 0) { |
| // if the previous word was also encoded, we |
| // should ignore the collected whitespace. Else |
| // we include the whitespace as well. |
| sb.append(wsb); |
| } |
| prevWasEncoded = true; |
| } catch (ParseException pex) { |
| // This is NOT an 'encoded-word'. |
| word = s; |
| // possibly decode inner encoded words |
| if (!decodeStrict) |
| word = decodeInnerWords(word); |
| // include colleced whitespace .. |
| if (wsb.length() > 0) |
| sb.append(wsb); |
| prevWasEncoded = false; |
| } |
| sb.append(word); // append the actual word |
| wsb.setLength(0); // reset wsb for reuse |
| } |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Encode a RFC 822 "word" token into mail-safe form as per |
| * RFC 2047. <p> |
| * |
| * The given Unicode string is examined for non US-ASCII |
| * characters. If the string contains only US-ASCII characters, |
| * it is returned as-is. If the string contains non US-ASCII |
| * characters, it is first character-encoded using the platform's |
| * default charset, then transfer-encoded using either the B or |
| * Q encoding. The resulting bytes are then returned as a Unicode |
| * string containing only ASCII characters. <p> |
| * |
| * This method is meant to be used when creating RFC 822 "phrases". |
| * The InternetAddress class, for example, uses this to encode |
| * it's 'phrase' component. |
| * |
| * @param text unicode string |
| * @return Array of Unicode strings containing only US-ASCII |
| * characters. |
| * @exception UnsupportedEncodingException if the encoding fails |
| */ |
| public static String encodeWord(String word) |
| throws UnsupportedEncodingException { |
| return encodeWord(word, null, null); |
| } |
| |
| /** |
| * Encode a RFC 822 "word" token into mail-safe form as per |
| * RFC 2047. <p> |
| * |
| * The given Unicode string is examined for non US-ASCII |
| * characters. If the string contains only US-ASCII characters, |
| * it is returned as-is. If the string contains non US-ASCII |
| * characters, it is first character-encoded using the specified |
| * charset, then transfer-encoded using either the B or Q encoding. |
| * The resulting bytes are then returned as a Unicode string |
| * containing only ASCII characters. <p> |
| * |
| * @param text unicode string |
| * @param charset the MIME charset |
| * @param encoding the encoding to be used. Currently supported |
| * values are "B" and "Q". If this parameter is null, then |
| * the "Q" encoding is used if most of characters to be |
| * encoded are in the ASCII charset, otherwise "B" encoding |
| * is used. |
| * @return Unicode string containing only US-ASCII characters |
| * @exception UnsupportedEncodingException if the encoding fails |
| */ |
| public static String encodeWord(String word, String charset, |
| String encoding) |
| throws UnsupportedEncodingException { |
| return encodeWord(word, charset, encoding, true); |
| } |
| |
| /* |
| * Encode the given string. The parameter 'encodingWord' should |
| * be true if a RFC 822 "word" token is being encoded and false if a |
| * RFC 822 "text" token is being encoded. This is because the |
| * "Q" encoding defined in RFC 2047 has more restrictions when |
| * encoding "word" tokens. (Sigh) |
| */ |
| private static String encodeWord(String string, String charset, |
| String encoding, boolean encodingWord) |
| throws UnsupportedEncodingException { |
| |
| // If 'string' contains only US-ASCII characters, just |
| // return it. |
| int ascii = checkAscii(string); |
| if (ascii == ALL_ASCII) |
| return string; |
| |
| // Else, apply the specified charset conversion. |
| String jcharset; |
| if (charset == null) { // use default charset |
| jcharset = getDefaultJavaCharset(); // the java charset |
| charset = getDefaultMIMECharset(); // the MIME equivalent |
| } else // MIME charset -> java charset |
| jcharset = javaCharset(charset); |
| |
| // If no transfer-encoding is specified, figure one out. |
| if (encoding == null) { |
| if (ascii != MOSTLY_NONASCII) |
| encoding = "Q"; |
| else |
| encoding = "B"; |
| } |
| |
| boolean b64; |
| if (encoding.equalsIgnoreCase("B")) |
| b64 = true; |
| else if (encoding.equalsIgnoreCase("Q")) |
| b64 = false; |
| else |
| throw new UnsupportedEncodingException( |
| "Unknown transfer encoding: " + encoding); |
| |
| StringBuffer outb = new StringBuffer(); // the output buffer |
| doEncode(string, b64, jcharset, |
| // As per RFC 2047, size of an encoded string should not |
| // exceed 75 bytes. |
| // 7 = size of "=?", '?', 'B'/'Q', '?', "?=" |
| 75 - 7 - charset.length(), // the available space |
| "=?" + charset + "?" + encoding + "?", // prefix |
| true, encodingWord, outb); |
| |
| return outb.toString(); |
| } |
| |
| private static void doEncode(String string, boolean b64, |
| String jcharset, int avail, String prefix, |
| boolean first, boolean encodingWord, StringBuffer buf) |
| throws UnsupportedEncodingException { |
| |
| // First find out what the length of the encoded version of |
| // 'string' would be. |
| byte[] bytes = string.getBytes(jcharset); |
| int len; |
| if (b64) // "B" encoding |
| len = BEncoderStream.encodedLength(bytes); |
| else // "Q" |
| len = QEncoderStream.encodedLength(bytes, encodingWord); |
| |
| int size; |
| if ((len > avail) && ((size = string.length()) > 1)) { |
| // If the length is greater than 'avail', split 'string' |
| // into two and recurse. |
| doEncode(string.substring(0, size/2), b64, jcharset, |
| avail, prefix, first, encodingWord, buf); |
| doEncode(string.substring(size/2, size), b64, jcharset, |
| avail, prefix, false, encodingWord, buf); |
| } else { |
| // length <= than 'avail'. Encode the given string |
| ByteArrayOutputStream os = new ByteArrayOutputStream(BUFFER_SIZE); |
| OutputStream eos; // the encoder |
| if (b64) // "B" encoding |
| eos = new BEncoderStream(os); |
| else // "Q" encoding |
| eos = new QEncoderStream(os, encodingWord); |
| |
| try { // do the encoding |
| eos.write(bytes); |
| eos.close(); |
| } catch (IOException ioex) { } |
| |
| byte[] encodedBytes = os.toByteArray(); // the encoded stuff |
| // Now write out the encoded (all ASCII) bytes into our |
| // StringBuffer |
| if (!first) // not the first line of this sequence |
| if (foldEncodedWords) |
| buf.append("\r\n "); // start a continuation line |
| else |
| buf.append(" "); // line will be folded later |
| |
| buf.append(prefix); |
| for (int i = 0; i < encodedBytes.length; i++) |
| buf.append((char)encodedBytes[i]); |
| buf.append("?="); // terminate the current sequence |
| } |
| } |
| |
| /** |
| * The string is parsed using the rules in RFC 2047 for parsing |
| * an "encoded-word". If the parse fails, a ParseException is |
| * thrown. Otherwise, it is transfer-decoded, and then |
| * charset-converted into Unicode. If the charset-conversion |
| * fails, an UnsupportedEncodingException is thrown.<p> |
| * |
| * @param eword the possibly encoded value |
| * @exception ParseException if the string is not an |
| * encoded-word as per RFC 2047. |
| * @exception UnsupportedEncodingException if the charset |
| * conversion failed. |
| */ |
| public static String decodeWord(String eword) |
| throws ParseException, UnsupportedEncodingException { |
| |
| if (!eword.startsWith("=?")) // not an encoded word |
| throw new ParseException(); |
| |
| // get charset |
| int start = 2; int pos; |
| if ((pos = eword.indexOf('?', start)) == -1) |
| throw new ParseException(); |
| String charset = javaCharset(eword.substring(start, pos)); |
| |
| // get encoding |
| start = pos+1; |
| if ((pos = eword.indexOf('?', start)) == -1) |
| throw new ParseException(); |
| String encoding = eword.substring(start, pos); |
| |
| // get encoded-sequence |
| start = pos+1; |
| if ((pos = eword.indexOf("?=", start)) == -1) |
| throw new ParseException(); |
| String word = eword.substring(start, pos); |
| |
| try { |
| // Extract the bytes from word |
| ByteArrayInputStream bis = |
| new ByteArrayInputStream(ASCIIUtility.getBytes(word)); |
| |
| // Get the appropriate decoder |
| InputStream is; |
| if (encoding.equalsIgnoreCase("B")) |
| is = new BASE64DecoderStream(bis); |
| else if (encoding.equalsIgnoreCase("Q")) |
| is = new QDecoderStream(bis); |
| else |
| throw new UnsupportedEncodingException( |
| "unknown encoding: " + encoding); |
| |
| // For b64 & q, size of decoded word <= size of word. So |
| // the decoded bytes must fit into the 'bytes' array. This |
| // is certainly more efficient than writing bytes into a |
| // ByteArrayOutputStream and then pulling out the byte[] |
| // from it. |
| int count = bis.available(); |
| byte[] bytes = new byte[count]; |
| // count is set to the actual number of decoded bytes |
| count = is.read(bytes, 0, count); |
| |
| // Finally, convert the decoded bytes into a String using |
| // the specified charset |
| String s = new String(bytes, 0, count, charset); |
| if (pos + 2 < eword.length()) { |
| // there's still more text in the string |
| String rest = eword.substring(pos + 2); |
| if (!decodeStrict) |
| rest = decodeInnerWords(rest); |
| s += rest; |
| } |
| return s; |
| } catch (UnsupportedEncodingException uex) { |
| // explicitly catch and rethrow this exception, otherwise |
| // the below IOException catch will swallow this up! |
| throw uex; |
| } catch (IOException ioex) { |
| // Shouldn't happen. |
| throw new ParseException(); |
| } catch (IllegalArgumentException iex) { |
| /* An unknown charset of the form ISO-XXX-XXX, will cause |
| * the JDK to throw an IllegalArgumentException ... Since the |
| * JDK will attempt to create a classname using this string, |
| * but valid classnames must not contain the character '-', |
| * and this results in an IllegalArgumentException, rather than |
| * the expected UnsupportedEncodingException. Yikes |
| */ |
| throw new UnsupportedEncodingException(); |
| } |
| } |
| |
| /** |
| * Look for encoded words within a word. The MIME spec doesn't |
| * allow this, but many broken mailers, especially Japanese mailers, |
| * produce such incorrect encodings. |
| */ |
| private static String decodeInnerWords(String word) |
| throws UnsupportedEncodingException { |
| int start = 0, i; |
| StringBuffer buf = new StringBuffer(); |
| while ((i = word.indexOf("=?", start)) >= 0) { |
| buf.append(word.substring(start, i)); |
| int end = word.indexOf("?=", i); |
| if (end < 0) |
| break; |
| String s = word.substring(i, end + 2); |
| try { |
| s = decodeWord(s); |
| } catch (ParseException pex) { |
| // ignore it, just use the original string |
| } |
| buf.append(s); |
| start = end + 2; |
| } |
| if (start == 0) |
| return word; |
| if (start < word.length()) |
| buf.append(word.substring(start)); |
| return buf.toString(); |
| } |
| |
| /** |
| * A utility method to quote a word, if the word contains any |
| * characters from the specified 'specials' list.<p> |
| * |
| * The <code>HeaderTokenizer</code> class defines two special |
| * sets of delimiters - MIME and RFC 822. <p> |
| * |
| * This method is typically used during the generation of |
| * RFC 822 and MIME header fields. |
| * |
| * @param word word to be quoted |
| * @param specials the set of special characters |
| * @return the possibly quoted word |
| * @see javax.mail.internet.HeaderTokenizer#MIME |
| * @see javax.mail.internet.HeaderTokenizer#RFC822 |
| */ |
| public static String quote(String word, String specials) { |
| int len = word.length(); |
| |
| /* |
| * Look for any "bad" characters, Escape and |
| * quote the entire string if necessary. |
| */ |
| boolean needQuoting = false; |
| for (int i = 0; i < len; i++) { |
| char c = word.charAt(i); |
| if (c == '"' || c == '\\' || c == '\r' || c == '\n') { |
| // need to escape them and then quote the whole string |
| StringBuffer sb = new StringBuffer(len + 3); |
| sb.append('"'); |
| sb.append(word.substring(0, i)); |
| int lastc = 0; |
| for (int j = i; j < len; j++) { |
| char cc = word.charAt(j); |
| if ((cc == '"') || (cc == '\\') || |
| (cc == '\r') || (cc == '\n')) |
| if (cc == '\n' && lastc == '\r') |
| ; // do nothing, CR was already escaped |
| else |
| sb.append('\\'); // Escape the character |
| sb.append(cc); |
| lastc = cc; |
| } |
| sb.append('"'); |
| return sb.toString(); |
| } else if (c < 040 || c >= 0177 || specials.indexOf(c) >= 0) |
| // These characters cause the string to be quoted |
| needQuoting = true; |
| } |
| |
| if (needQuoting) { |
| StringBuffer sb = new StringBuffer(len + 2); |
| sb.append('"').append(word).append('"'); |
| return sb.toString(); |
| } else |
| return word; |
| } |
| |
| /** |
| * Fold a string at linear whitespace so that each line is no longer |
| * than 76 characters, if possible. If there are more than 76 |
| * non-whitespace characters consecutively, the string is folded at |
| * the first whitespace after that sequence. The parameter |
| * <code>used</code> indicates how many characters have been used in |
| * the current line; it is usually the length of the header name. <p> |
| * |
| * Note that line breaks in the string aren't escaped; they probably |
| * should be. |
| * |
| * @param used characters used in line so far |
| * @param s the string to fold |
| * @return the folded string |
| */ |
| /*public*/ static String fold(int used, String s) { |
| if (!foldText) |
| return s; |
| |
| int end; |
| char c; |
| // Strip trailing spaces |
| for (end = s.length() - 1; end >= 0; end--) { |
| c = s.charAt(end); |
| if (c != ' ' && c != '\t') |
| break; |
| } |
| if (end != s.length() - 1) |
| s = s.substring(0, end + 1); |
| |
| // if the string fits now, just return it |
| if (used + s.length() <= 76) |
| return s; |
| |
| // have to actually fold the string |
| StringBuffer sb = new StringBuffer(s.length() + 4); |
| char lastc = 0; |
| while (used + s.length() > 76) { |
| int lastspace = -1; |
| for (int i = 0; i < s.length(); i++) { |
| if (lastspace != -1 && used + i > 76) |
| break; |
| c = s.charAt(i); |
| if (c == ' ' || c == '\t') |
| if (!(lastc == ' ' || lastc == '\t')) |
| lastspace = i; |
| lastc = c; |
| } |
| if (lastspace == -1) { |
| // no space, use the whole thing |
| sb.append(s); |
| s = ""; |
| used = 0; |
| break; |
| } |
| sb.append(s.substring(0, lastspace)); |
| sb.append("\r\n"); |
| lastc = s.charAt(lastspace); |
| sb.append(lastc); |
| s = s.substring(lastspace + 1); |
| used = 1; |
| } |
| sb.append(s); |
| return sb.toString(); |
| } |
| |
| /** |
| * Unfold a folded header. Any line breaks that aren't escaped and |
| * are followed by whitespace are removed. |
| * |
| * @param s the string to unfold |
| * @return the unfolded string |
| */ |
| /*public*/ static String unfold(String s) { |
| if (!foldText) |
| return s; |
| |
| StringBuffer sb = null; |
| int i; |
| while ((i = indexOfAny(s, "\r\n")) >= 0) { |
| int start = i; |
| int l = s.length(); |
| i++; // skip CR or NL |
| if (i < l && s.charAt(i - 1) == '\r' && s.charAt(i) == '\n') |
| i++; // skip LF |
| if (start == 0 || s.charAt(start - 1) != '\\') { |
| char c; |
| // if next line starts with whitespace, skip all of it |
| // XXX - always has to be true? |
| if (i < l && ((c = s.charAt(i)) == ' ' || c == '\t')) { |
| i++; // skip whitespace |
| while (i < l && ((c = s.charAt(i)) == ' ' || c == '\t')) |
| i++; |
| if (sb == null) |
| sb = new StringBuffer(s.length()); |
| if (start != 0) { |
| sb.append(s.substring(0, start)); |
| sb.append(' '); |
| } |
| s = s.substring(i); |
| continue; |
| } |
| // it's not a continuation line, just leave it in |
| if (sb == null) |
| sb = new StringBuffer(s.length()); |
| sb.append(s.substring(0, i)); |
| s = s.substring(i); |
| } else { |
| // there's a backslash at "start - 1" |
| // strip it out, but leave in the line break |
| if (sb == null) |
| sb = new StringBuffer(s.length()); |
| sb.append(s.substring(0, start - 1)); |
| sb.append(s.substring(start, i)); |
| s = s.substring(i); |
| } |
| } |
| if (sb != null) { |
| sb.append(s); |
| return sb.toString(); |
| } else |
| return s; |
| } |
| |
| /** |
| * Return the first index of any of the characters in "any" in "s", |
| * or -1 if none are found. |
| * |
| * This should be a method on String. |
| */ |
| private static int indexOfAny(String s, String any) { |
| return indexOfAny(s, any, 0); |
| } |
| |
| private static int indexOfAny(String s, String any, int start) { |
| try { |
| int len = s.length(); |
| for (int i = start; i < len; i++) { |
| if (any.indexOf(s.charAt(i)) >= 0) |
| return i; |
| } |
| return -1; |
| } catch (StringIndexOutOfBoundsException e) { |
| return -1; |
| } |
| } |
| |
| /** |
| * Convert a MIME charset name into a valid Java charset name. <p> |
| * |
| * @param charset the MIME charset name |
| * @return the Java charset equivalent. If a suitable mapping is |
| * not available, the passed in charset is itself returned. |
| */ |
| public static String javaCharset(String charset) { |
| if (mime2java == null || charset == null) |
| // no mapping table, or charset parameter is null |
| return charset; |
| |
| String alias = (String)mime2java.get(charset.toLowerCase()); |
| return alias == null ? charset : alias; |
| } |
| |
| /** |
| * Convert a java charset into its MIME charset name. <p> |
| * |
| * Note that a future version of JDK (post 1.2) might provide |
| * this functionality, in which case, we may deprecate this |
| * method then. |
| * |
| * @param charset the JDK charset |
| * @return the MIME/IANA equivalent. If a mapping |
| * is not possible, the passed in charset itself |
| * is returned. |
| * @since JavaMail 1.1 |
| */ |
| public static String mimeCharset(String charset) { |
| if (java2mime == null || charset == null) |
| // no mapping table or charset param is null |
| return charset; |
| |
| String alias = (String)java2mime.get(charset.toLowerCase()); |
| return alias == null ? charset : alias; |
| } |
| |
| private static String defaultJavaCharset; |
| private static String defaultMIMECharset; |
| |
| /** |
| * Get the default charset corresponding to the system's current |
| * default locale. If the System property <code>mail.mime.charset</code> |
| * is set, a system charset corresponding to this MIME charset will be |
| * returned. <p> |
| * |
| * @return the default charset of the system's default locale, |
| * as a Java charset. (NOT a MIME charset) |
| * @since JavaMail 1.1 |
| */ |
| public static String getDefaultJavaCharset() { |
| if (defaultJavaCharset == null) { |
| /* |
| * If mail.mime.charset is set, it controls the default |
| * Java charset as well. |
| */ |
| String mimecs = null; |
| |
| mimecs = SAAJUtil.getSystemProperty("mail.mime.charset"); |
| |
| if (mimecs != null && mimecs.length() > 0) { |
| defaultJavaCharset = javaCharset(mimecs); |
| return defaultJavaCharset; |
| } |
| |
| try { |
| defaultJavaCharset = System.getProperty("file.encoding", |
| "8859_1"); |
| } catch (SecurityException sex) { |
| |
| class NullInputStream extends InputStream { |
| public int read() { |
| return 0; |
| } |
| } |
| InputStreamReader reader = |
| new InputStreamReader(new NullInputStream()); |
| defaultJavaCharset = reader.getEncoding(); |
| if (defaultJavaCharset == null) |
| defaultJavaCharset = "8859_1"; |
| } |
| } |
| |
| return defaultJavaCharset; |
| } |
| |
| /* |
| * Get the default MIME charset for this locale. |
| */ |
| static String getDefaultMIMECharset() { |
| if (defaultMIMECharset == null) { |
| defaultMIMECharset = SAAJUtil.getSystemProperty("mail.mime.charset"); |
| } |
| if (defaultMIMECharset == null) |
| defaultMIMECharset = mimeCharset(getDefaultJavaCharset()); |
| return defaultMIMECharset; |
| } |
| |
| // Tables to map MIME charset names to Java names and vice versa. |
| // XXX - Should eventually use J2SE 1.4 java.nio.charset.Charset |
| private static Hashtable mime2java; |
| private static Hashtable java2mime; |
| |
| static { |
| java2mime = new Hashtable(40); |
| mime2java = new Hashtable(10); |
| |
| try { |
| // Use this class's classloader to load the mapping file |
| // XXX - we should use SecuritySupport, but it's in another package |
| InputStream is = |
| com.sun.xml.internal.messaging.saaj.packaging.mime.internet.MimeUtility.class.getResourceAsStream( |
| "/META-INF/javamail.charset.map"); |
| |
| if (is != null) { |
| is = new LineInputStream(is); |
| |
| // Load the JDK-to-MIME charset mapping table |
| loadMappings((LineInputStream)is, java2mime); |
| |
| // Load the MIME-to-JDK charset mapping table |
| loadMappings((LineInputStream)is, mime2java); |
| } |
| } catch (Exception ex) { } |
| |
| // If we didn't load the tables, e.g., because we didn't have |
| // permission, load them manually. The entries here should be |
| // the same as the default javamail.charset.map. |
| if (java2mime.isEmpty()) { |
| java2mime.put("8859_1", "ISO-8859-1"); |
| java2mime.put("iso8859_1", "ISO-8859-1"); |
| java2mime.put("ISO8859-1", "ISO-8859-1"); |
| |
| java2mime.put("8859_2", "ISO-8859-2"); |
| java2mime.put("iso8859_2", "ISO-8859-2"); |
| java2mime.put("ISO8859-2", "ISO-8859-2"); |
| |
| java2mime.put("8859_3", "ISO-8859-3"); |
| java2mime.put("iso8859_3", "ISO-8859-3"); |
| java2mime.put("ISO8859-3", "ISO-8859-3"); |
| |
| java2mime.put("8859_4", "ISO-8859-4"); |
| java2mime.put("iso8859_4", "ISO-8859-4"); |
| java2mime.put("ISO8859-4", "ISO-8859-4"); |
| |
| java2mime.put("8859_5", "ISO-8859-5"); |
| java2mime.put("iso8859_5", "ISO-8859-5"); |
| java2mime.put("ISO8859-5", "ISO-8859-5"); |
| |
| java2mime.put("8859_6", "ISO-8859-6"); |
| java2mime.put("iso8859_6", "ISO-8859-6"); |
| java2mime.put("ISO8859-6", "ISO-8859-6"); |
| |
| java2mime.put("8859_7", "ISO-8859-7"); |
| java2mime.put("iso8859_7", "ISO-8859-7"); |
| java2mime.put("ISO8859-7", "ISO-8859-7"); |
| |
| java2mime.put("8859_8", "ISO-8859-8"); |
| java2mime.put("iso8859_8", "ISO-8859-8"); |
| java2mime.put("ISO8859-8", "ISO-8859-8"); |
| |
| java2mime.put("8859_9", "ISO-8859-9"); |
| java2mime.put("iso8859_9", "ISO-8859-9"); |
| java2mime.put("ISO8859-9", "ISO-8859-9"); |
| |
| java2mime.put("SJIS", "Shift_JIS"); |
| java2mime.put("MS932", "Shift_JIS"); |
| java2mime.put("JIS", "ISO-2022-JP"); |
| java2mime.put("ISO2022JP", "ISO-2022-JP"); |
| java2mime.put("EUC_JP", "euc-jp"); |
| java2mime.put("KOI8_R", "koi8-r"); |
| java2mime.put("EUC_CN", "euc-cn"); |
| java2mime.put("EUC_TW", "euc-tw"); |
| java2mime.put("EUC_KR", "euc-kr"); |
| } |
| if (mime2java.isEmpty()) { |
| mime2java.put("iso-2022-cn", "ISO2022CN"); |
| mime2java.put("iso-2022-kr", "ISO2022KR"); |
| mime2java.put("utf-8", "UTF8"); |
| mime2java.put("utf8", "UTF8"); |
| mime2java.put("ja_jp.iso2022-7", "ISO2022JP"); |
| mime2java.put("ja_jp.eucjp", "EUCJIS"); |
| mime2java.put("euc-kr", "KSC5601"); |
| mime2java.put("euckr", "KSC5601"); |
| mime2java.put("us-ascii", "ISO-8859-1"); |
| mime2java.put("x-us-ascii", "ISO-8859-1"); |
| } |
| } |
| |
| private static void loadMappings(LineInputStream is, Hashtable table) { |
| String currLine; |
| |
| while (true) { |
| try { |
| currLine = is.readLine(); |
| } catch (IOException ioex) { |
| break; // error in reading, stop |
| } |
| |
| if (currLine == null) // end of file, stop |
| break; |
| if (currLine.startsWith("--") && currLine.endsWith("--")) |
| // end of this table |
| break; |
| |
| // ignore empty lines and comments |
| if (currLine.trim().length() == 0 || currLine.startsWith("#")) |
| continue; |
| |
| // A valid entry is of the form <key><separator><value> |
| // where, <separator> := SPACE | HT. Parse this |
| StringTokenizer tk = new StringTokenizer(currLine, " \t"); |
| try { |
| String key = tk.nextToken(); |
| String value = tk.nextToken(); |
| table.put(key.toLowerCase(), value); |
| } catch (NoSuchElementException nex) { } |
| } |
| } |
| |
| static final int ALL_ASCII = 1; |
| static final int MOSTLY_ASCII = 2; |
| static final int MOSTLY_NONASCII = 3; |
| |
| /** |
| * Check if the given string contains non US-ASCII characters. |
| * @param s string |
| * @return ALL_ASCII if all characters in the string |
| * belong to the US-ASCII charset. MOSTLY_ASCII |
| * if more than half of the available characters |
| * are US-ASCII characters. Else MOSTLY_NONASCII. |
| */ |
| static int checkAscii(String s) { |
| int ascii = 0, non_ascii = 0; |
| int l = s.length(); |
| |
| for (int i = 0; i < l; i++) { |
| if (nonascii((int)s.charAt(i))) // non-ascii |
| non_ascii++; |
| else |
| ascii++; |
| } |
| |
| if (non_ascii == 0) |
| return ALL_ASCII; |
| if (ascii > non_ascii) |
| return MOSTLY_ASCII; |
| |
| return MOSTLY_NONASCII; |
| } |
| |
| /** |
| * Check if the given byte array contains non US-ASCII characters. |
| * @param b byte array |
| * @return ALL_ASCII if all characters in the string |
| * belong to the US-ASCII charset. MOSTLY_ASCII |
| * if more than half of the available characters |
| * are US-ASCII characters. Else MOSTLY_NONASCII. |
| * |
| * XXX - this method is no longer used |
| */ |
| static int checkAscii(byte[] b) { |
| int ascii = 0, non_ascii = 0; |
| |
| for (int i=0; i < b.length; i++) { |
| // The '&' operator automatically causes b[i] to be promoted |
| // to an int, and we mask out the higher bytes in the int |
| // so that the resulting value is not a negative integer. |
| if (nonascii(b[i] & 0xff)) // non-ascii |
| non_ascii++; |
| else |
| ascii++; |
| } |
| |
| if (non_ascii == 0) |
| return ALL_ASCII; |
| if (ascii > non_ascii) |
| return MOSTLY_ASCII; |
| |
| return MOSTLY_NONASCII; |
| } |
| |
| /** |
| * Check if the given input stream contains non US-ASCII characters. |
| * Upto <code>max</code> bytes are checked. If <code>max</code> is |
| * set to <code>ALL</code>, then all the bytes available in this |
| * input stream are checked. If <code>breakOnNonAscii</code> is true |
| * the check terminates when the first non-US-ASCII character is |
| * found and MOSTLY_NONASCII is returned. Else, the check continues |
| * till <code>max</code> bytes or till the end of stream. |
| * |
| * @param is the input stream |
| * @param max maximum bytes to check for. The special value |
| * ALL indicates that all the bytes in this input |
| * stream must be checked. |
| * @param breakOnNonAscii if <code>true</code>, then terminate the |
| * the check when the first non-US-ASCII character |
| * is found. |
| * @return ALL_ASCII if all characters in the string |
| * belong to the US-ASCII charset. MOSTLY_ASCII |
| * if more than half of the available characters |
| * are US-ASCII characters. Else MOSTLY_NONASCII. |
| */ |
| static int checkAscii(InputStream is, int max, boolean breakOnNonAscii) { |
| int ascii = 0, non_ascii = 0; |
| int len; |
| int block = 4096; |
| int linelen = 0; |
| boolean longLine = false, badEOL = false; |
| boolean checkEOL = encodeEolStrict && breakOnNonAscii; |
| byte buf[] = null; |
| if (max != 0) { |
| block = (max == ALL) ? 4096 : Math.min(max, 4096); |
| buf = new byte[block]; |
| } |
| while (max != 0) { |
| try { |
| if ((len = is.read(buf, 0, block)) == -1) |
| break; |
| int lastb = 0; |
| for (int i = 0; i < len; i++) { |
| // The '&' operator automatically causes b[i] to |
| // be promoted to an int, and we mask out the higher |
| // bytes in the int so that the resulting value is |
| // not a negative integer. |
| int b = buf[i] & 0xff; |
| if (checkEOL && |
| ((lastb == '\r' && b != '\n') || |
| (lastb != '\r' && b == '\n'))) |
| badEOL = true; |
| if (b == '\r' || b == '\n') |
| linelen = 0; |
| else { |
| linelen++; |
| if (linelen > 998) // 1000 - CRLF |
| longLine = true; |
| } |
| if (nonascii(b)) { // non-ascii |
| if (breakOnNonAscii) // we are done |
| return MOSTLY_NONASCII; |
| else |
| non_ascii++; |
| } else |
| ascii++; |
| lastb = b; |
| } |
| } catch (IOException ioex) { |
| break; |
| } |
| if (max != ALL) |
| max -= len; |
| } |
| |
| if (max == 0 && breakOnNonAscii) |
| // We have been told to break on the first non-ascii character. |
| // We haven't got any non-ascii character yet, but then we |
| // have not checked all of the available bytes either. So we |
| // cannot say for sure that this input stream is ALL_ASCII, |
| // and hence we must play safe and return MOSTLY_NONASCII |
| |
| return MOSTLY_NONASCII; |
| |
| if (non_ascii == 0) { // no non-us-ascii characters so far |
| // If we're looking at non-text data, and we saw CR without LF |
| // or vice versa, consider this mostly non-ASCII so that it |
| // will be base64 encoded (since the quoted-printable encoder |
| // doesn't encode this case properly). |
| if (badEOL) |
| return MOSTLY_NONASCII; |
| // if we've seen a long line, we degrade to mostly ascii |
| else if (longLine) |
| return MOSTLY_ASCII; |
| else |
| return ALL_ASCII; |
| } |
| if (ascii > non_ascii) // mostly ascii |
| return MOSTLY_ASCII; |
| return MOSTLY_NONASCII; |
| } |
| |
| static final boolean nonascii(int b) { |
| return b >= 0177 || (b < 040 && b != '\r' && b != '\n' && b != '\t'); |
| } |
| } |
| |
| /** |
| * An OutputStream that determines whether the data written to |
| * it is all ASCII, mostly ASCII, or mostly non-ASCII. |
| */ |
| class AsciiOutputStream extends OutputStream { |
| private boolean breakOnNonAscii; |
| private int ascii = 0, non_ascii = 0; |
| private int linelen = 0; |
| private boolean longLine = false; |
| private boolean badEOL = false; |
| private boolean checkEOL = false; |
| private int lastb = 0; |
| private int ret = 0; |
| |
| public AsciiOutputStream(boolean breakOnNonAscii, boolean encodeEolStrict) { |
| this.breakOnNonAscii = breakOnNonAscii; |
| checkEOL = encodeEolStrict && breakOnNonAscii; |
| } |
| |
| public void write(int b) throws IOException { |
| check(b); |
| } |
| |
| public void write(byte b[]) throws IOException { |
| write(b, 0, b.length); |
| } |
| |
| public void write(byte b[], int off, int len) throws IOException { |
| len += off; |
| for (int i = off; i < len ; i++) |
| check(b[i]); |
| } |
| |
| private final void check(int b) throws IOException { |
| b &= 0xff; |
| if (checkEOL && |
| ((lastb == '\r' && b != '\n') || (lastb != '\r' && b == '\n'))) |
| badEOL = true; |
| if (b == '\r' || b == '\n') |
| linelen = 0; |
| else { |
| linelen++; |
| if (linelen > 998) // 1000 - CRLF |
| longLine = true; |
| } |
| if (MimeUtility.nonascii(b)) { // non-ascii |
| non_ascii++; |
| if (breakOnNonAscii) { // we are done |
| ret = MimeUtility.MOSTLY_NONASCII; |
| throw new EOFException(); |
| } |
| } else |
| ascii++; |
| lastb = b; |
| } |
| |
| /** |
| * Return ASCII-ness of data stream. |
| */ |
| public int getAscii() { |
| if (ret != 0) |
| return ret; |
| // If we're looking at non-text data, and we saw CR without LF |
| // or vice versa, consider this mostly non-ASCII so that it |
| // will be base64 encoded (since the quoted-printable encoder |
| // doesn't encode this case properly). |
| if (badEOL) |
| return MimeUtility.MOSTLY_NONASCII; |
| else if (non_ascii == 0) { // no non-us-ascii characters so far |
| // if we've seen a long line, we degrade to mostly ascii |
| if (longLine) |
| return MimeUtility.MOSTLY_ASCII; |
| else |
| return MimeUtility.ALL_ASCII; |
| } |
| if (ascii > non_ascii) // mostly ascii |
| return MimeUtility.MOSTLY_ASCII; |
| return MimeUtility.MOSTLY_NONASCII; |
| } |
| } |
