Fixed attachment filename encoding and decoding issues, added ISO-8859-2 to the StringFactory, and increased scope of the MIMEInputStream bug workaround preprocessing to cover message part headers and local message file loading (refs #352)

git-svn-id: https://logicmail.svn.sourceforge.net/svnroot/logicmail/trunk@925 5c734088-3d25-0410-9155-b3c3832efda5

LogicMail/src/org/logicprobe/LogicMail/mail/LocalMessageRequest.java

···
 
 package org.logicprobe.LogicMail.mail;
 
-import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.Enumeration;
 import java.util.Hashtable;
 
···
             
             // Parse the message source
             Hashtable contentMap = new Hashtable();
-            MimeMessagePart rootPart = MailMessageParser.parseRawMessage(contentMap, new ByteArrayInputStream(messageSource.getBytes()));
+            InputStream messageStream = MailMessageParser.convertMessageResultToStream(messageSource);
+            MimeMessagePart rootPart = MailMessageParser.parseRawMessage(contentMap, messageStream);
             message = new Message(rootPart);
             Enumeration e = contentMap.keys();
             while(e.hasMoreElements()) {

LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapParser.java

···
                     if (key.equalsIgnoreCase(CHARSET)) {
                         sec.charset = value;
                     } else if (key.equalsIgnoreCase(NAME)) {
-                        sec.name = value;
+                        sec.name = StringParser.parseEncodedHeader(value);
                     }
                 }
             }

LogicMail/src/org/logicprobe/LogicMail/mail/pop/PopClient.java

···
 
 package org.logicprobe.LogicMail.mail.pop;
 
-import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Enumeration;
 import java.util.Hashtable;
 
 import net.rim.device.api.util.Arrays;
-import net.rim.device.api.util.DataBuffer;
 import net.rim.device.api.util.ToIntHashtable;
 
 import org.logicprobe.LogicMail.conf.AccountConfig;
···
     private String password;
     private boolean openStarted;
     
-    private static final byte[] CRLF = new byte[] { (byte)'\r', (byte)'\n' };
     private static String CAPA_STLS = "STLS"; 
     
     /**
···
         // the special case where maxLines == retrievedLines and we are
         // downloading a single-part message with no separators.
 
-        InputStream inputStream = convertMessageResultToStream(retrResult);
+        InputStream inputStream = MailMessageParser.convertMessageResultToStream(retrResult);
         
         Hashtable contentMap = new Hashtable();
         MimeMessagePart rootPart = MailMessageParser.parseRawMessage(contentMap, inputStream);
···
         }
     }
 
-    /**
-     * Convert the server result to an InputStream wrapping a byte[] buffer
-     * that includes the CRLF markers that were stripped out by the socket
-     * reading code, and has any other necessary pre-processing applied.
-     *
-     * @param resultLines the lines of message data returned by the server
-     * @return the input stream to be passed to the parser code
-     */
-    private static InputStream convertMessageResultToStream(byte[][] resultLines) {
-        DataBuffer buf = new DataBuffer();
-        
-        boolean inHeaders = true;
-        for(int i=0; i<resultLines.length; i++) {
-            if(inHeaders) {
-                // Special logic to unfold message headers and replace HTAB
-                // indentations in folded headers with spaces.
-                // This is a workaround for a bug in MIMEInputStream that
-                // causes it to fail to parse certain messages with folded
-                // headers.  (The bug appears to be fixed in OS 6.0, but the
-                // workaround is always invoked because it should not have
-                // any harmful side-effects.)
-                if(resultLines[i].length == 0) {
-                    inHeaders = false;
-                    if(i > 0) {
-                        buf.write(CRLF);
-                    }
-                    buf.write(CRLF);
-                }
-                else if(resultLines[i][0] == (byte)'\t') {
-                    resultLines[i][0] = (byte)' ';
-                    buf.write(resultLines[i]);
-                }
-                else if(resultLines[i][0] == (byte)' ') {
-                    buf.write(resultLines[i]);
-                }
-                else {
-                    if(i > 0) {
-                        buf.write(CRLF);
-                    }
-                    buf.write(resultLines[i]);
-                }
-            }
-            else {
-                buf.write(resultLines[i]);
-                buf.write(CRLF);
-            }
-        }
-        
-        ByteArrayInputStream inputStream = new ByteArrayInputStream(
-                buf.getArray(), buf.getArrayStart(), buf.getArrayLength());
-        
-        return inputStream;
-    }
-    
     /* (non-Javadoc)
      * @see org.logicprobe.LogicMail.mail.IncomingMailClient#deleteMessage(org.logicprobe.LogicMail.mail.MessageToken)
      */

LogicMail/src/org/logicprobe/LogicMail/message/MessageMimeConverter.java

···
                 ContentPart contentPart = (ContentPart)part;
                 String name = contentPart.getName();
                 if(name.length() > 0) {
-                    mimeStream.addContentTypeParameter("name", name);
+                    mimeStream.addContentTypeParameter("name", "\"" + StringParser.createEncodedHeader(10, name) + "\"");
                     if(contentPart.getDisposition().equalsIgnoreCase("attachment")) {
-                        mimeStream.addHeaderField("Content-Disposition: attachment; filename=\"" + name + "\"");
+                        mimeStream.addHeaderField("Content-Disposition: attachment; filename=\""
+                                + StringParser.createEncodedHeader(44, name) + "\"");
                     }
                 }
             }

LogicMail/src/org/logicprobe/LogicMail/ui/CompositionScreen.java

···
                 String mimeSubtype = mimeType.substring(p + 1);
                 mimeType = mimeType.substring(0, p);
                 
-                p = fileUrl.lastIndexOf('/');
-                String fileName = fileUrl.substring(p + 1);
-                
                 MimeMessagePart part =
                     MimeMessagePartFactory.createMimeMessagePart(
                             mimeType,
                             mimeSubtype,
-                            fileName,
+                            fileConnection.getName(),
                             null,         // encoding
                             null,         // param
                             "attachment", // disposition

LogicMail/src/org/logicprobe/LogicMail/util/MailMessageParser.java

···
 package org.logicprobe.LogicMail.util;
 
 import net.rim.device.api.io.IOUtilities;
+import net.rim.device.api.io.LineReader;
 import net.rim.device.api.io.SharedInputStream;
 import net.rim.device.api.mime.MIMEInputStream;
 import net.rim.device.api.mime.MIMEParsingException;
 import net.rim.device.api.system.EventLogger;
 import net.rim.device.api.util.Arrays;
+import net.rim.device.api.util.DataBuffer;
 
 import org.logicprobe.LogicMail.AppInfo;
 import org.logicprobe.LogicMail.message.MimeMessageContent;
···
 import org.logicprobe.LogicMail.message.TextPart;
 import org.logicprobe.LogicMail.message.UnsupportedContentException;
 
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 
 import java.util.Calendar;
 import java.util.Hashtable;
+import java.util.Vector;
 
 
 /**
···
  */
 public class MailMessageParser {
     private static String strCRLF = "\r\n";
+    private static final byte[] CRLF = new byte[] { (byte)'\r', (byte)'\n' };
+    private static final byte[] CONTENT_TYPE_KEY = "Content-Type:".getBytes();
+    private static final byte[] BOUNDARY_EQ = "boundary=".getBytes();
 
     private MailMessageParser() {
     }
···
 
         return addresses;
     }
+    
+    /**
+     * Convert string-format raw message source to an InputStream that is
+     * compatible with {@link #parseRawMessage(Hashtable, InputStream)}.
+     *
+     * @param messageSource the message source
+     * @return the input stream to be passed to the parser code
+     */
+    public static InputStream convertMessageResultToStream(String messageSource) {
+        ByteArrayInputStream inputStream = new ByteArrayInputStream(messageSource.getBytes());
+        
+        Vector lines = new Vector();
+        try {
+            LineReader reader = new LineReader(inputStream);
+            byte[] line;
+            while((line = reader.readLine()) != null) {
+                lines.addElement(line);
+            }
+        } catch (IOException e) {
+            EventLogger.logEvent(AppInfo.GUID,
+                    ("Error converting message to stream: " + e.getMessage()).getBytes(),
+                    EventLogger.WARNING);
+        }
+        
+        byte[][] resultLines = new byte[lines.size()][];
+        lines.copyInto(resultLines);
+        return convertMessageResultToStream(resultLines);
+    }
+    
+    /**
+     * Convert the server result to an InputStream wrapping a byte[] buffer
+     * that includes the CRLF markers that were stripped out by the socket
+     * reading code, and has any other necessary pre-processing applied.
+     *
+     * @param resultLines the lines of message data returned by the server
+     * @return the input stream to be passed to the parser code
+     */
+    public static InputStream convertMessageResultToStream(byte[][] resultLines) {
+        DataBuffer buf = new DataBuffer();
+        
+        boolean inHeaders = true;
+        boolean inInitialHeaders = true;
+        boolean firstHeaderLine = true;
+        byte[] boundary = null;
+        for(int i=0; i<resultLines.length; i++) {
+            if(inHeaders) {
+                // Special logic to unfold message headers and replace HTAB
+                // indentations in folded headers with spaces.
+                // This is a workaround for a bug in MIMEInputStream that
+                // causes it to fail to parse certain messages with folded
+                // headers.  (The bug appears to be fixed in OS 6.0, but the
+                // workaround is always invoked because it should not have
+                // any harmful side-effects.)
+                if(resultLines[i].length == 0) {
+                    inHeaders = false;
+                    if(!firstHeaderLine) {
+                        buf.write(CRLF);
+                    }
+                    buf.write(CRLF);
+                    
+                    if(inInitialHeaders) {
+                        boundary = getContentBoundary(buf.getArray(), buf.getArrayStart(), buf.getArrayLength());
+                        inInitialHeaders = false;
+                    }
+                }
+                else if(resultLines[i][0] == (byte)'\t' || resultLines[i][0] == (byte)' ') {
+                    for(int j=1; j<resultLines[i].length; j++) {
+                        if(resultLines[i][j] != (byte)'\t' && resultLines[i][j] != (byte)' ') {
+                            buf.write((byte)' ');
+                            buf.write(resultLines[i], j, resultLines[i].length - j);
+                            break;
+                        }
+                    }
+                }
+                else {
+                    if(!firstHeaderLine) {
+                        buf.write(CRLF);
+                    }
+                    buf.write(resultLines[i]);
+                }
+                if(firstHeaderLine) { firstHeaderLine = false; }
+            }
+            else {
+                buf.write(resultLines[i]);
+                buf.write(CRLF);
+                if(Arrays.equals(resultLines[i], boundary)) {
+                    inHeaders = true;
+                    firstHeaderLine = true;
+                }
+            }
+        }
+        
+        ByteArrayInputStream inputStream = new ByteArrayInputStream(
+                buf.getArray(), buf.getArrayStart(), buf.getArrayLength());
+        
+        return inputStream;
+    }
+    
+    private static byte[] getContentBoundary(byte[] buf, int offset, int length) {
+        int p = StringArrays.indexOf(buf, CONTENT_TYPE_KEY, offset, length, true);
+        if(p == -1) { return null; } else { p += CONTENT_TYPE_KEY.length; }
+        
+        int q = StringArrays.indexOf(buf, CRLF, p, length, false);
+        if(q == -1) { return null; }
+        
+        int r = StringArrays.indexOf(buf, BOUNDARY_EQ, p, q, true);
+        if(r == -1) { return null; } else { r += BOUNDARY_EQ.length; }
+        
+        int s = StringArrays.indexOf(buf, (byte)' ', r);
+        if(s == -1 || s > q) { s = q; }
+        
+        if(buf[r] == (byte)'\"') { r++; }
+        if(buf[s - 1] == (byte)'\"') { s--; }
+        if((s - r) <= 0) { return null; }
+        
+        byte[] result = new byte[(s - r) + 2];
+        result[0] = (byte)'-';
+        result[1] = (byte)'-';
+        System.arraycopy(buf, r, result, 2, s - r);
+        
+        return result;
+    }
 
     /**
      * Parses the raw message body.
···
         String subtype = mimeType.substring(mimeType.indexOf('/') + 1);
         String encoding = mimeInputStream.getHeader("Content-Transfer-Encoding");
         String charset = mimeInputStream.getContentTypeParameter("charset");
-        String name = mimeInputStream.getContentTypeParameter("name");
+        String name = StringParser.parseEncodedHeader(mimeInputStream.getContentTypeParameter("name"), false);
         String disposition = mimeInputStream.getHeader("Content-Disposition");
         String contentId = mimeInputStream.getHeader("Content-ID");
 

LogicMail/src/org/logicprobe/LogicMail/util/StringArrays.java

···
  */
 package org.logicprobe.LogicMail.util;
 
+import net.rim.device.api.util.CharacterUtilities;
+
 /**
  * Provides utility methods that operate on <code>byte</code> arrays, with
  * similar functionality to common <code>String</code> methods.
···
      * @throws NullPointerException if <code>str</code> is <code>null</code>
      */
     public static int indexOf(byte[] array, byte[] str, int fromIndex) {
+        return indexOf(array, str, fromIndex, array.length, false);
+    }
+    
+    /**
+     * Returns the index within this string of the first occurrence of the
+     * specified substring, starting at the specified index.
+     *
+     * @param array the array representing the string.
+     * @param str the substring to search for.
+     * @param fromIndex the index to start the search from.
+     * @param arrayLength the length of the data in the array that is valid for
+     *   the search
+     * @param ignoreCase true, if the search should be case insensitive
+     * @return If the string argument occurs as a substring within this object
+     *   at a starting index no smaller than <code>fromIndex</code>, then the
+     *   index of the first character of the first such substring is returned.
+     *   If it does not occur as a substring starting at <code>fromIndex</code>
+     *   or beyond, <code>-1</code> is returned.
+     * @throws NullPointerException if <code>str</code> is <code>null</code>
+     */
+    public static int indexOf(byte[] array, byte[] str, int fromIndex, int arrayLength, boolean ignoreCase) {
         if(str == null) {
             throw new NullPointerException();
         }
-        if(fromIndex + str.length > array.length) {
+        if(fromIndex + str.length > arrayLength) {
             return -1;
         }
         
-        int max = array.length - str.length;
+        int max = arrayLength - str.length;
+
+        if(ignoreCase) {
+            for (int i = fromIndex; i <= max; i++) {
+                if (!equalsIgnoreCase(array[i], str[0])) {
+                    while (++i <= max && !equalsIgnoreCase(array[i], str[0]));
+                }
+
+                if (i <= max) {
+                    int j = i + 1;
+                    int end = j + str.length - 1;
+                    for (int k = 1; j < end && equalsIgnoreCase(array[j], str[k]); j++, k++);
 
-        for (int i = fromIndex; i <= max; i++) {
-            if (array[i] != str[0]) {
-                while (++i <= max && array[i] != str[0]);
+                    if (j == end) {
+                        return i;
+                    }
+                }
             }
+        }
+        else {
+            for (int i = fromIndex; i <= max; i++) {
+                if (array[i] != str[0]) {
+                    while (++i <= max && array[i] != str[0]);
+                }
 
-            if (i <= max) {
-                int j = i + 1;
-                int end = j + str.length - 1;
-                for (int k = 1; j < end && array[j] == str[k]; j++, k++);
+                if (i <= max) {
+                    int j = i + 1;
+                    int end = j + str.length - 1;
+                    for (int k = 1; j < end && array[j] == str[k]; j++, k++);
 
-                if (j == end) {
-                    return i;
+                    if (j == end) {
+                        return i;
+                    }
                 }
             }
         }
         return -1;
+    }
+    
+    private static boolean equalsIgnoreCase(byte ch1, byte ch2) {
+        if(CharacterUtilities.isLetter((char)ch1) && CharacterUtilities.isLetter((char)ch2)) {
+            return CharacterUtilities.toUpperCase((char)ch1) == CharacterUtilities.toUpperCase((char)ch2);
+        }
+        else {
+            return ch1 == ch2;
+        }
     }
     
     /**

LogicMail/src/org/logicprobe/LogicMail/util/StringFactory.java

···
  * <li><b>&quot;Windows-1256&quot;</b> - Arabic</li>
  * <li><b>&quot;Windows-1257&quot;</b> - Estonian, Latvian and Lithuanian</li>
  * <li><b>&quot;Windows-1258&quot;</b> - Vietnamese</li>
+ * <li><b>&quot;ISO-8859-2&quot;</b> - Central European and Eastern European languages that use Latin script</li>
  * <li><b>&quot;KOI8-R&quot;</b> - Russian</li>
  * <li><b>&quot;KOI8-U&quot;</b> - Ukrainian</li>
  * </ul>
···
         charsetMappingTables.put("WINDOWS-1257", mappingTableCP1257);
         charsetMappingTables.put("CP1258", mappingTableCP1258);
         charsetMappingTables.put("WINDOWS-1258", mappingTableCP1258);
+        charsetMappingTables.put("ISO-8859-2", mappingTable8859_2);
         charsetMappingTables.put("KOI8-R", mappingTableKOI8R);
         charsetMappingTables.put("KOI8-U", mappingTableKOI8U);
     }
···
      * @see String#String(byte[], String)
      */
     public static String create(byte[] bytes, String charset) throws UnsupportedEncodingException {
+        return create(bytes, 0, bytes.length, charset);
+    }
+
+    /**
+     * Construct a new <tt>String</tt> by converting the specified array of
+     * bytes using the specified character encoding.  This method will first
+     * attempt to use the constructor of the <tt>String</tt> class that takes
+     * a character encoding parameter.  If <tt>String</tt> does not directly
+     * recognize the encoding, this method will then attempt to use a variety
+     * of Unicode mapping tables.
+     *
+     * @param bytes The bytes to be converted into characters
+     * @param off Index of the first byte to convert
+     * @param len Number of bytes to convert
+     * @param charset The name of a supported character encoding
+     * @return Converted string representation
+     * @throws UnsupportedEncodingException If the named character encoding is not supported
+     * 
+     * @see String#String(byte[], String)
+     */
+    public static String create(byte[] bytes, int off, int len, String charset) throws UnsupportedEncodingException {
         if(charset == null || charset.length() == 0) {
             throw new UnsupportedEncodingException();
         }
         
         String result;
         try {
-            result = new String(bytes, charset);
+            result = new String(bytes, off, len, charset);
         } catch (UnsupportedEncodingException exp) {
-            result = getInstance().createFromMappingTable(bytes, charset);
+            result = getInstance().createFromMappingTable(bytes, off, len, charset);
         }
         return result;
     }
···
      * bytes using the specified character encoding.
      *
      * @param bytes The bytes to be converted into characters
+     * @param off Index of the first byte to convert
+     * @param len Number of bytes to convert
      * @param charset The name of a supported character encoding
      * @return Converted string representation
      * @throws UnsupportedEncodingException If the named character encoding is not supported
      */
-    private String createFromMappingTable(byte[] bytes, String charset) throws UnsupportedEncodingException {
+    private String createFromMappingTable(byte[] bytes, int off, int len, String charset) throws UnsupportedEncodingException {
         char[] mappingTable = (char[])charsetMappingTables.get(charset.toUpperCase());
         if(mappingTable == null) {
             throw new UnsupportedEncodingException();
         }
         
         StringBuffer buf = new StringBuffer();
-        for(int i=0; i<bytes.length; i++) {
+        for(int i=off; i<len; i++) {
             buf.append(mappingTable[(int) bytes[i] & 0xFF]);
         }
         return buf.toString();
···
         '\u00FC', '\u01B0', '\u20AB', '\u00FF'
     };
 
+    /**
+     * ISO-8859-2 to Unicode table
+     * <pre>
+     * Unicode version: 3.0
+     * Table version: 1.0
+     * Date: 07/27/1999
+     * URL:  http://www.unicode.org/Public/MAPPINGS/ISO8859/8859-2.TXT
+     * </pre>
+     */
+    private static char[] mappingTable8859_2 = {
+        '\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
+        '\u0006', '\u0007', '\u0008', '\u0009', '\n', '\u000B',
+        '\u000C', '\r', '\u000E', '\u000F', '\u0010', '\u0011',
+        '\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
+        '\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
+        '\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
+        '\u0024', '\u0025', '\u0026', '\'', '\u0028', '\u0029',
+        '\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
+        '\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
+        '\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
+        '\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
+        '\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
+        '\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
+        '\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
+        '\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
+        '\u005A', '\u005B', '\\', '\u005D', '\u005E', '\u005F',
+        '\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
+        '\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
+        '\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
+        '\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
+        '\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
+        '\u007E', '\u007F', '\u0080', '\u0081', '\u0082', '\u0083',
+        '\u0084', '\u0085', '\u0086', '\u0087', '\u0088', '\u0089',
+        '\u008A', '\u008B', '\u008C', '\u008D', '\u008E', '\u008F',
+        '\u0090', '\u0091', '\u0092', '\u0093', '\u0094', '\u0095',
+        '\u0096', '\u0097', '\u0098', '\u0099', '\u009A', '\u009B',
+        '\u009C', '\u009D', '\u009E', '\u009F', '\u00A0', '\u0104',
+        '\u02D8', '\u0141', '\u00A4', '\u013D', '\u015A', '\u00A7',
+        '\u00A8', '\u0160', '\u015E', '\u0164', '\u0179', '\u00AD',
+        '\u017D', '\u017B', '\u00B0', '\u0105', '\u02DB', '\u0142',
+        '\u00B4', '\u013E', '\u015B', '\u02C7', '\u00B8', '\u0161',
+        '\u015F', '\u0165', '\u017A', '\u02DD', '\u017E', '\u017C',
+        '\u0154', '\u00C1', '\u00C2', '\u0102', '\u00C4', '\u0139',
+        '\u0106', '\u00C7', '\u010C', '\u00C9', '\u0118', '\u00CB',
+        '\u011A', '\u00CD', '\u00CE', '\u010E', '\u0110', '\u0143',
+        '\u0147', '\u00D3', '\u00D4', '\u0150', '\u00D6', '\u00D7',
+        '\u0158', '\u016E', '\u00DA', '\u0170', '\u00DC', '\u00DD',
+        '\u0162', '\u00DF', '\u0155', '\u00E1', '\u00E2', '\u0103',
+        '\u00E4', '\u013A', '\u0107', '\u00E7', '\u010D', '\u00E9',
+        '\u0119', '\u00EB', '\u011B', '\u00ED', '\u00EE', '\u010F',
+        '\u0111', '\u0144', '\u0148', '\u00F3', '\u00F4', '\u0151',
+        '\u00F6', '\u00F7', '\u0159', '\u016F', '\u00FA', '\u0171',
+        '\u00FC', '\u00FD', '\u0163', '\u02D9'
+    };
+    
     /**
      * KOI8-R (RFC1489) to Unicode table
      * <pre>

LogicMail/src/org/logicprobe/LogicMail/util/StringParser.java

···
      * @return Processed unicode string
      */
     public static String parseEncodedHeader(String text) {
+        return parseEncodedHeader(text, true);
+    }
+    
+    /**
+     * Scans the provided string for blocks of text encoded according
+     * to RFC2047, decodes them accordingly, and returns a new Unicode
+     * string usable in the rest of the application.  If the charset for
+     * a block of text is not supported, then that block is not included
+     * in the result.
+     *
+     * @param text The text to scan.
+     * @param reencode true, if the text should be reencoded if it contains
+     *     characters outside of the US-ASCII 7bit range
+     * @return Processed unicode string
+     */
+    public static String parseEncodedHeader(String text, boolean reencode) {
         // Quick check for null input
         if (text == null) {
             return null;
         }
 
-        text = reencodeStringIfNecessary(text);
+        if(reencode) {
+            text = reencodeStringIfNecessary(text);
+        }
 
         int size = text.length();
 
···
         } else if (encoding.charAt(0) == 'B') {
             // Base64
             try {
-                result = new String(
-                        Base64InputStream.decode(encodedText),
-                        charset);
+                byte[] decodedData = Base64InputStream.decode(encodedText);
+                try {
+                    result = StringFactory.create(decodedData, charset);
+                } catch (UnsupportedEncodingException e) {
+                    result = new String(decodedData);
+                }
             } catch (IOException e) {
                 result = "";
             }
···
         buf.append(' ');
         
         appendEncodedHeaderSegment(buf, key.length() + 1, text);
+        
+        return buf.toString();
+    }
+    
+    public static String createEncodedHeader(int indent, String text) {
+        StringBuffer buf = new StringBuffer();
+        
+        appendEncodedHeaderSegment(buf, indent, text);
         
         return buf.toString();
     }
···
         decodeQuotedPrintableDataImpl(buf, text, header);
         String result;
         try {
-            result = new String(buf.getArray(), buf.getArrayStart(), buf.getArrayLength(), charset);
+            result = StringFactory.create(buf.getArray(), buf.getArrayStart(), buf.getArrayLength(), charset);
         } catch (UnsupportedEncodingException e) {
             result = new String(buf.getArray(), buf.getArrayStart(), buf.getArrayLength());
         }