standardmimemessageparser.java

来自「spam source codejasen-0.9jASEN - java An」· Java 代码 · 共 215 行

/*
 * @(#)StandardMimeMessageParser.java	31/10/2004
 *
 * Copyright (c) 2004, 2005  jASEN.org
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *
 *   3. The names of the authors may not be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 *   4. Any modification or additions to the software must be contributed back
 *      to the project.
 *
 *   5. Any investigation or reverse engineering of source code or binary to
 *      enable emails to bypass the filters, and hence inflict spam and or viruses
 *      onto users who use or do not use jASEN could subject the perpetrator to
 *      criminal and or civil liability.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JASEN.ORG,
 * OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
package org.jasen.core.parsers;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import javax.mail.Address;
import javax.mail.MessagingException;
import javax.mail.Part;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.ParseException;

import org.jasen.core.StandardJasenMessage;
import org.jasen.error.ErrorHandlerBroker;
import org.jasen.error.JasenParseException;
import org.jasen.error.ParseErrorType;
import org.jasen.interfaces.JasenMessage;
import org.jasen.interfaces.MimeMessageParser;
import org.jasen.util.MimeType;
import org.jasen.util.MimeUtils;


/**
 * <P>
 * 	A simple implementation of a mime message parser.
 * </P>
 * <p>
 * 	This is the default parser used by JASEN, however implementors may consider creating their own
 * </p>
 * @author Jason Polites
 */
public class StandardMimeMessageParser implements MimeMessageParser
{

    /**
     *
     */
    public StandardMimeMessageParser() {
        super ();
    }

    /* (non-Javadoc)
     * @see org.jasen.interfaces.MimeParser#parse(javax.mail.internet.MimeMessage)
     */
    public JasenMessage parse(MimeMessage mm) throws JasenParseException {

        try
        {
            List parts = new LinkedList ();
            StandardJasenMessage message = null;

            InternetAddress from = null;

            try
            {
                MimeUtils.getParts (parts, mm);

                message = new StandardJasenMessage ();

                message.setTextPart ((String) MimeUtils.getPartContent (MimeUtils.getFirstPartFromList (parts, MimeType.TEXT_PLAIN, null)));
                message.setHtmlPart ((String) MimeUtils.getPartContent (MimeUtils.getFirstPartFromList (parts, MimeType.TEXT_HTML, null)));

                from = getFromSafe(mm);

                if(from == null) {
                    throw new JasenParseException("Empty from", ParseErrorType.MALFORMED_MIME);
                }

                message.setFrom(from);

                if(mm.getHeader("x-envelope-sender") != null) {
                    message.setEnvelopeSender(mm.getHeader("x-envelope-sender")[0]);
                }
                else
                {
                    message.setEnvelopeSender(message.getFrom().getAddress());
                }

                // Get attachments
                List attachments = MimeUtils.getAllAttachmentParts (parts);

                if (attachments != null && attachments.size () > 0)
                {

                    String[] attachmentNames = new String[attachments.size ()];

                    Iterator i = attachments.iterator ();

                    int count = 0;

                    Part p = null;

                    while (i.hasNext ())
                    {
                        p = (Part) i.next ();
                        try
                        {
                            attachmentNames[count] = p.getFileName ();
                            count++;
                        }
                        catch (MessagingException e)
                        {
                            // Ignore this
                            ErrorHandlerBroker.getInstance().getErrorHandler().handleException(e);
                        }

                    }

                    message.setAttachmentNames (attachmentNames);
                }

            }
            catch (ParseException e)
            {
                throw new JasenParseException (e, ParseErrorType.MALFORMED_MIME);
            }
            catch (UnsupportedEncodingException e)
            {
                throw new JasenParseException (e, ParseErrorType.UNSUPPORTED_ENCODING);
            }
            catch (MessagingException e)
            {
                throw new JasenParseException (e, ParseErrorType.PARSE_ERROR);
            }

            return message;
        }
        catch (IOException e)
        {
            throw new JasenParseException (e, ParseErrorType.PARSE_ERROR);
        }

    }


    /**
     * "Safely" gets the from header.  If the from header is unavailable, returns the Reply-To.
     * <br/>
     * If Reply-To is unavailable, gets Return-Path
     * @param mm
     * @return The contents of the From, Reply-To or Return-Path header
     * @throws MessagingException
     */
    public InternetAddress getFromSafe(MimeMessage mm) throws MessagingException {
        InternetAddress from = null;

        Address[] froms = mm.getFrom();


        if(froms != null && froms.length > 0) {
            from = MimeUtils.toInternetAddress(froms[0], false);
        }
        else {
            // try the reply to
            String[] headers = mm.getHeader("Reply-To");

            if(headers != null && headers.length > 0) {
                from = InternetAddress.parse(headers[0], false)[0];
            }
            else
            {
                // try return path
                headers = mm.getHeader("Return-Path");

                if(headers != null && headers.length > 0) {
                    from = InternetAddress.parse(headers[0], false)[0];
                }
            }
        }

        return from;
    }
}