imapclient.java

手机游戏例子

/******************************************************************************
 * Mail4ME - Mail for the Java 2 Micro Edition
 *
 * A lightweight, J2ME- (and also J2SE-) compatible package for sending and
 * receiving Internet mail messages using the SMTP and POP3 protocols.
 *
 * Copyright (c) 2000-2002 J鰎g Pleumann <[e-mail]>
 *
 * Mail4ME is part of the EnhydraME family of projects. See the following web
 * sites for more information:
 *
 * -> http://mail4me.enhydra.org
 * -> http://me.enhydra.org
 *
 * Mail4ME is distributed under the Enhydra Public License (EPL), which is
 * discussed in great detail here:
 *
 * -> http://www.enhydra.org/software/license/index.html
 *
 * Have fun!
 ******************************************************************************/
package de.trantor.mail;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;

/**
 * Encapsulates the IMAP v4.1 protocol as specified in RFC 2060. This class
 * provides a simple interface to a IMAP mailbox. After a session has been
 * established using the open() method, the number of available messages can be
 * queried by calling the getMessageCount() method, and arbitrary messages or
 * their headers can be retrieved from the mailbox using getMessage() or
 * getHeaders(), respectively. Deleting messages is possible using
 * removeMessage(). Each IMAP session should be terminated by a call to the
 * close() method.
 *
 * @see MailException
 * @see SmtpClient
 * @see Message
 */
public class ImapClient extends InboxClient {

    /**
     * Counts the commands executed so far in this session. Every command of an
     * IMAP session needs a unique ID that is prepended to the command line.
     */
    private int commandCount = 0;

    /**
     * Creates a new ImapClient instance.
     */
    public ImapClient() {
        super(null);
    }

    /**
     * Creates a new ImapClient instance with a given Connection instance.
     */
    public ImapClient(Connection connection) {
        super(connection);
    }

    public void open(String host, int port, boolean ssl, String user, String pass) throws IOException, MailException {
        /**
         * Terminate any open session first.
         */
        if (connected()) close();

        /**
         * Create a connection object matching the current environment (J2ME or
         * J2SE) using the factory method of Connection, then open the socket.
         */
        connection.open(host, (port == 0 ? 143 : port), ssl);

        /**
         * Swallow the initial 'hello' line from the server, then try to
         * authenticate using the given username and password. If something
         * goes wrong, close the whole session.
         */
        try {
            execute("LOGIN", user + " " + pass, null);
            execute("SELECT", "INBOX", null);
        }
        catch (MailException e) {
            connection.close();

            throw e;
        }
    }

    public void close() throws IOException, MailException {
        if (connected()) {
            execute("CLOSE", null, null);
            execute("LOGOUT", null, null);
        }

        connection.close();
    }

    /**
     * Handles a request/response pair. This is a convenience method used
     * internally to handle sending a request to the IMAP server as well as
     * receiving the response. If the response starts with a "-" sign, and thus
     * denotes a protocol error, an exception is raised to reflect it. Note that
     * the request is only sent if it doesn't equal null, while the response is
     * always being waited for.
     *
     * @see #send
     * @see #receive
     * @see MailException
     */
    private String execute(String command, String arguments, Message message) throws IOException, MailException {
        String result = null;

        String tag = "A" + commandCount++ + " ";
        connection.send(tag + command + (arguments == null ? "" : " " + arguments));

        String temp = connection.receive();
        while (!temp.startsWith(tag)) {
            if (temp.indexOf(" " + command + " ") != -1) {
                int p = temp.indexOf('(');
                int q = temp.indexOf(')', p + 1);

                if (p != -1) {
                    if (q > p) {
                        result = temp.substring(p + 1, q);
                    }
                    else if (message != null) {
                        int left = temp.indexOf('{');
                        int right = temp.indexOf('}', left);

                        receiveMessage(message, Integer.parseInt(temp.substring(left + 1, right)));
                    }
                }
            }
            temp = connection.receive();
        }

        temp = temp.substring(tag.length());
        if (temp.startsWith("BAD ") || temp.startsWith("NO ")) {
            throw new MailException(temp);
        }

        return result;
    }

    public int getMessageCount() throws IOException, MailException {
        String buffer = execute("STATUS", "INBOX (MESSAGES)", null);

        /**
         * The result of the "STAT" request should always be "+OK <#msgs> <#bytes>",
         * so we simply fetch the number between the first and the second space
         * (and keep our fingers crossed that every POP3 implementation follows the
         * RFC).
         */
        int space = buffer.indexOf(' ');

        return Integer.parseInt(buffer.substring(space + 1));
    }

    /**
     * Receives a message. This method receives a whole message from the server
     * and stores the header and body parts in the according vectors. It is able
     * to undo any byte stuffing produced by the server. It also undoes header
     * folding in a way, putting multiple header lines that belong to one
     * field into a single line of the header vector.
     * <p>
     * The method assumes that either a "RETR" or a "TOP" command has already
     * been issued, so that it can only be called from the getMessage() and
     * getHeader() methods (whom it serves as an internal helper method).
     *
     * @see #getMessage
     * @see #getHeaders
     */
    private void receiveMessage(Message message, int size) throws IOException, MailException {
        int count = 0;

        /**
         * First we read the header lines. The end of the header is denoted by
         * an empty line.
         */
        String buffer = connection.receive();
        int octets = buffer.length() + 2;

        while (!(buffer.equals(""))) {
            /**
             * Undo header folding, that is, put logical header lines that span
             * multiple physical ones into one vector entry. This eases dealing
             * with header fields a lot.
             */
            if (buffer.startsWith(" ") || buffer.startsWith("\t")) {
                message.setHeaderLine(count - 1, message.getHeaderLine(count - 1) + "\r\n" + buffer);
            }
            else {
                message.addHeaderLine(buffer);
                count++;
            }

            buffer = connection.receive();
            octets = octets + buffer.length() + 2;
        }

        /**
         * Next we read the body lines. The end of the body is denoted by a line
         * consisting only of a dot (which is the usual end of multiline respones).
         */
        while (octets < size) {
            buffer = connection.receive();
            octets = octets + buffer.length() + 2;
            message.addBodyLine(buffer);
        }
    }

    public Message getMessage(int index) throws IOException, MailException {
        Message message = new Message();
        execute("FETCH", (index + 1)+ " (RFC822)", message);
        return message;
    }

    public Message getHeaders(int index) throws IOException, MailException {
        Message message = new Message();
        execute("FETCH", (index + 1)+ " (RFC822.HEADER)", message);
        return message;
    }

    public void removeMessage(int index) throws IOException, MailException {
        execute("STORE", (index + 1) + " +FLAGS.SILENT (\\DELETED)", null);
    }

    public String getUniqueId(int index) throws IOException, MailException {
        String buffer = execute("FETCH", (index + 1) + " (UID)", null); // in Klammern?

        int space = buffer.indexOf(' ');

        return buffer.substring(space + 1);
    }

    public int getSize(int index) throws IOException, MailException {
        String buffer = execute("FETCH", (index + 1) + " (RFC822.SIZE)", null); // in Klammern?

        int space = buffer.indexOf(' ');

        return Integer.parseInt(buffer.substring(space + 1));
    }
}