mimeutility.java

封装了SQL、Socket、WAP、MIME等功能的通用组件

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi
// Source File Name:   MimeUtility.java

package org.lazybug.mime;

import com.sun.mail.util.*;
import java.io.*;
import java.util.*;
import javax.activation.DataSource;
import javax.mail.MessagingException;

// Referenced classes of package javax.mail.internet:
//            AsciiOutputStream, ContentType, ParseException

public class MimeUtility
{
    private class NullInputStream extends InputStream
    {

        public int read()
        {
            return 0;
        }

        NullInputStream()
        {
        }
    }


    public static final int ALL = -1;
    private static boolean decodeStrict = true;
    private static boolean encodeEolStrict;
    private static String defaultJavaCharset;
    private static String defaultMIMECharset;
    private static Hashtable mime2java;
    private static Hashtable java2mime;
    static final int ALL_ASCII = 1;
    static final int MOSTLY_ASCII = 2;
    static final int MOSTLY_NONASCII = 3;
    //static Class class$javax$mail$internet$MimeUtility; /* synthetic field */

    private MimeUtility()
    {
    }

    public static String getEncoding(DataSource datasource)
    {
        ContentType contenttype = null;
        InputStream inputstream = null;
        String s = null;
        try
        {
            contenttype = new ContentType(datasource.getContentType());
            inputstream = datasource.getInputStream();
        }
        catch(Exception _ex)
        {
            return "base64";
        }
        boolean flag = contenttype.match("text/*");
        int i = checkAscii(inputstream, -1, !flag);
        switch(i)
        {
        case 1: // '\001'
            s = "7bit";
            break;

        case 2: // '\002'
            s = "quoted-printable";
            break;

        default:
            s = "base64";
            break;
        }
        try
        {
            inputstream.close();
        }
        catch(IOException _ex) { }
        return s;
    }
/*
    public static String getEncoding(DataHandler datahandler)
    {
        ContentType contenttype = null;
        String s = null;
        if(datahandler.getName() != null)
            return getEncoding(datahandler.getDataSource());
        try
        {
            contenttype = new ContentType(datahandler.getContentType());
        }
        catch(Exception _ex)
        {
            return "base64";
        }
        if(contenttype.match("text/*"))
        {
            AsciiOutputStream asciioutputstream = new AsciiOutputStream(false, false);
            try
            {
                datahandler.writeTo(asciioutputstream);
            }
            catch(IOException _ex) { }
            switch(asciioutputstream.getAscii())
            {
            case 1: // '\001'
                s = "7bit";
                break;

            case 2: // '\002'
                s = "quoted-printable";
                break;

            default:
                s = "base64";
                break;
            }
        } else
        {
            AsciiOutputStream asciioutputstream1 = new AsciiOutputStream(true, encodeEolStrict);
            try
            {
                datahandler.writeTo(asciioutputstream1);
            }
            catch(IOException _ex) { }
            if(asciioutputstream1.getAscii() == 1)
                s = "7bit";
            else
                s = "base64";
        }
        return s;
    }
                   */
    public static InputStream decode(InputStream inputstream, String s)
        throws IOException
    {
        if(s.equalsIgnoreCase("base64"))
            return new BASE64DecoderStream(inputstream);
        if(s.equalsIgnoreCase("quoted-printable"))
            return new QPDecoderStream(inputstream);
        if(s.equalsIgnoreCase("uuencode") || s.equalsIgnoreCase("x-uuencode") || s.equalsIgnoreCase("x-uue"))
            return new UUDecoderStream(inputstream);
        if(s.equalsIgnoreCase("binary") || s.equalsIgnoreCase("7bit") || s.equalsIgnoreCase("8bit"))
            return inputstream;
        else
            throw new IOException("Unknown encoding: " + s);
    }

    public static OutputStream encode(OutputStream outputstream, String s)
        throws MessagingException
    {
        if(s == null)
            return outputstream;
        if(s.equalsIgnoreCase("base64"))
            return new BASE64EncoderStream(outputstream);
        if(s.equalsIgnoreCase("quoted-printable"))
            return new QPEncoderStream(outputstream);
        if(s.equalsIgnoreCase("uuencode") || s.equalsIgnoreCase("x-uuencode") || s.equalsIgnoreCase("x-uue"))
            return new UUEncoderStream(outputstream);
        if(s.equalsIgnoreCase("binary") || s.equalsIgnoreCase("7bit") || s.equalsIgnoreCase("8bit"))
            return outputstream;
        else
            throw new MessagingException("Unknown encoding: " + s);
    }

    public static OutputStream encode(OutputStream outputstream, String s, String s1)
        throws MessagingException
    {
        if(s == null)
            return outputstream;
        if(s.equalsIgnoreCase("base64"))
            return new BASE64EncoderStream(outputstream);
        if(s.equalsIgnoreCase("quoted-printable"))
            return new QPEncoderStream(outputstream);
        if(s.equalsIgnoreCase("uuencode") || s.equalsIgnoreCase("x-uuencode") || s.equalsIgnoreCase("x-uue"))
            return new UUEncoderStream(outputstream, s1);
        if(s.equalsIgnoreCase("binary") || s.equalsIgnoreCase("7bit") || s.equalsIgnoreCase("8bit"))
            return outputstream;
        else
            throw new MessagingException("Unknown encoding: " + s);
    }

    public static String encodeText(String s)
        throws UnsupportedEncodingException
    {
        return encodeText(s, null, null);
    }

    public static String encodeText(String s, String s1, String s2)
        throws UnsupportedEncodingException
    {
        return encodeWord(s, s1, s2, false);
    }

    public static String decodeText(String s)
        throws UnsupportedEncodingException
    {
        String s1 = " \t\n\r";
        if(s.indexOf("=?") == -1)
            return s;
        StringTokenizer stringtokenizer = new StringTokenizer(s, s1, true);
        StringBuffer stringbuffer = new StringBuffer();
        StringBuffer stringbuffer1 = new StringBuffer();
        boolean flag = false;
        while(stringtokenizer.hasMoreTokens())
        {
            String s2 = stringtokenizer.nextToken();
            char c;
            if((c = s2.charAt(0)) == ' ' || c == '\t' || c == '\r' || c == '\n')
            {
                stringbuffer1.append(c);
            } else
            {
                String s3;
                try
                {
                    s3 = decodeWord(s2);
                    if(!flag && stringbuffer1.length() > 0)
                        stringbuffer.append(stringbuffer1);
                    flag = true;
                }
                catch(ParseException _ex)
                {
                    s3 = s2;
                    if(!decodeStrict)
                        s3 = decodeInnerWords(s3);
                    if(stringbuffer1.length() > 0)
                        stringbuffer.append(stringbuffer1);
                    flag = false;
                }
                stringbuffer.append(s3);
                stringbuffer1.setLength(0);
            }
        }
        return stringbuffer.toString();
    }

    public static String encodeWord(String s)
        throws UnsupportedEncodingException
    {
        return encodeWord(s, null, null);
    }

    public static String encodeWord(String s, String s1, String s2)
        throws UnsupportedEncodingException
    {
        return encodeWord(s, s1, s2, true);
    }

    private static String encodeWord(String s, String s1, String s2, boolean flag)
        throws UnsupportedEncodingException
    {
        int i = checkAscii(s);
        if(i == 1)
            return s;
        String s3;
        if(s1 == null)
        {
            s3 = getDefaultJavaCharset();
            s1 = getDefaultMIMECharset();
        } else
        {
            s3 = javaCharset(s1);
        }
        if(s2 == null)
            if(i != 3)
                s2 = "Q";
            else
                s2 = "B";
        boolean flag1;
        if(s2.equalsIgnoreCase("B"))
            flag1 = true;
        else
        if(s2.equalsIgnoreCase("Q"))
            flag1 = false;
        else
            throw new UnsupportedEncodingException("Unknown transfer encoding: " + s2);
        StringBuffer stringbuffer = new StringBuffer();
        doEncode(s, flag1, s3, 68 - s1.length(), "=?" + s1 + "?" + s2 + "?", true, flag, stringbuffer);
        return stringbuffer.toString();
    }

    private static void doEncode(String s, boolean flag, String s1, int i, String s2, boolean flag1, boolean flag2, StringBuffer stringbuffer)
        throws UnsupportedEncodingException
    {
        byte abyte0[] = s.getBytes(s1);
        int j;
        if(flag)
            j = BEncoderStream.encodedLength(abyte0);
        else
            j = QEncoderStream.encodedLength(abyte0, flag2);
        int k;
        if(j > i && (k = s.length()) > 1)
        {
            doEncode(s.substring(0, k / 2), flag, s1, i, s2, flag1, flag2, stringbuffer);
            doEncode(s.substring(k / 2, k), flag, s1, i, s2, false, flag2, stringbuffer);
            return;
        }
        ByteArrayOutputStream bytearrayoutputstream = new ByteArrayOutputStream();
        Object obj;
        if(flag)
            obj = new BEncoderStream(bytearrayoutputstream);
        else
            obj = new QEncoderStream(bytearrayoutputstream, flag2);
        try
        {
            ((OutputStream) (obj)).write(abyte0);
            ((OutputStream) (obj)).close();
        }
        catch(IOException _ex) { }
        byte abyte1[] = bytearrayoutputstream.toByteArray();
        if(!flag1)
            stringbuffer.append("\r\n ");
        stringbuffer.append(s2);
        for(int l = 0; l < abyte1.length; l++)
            stringbuffer.append((char)abyte1[l]);

        stringbuffer.append("?=");
    }

    public static String decodeWord(String s)
        throws ParseException, UnsupportedEncodingException
    {
        if(!s.startsWith("=?"))
            throw new ParseException();
        int i = 2;
        int j;
        if((j = s.indexOf(63, i)) == -1)
            throw new ParseException();
        String s1 = javaCharset(s.substring(i, j));
        i = j + 1;
        if((j = s.indexOf(63, i)) == -1)
            throw new ParseException();
        String s2 = s.substring(i, j);
        i = j + 1;
        if((j = s.indexOf("?=", i)) == -1)
            throw new ParseException();
        String s3 = s.substring(i, j);
        try
        {
            ByteArrayInputStream bytearrayinputstream = new ByteArrayInputStream(ASCIIUtility.getBytes(s3));
            Object obj;
            if(s2.equalsIgnoreCase("B"))
                obj = new BASE64DecoderStream(bytearrayinputstream);
            else
            if(s2.equalsIgnoreCase("Q"))
                obj = new QDecoderStream(bytearrayinputstream);
            else
                throw new UnsupportedEncodingException("unknown encoding: " + s2);
            int k = bytearrayinputstream.available();
            byte abyte0[] = new byte[k];
            k = ((InputStream) (obj)).read(abyte0, 0, k);
            String s4 = new String(abyte0, 0, k, s1);
            if(j + 2 < s.length())
            {
                String s5 = s.substring(j + 2);
                if(!decodeStrict)
                    s5 = decodeInnerWords(s5);
                s4 = s4 + s5;
            }
            return s4;
        }
        catch(UnsupportedEncodingException unsupportedencodingexception)
        {
            throw unsupportedencodingexception;
        }
        catch(IOException _ex)
        {
            throw new ParseException();