pop3client.java

Pop3协议的java实现代码

                // Prcoess as many of the responses as possible.
                ///////////////////////////////////////////////////////////////////

                while ( !m_pendingList.isEmpty() )
                {
                    l_commandType = (Integer)m_pendingList.firstElement();

                    switch( l_commandType.intValue() )
                    {
                        case CONN:
                            parseConnect();
                            break;
                        case DELE:
                            parseDelete();
                            break;
                        case LISTA:
                            parseListA();
                            break;
                        case LIST:
                            parseList();
                            break;
                        case NOOP:
                            parseNoop();
                            break;
                        case PASS:
                            parsePass();
                            break;
                        case QUIT:
                            parseQuit();
                            m_io.disconnect();
                            break;
                        case RSET:
                            parseRset();
                            break;
                        case RETR:
                            parseRetr();
                            break;
                        case SENDCOMMANDA:
                            parseSendCommandA();
                            break;
                        case SENDCOMMAND:
                            parseSendCommand();
                            break;
                        case STAT:
                            parseStat();
                            break;
                        case TOP:
                            parseTop();
                            break;
                        case UIDLA:
                            parseUidlA();
                            break;
                        case UIDL:
                            parseUidl();
                            break;
                        case USER:
                            parseUser();
                            break;
                        case XAUTHLISTA:
                            parseXAuthListA();
                            break;
                        case XAUTHLIST:
                            parseXAuthList();
                            break;
                        case XSENDER:
                            parseXSender();
                            break;
                    }

                    m_pendingList.removeElementAt( 0 );
                }

                m_mustProcess = false;
            }
            catch( POP3ServerException e )
            {
                m_mustProcess = false;
                m_pendingList.removeElementAt( 0 );
                throw e;
            }
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    // Preferences
    ///////////////////////////////////////////////////////////////////////////

    /**
    *Sets the size of the data chunks that are passed to the response sink
    *for the retrieve() callback.  The chunk size must be >= 1024.
	*@param in_chunkSize Size of chunk used for sending messages using
	*the send method. Minimum chunk size: 1024. Default = 1K.
    *@exception IOException If an I/O error occurs.
    *@see #retrieve
    */
    public synchronized void setChunkSize( int in_chunkSize )
    {
        synchronized(m_responseMessage)
        {
            if ( in_chunkSize < m_minChunkSize )
            {
                throw new IllegalArgumentException();
            }

            m_messageData = new byte[in_chunkSize];
        }
    }

    /**
    *Registers a new response sink, overriding the one passed into the
    *constructor or any set afterwards.
    *Server reponses are routed to this new response sink.
	*@param in_responseSink New POP3 response sink to use.
    *@exception IOException If an I/O error occurs.
    */
    public synchronized void setResponseSink( IPOP3Sink in_responseSink  )
    {
        synchronized(m_responseMessage)
        {
            if ( in_responseSink == null )
            {
                throw new NullPointerException();
            }

            m_notifySink = in_responseSink;
        }
    }

    /**
    *Sets the amount of time allowed to wait before
    *returning control to the user.
	*@param in_timeout Time-out period to set in milliseconds.
	*Values, in milliseconds:
	*<ul>
	*<li>0 = infinite time-out (default)
	*<li>-1 = no waiting
	*<li>> 0 = length of time-out period
	</ul>
    *@exception IOException If an I/O error occurs.
    *@see #processResponses
    */
    public synchronized void setTimeout( int in_timeout ) throws IOException
    {
        synchronized(m_responseMessage)
        {
            if ( in_timeout < -1 )
            {
                throw new IllegalArgumentException();
            }

            m_timeout = in_timeout;

            if ( m_io != null )
            {
                m_io.setTimeout( m_timeout );
            }
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    // Internal functions
    ///////////////////////////////////////////////////////////////////////////

    /**
    *Separates the response code from the message part of the response.
    */
    private final boolean setStatusInfo(
                        byte[] in_response,
                        int in_byteCount,
                        StringBuffer out_responseMessage ) throws IOException
    {
        boolean l_responseStatus;

        if ( in_byteCount < 3 )
        {
            throw new POP3Exception(errParse);
        }

        if ( '+' == (char)in_response[0] &&
                'O' == (char)in_response[1] &&
                'K' == (char)in_response[2] )
        {
            l_responseStatus = true;
        }
        else
        {
            l_responseStatus = false;
        }

        if ( in_byteCount > 4 )
        {
            m_responseMessage.setLength( 0 );

            for ( int count = 4; count < in_byteCount; count++ )
            {
                m_responseMessage.append( (char)m_response[count] );
            }
        }
        else
        {
            m_responseMessage.setLength( 0 );
        }

        return l_responseStatus;
    }

    /**
    *Copies the next token into the specified byte array.
    */
    private final int getNextToken(
                        byte[] in_parseLine,
                        int in_offset,
                        byte[] out_token ) throws IOException
    {
        int i;
        int n = 0;

        for ( i = in_offset; Character.isSpaceChar((char)in_parseLine[i]); i++ )
        {
        }

        while ( i < in_parseLine.length &&
                Character.isDigit((char)in_parseLine[i]) )
        {
            out_token[n++] = in_parseLine[i++];
        }

        out_token[n] = '\0';

        return i;
    }

    /**
    *Copies the bytes in a byte array into a StringBuffer.
    */
    private final void toStringBuffer( StringBuffer out_buffer,
                                    byte[] in_buffer,
                                    int offset,
                                    int in_length )
    {
        out_buffer.setLength( in_length );

        for ( int i = 0; i < in_length; i++ )
        {
            out_buffer.setCharAt( i, (char)in_buffer[offset+i] );
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    // Methods for parsing the responses and invoking sink notifications.
    ///////////////////////////////////////////////////////////////////////////

    private final void parseConnect() throws IOException
    {
        int l_byteCount = m_io.readLine( m_response );

        if ( setStatusInfo( m_response, l_byteCount, m_responseMessage ) )
        {
            m_notifySink.connect( m_responseMessage );
        }
        else
        {
            m_notifySink.error( m_responseMessage );
        }
    }

    private final void parseDelete() throws IOException
    {
        int l_byteCount = m_io.readLine( m_response );

        if ( setStatusInfo( m_response, l_byteCount, m_responseMessage ) )
        {
            m_notifySink.delete( m_responseMessage );
        }
        else
        {
            m_notifySink.error( m_responseMessage );
        }
    }

    private final void parseListA() throws IOException
    {
        int l_offset = 3;
        int l_messageNumber;
        int l_octetCount;
        int l_byteCount = m_io.readLine( m_response );

        if ( setStatusInfo( m_response, l_byteCount, m_responseMessage ) )
        {
            m_notifySink.listStart();

            l_offset = getNextToken( m_response, l_offset, m_tokenBuffer );
            l_messageNumber = m_common.atoi( m_tokenBuffer );
            l_offset = getNextToken( m_response, l_offset, m_tokenBuffer );
            l_octetCount = m_common.atoi( m_tokenBuffer );

            m_notifySink.list( l_messageNumber, l_octetCount );
            m_notifySink.listComplete();
        }
        else
        {
            m_notifySink.error( m_responseMessage );
        }
    }

    private final void parseList() throws IOException
    {
        int l_offset = 0;
        int l_messageNumber;
        int l_octetCount;
        int l_byteCount;
        boolean l_responseStatus;

        if ( m_multiLineState == false )
        {
            l_byteCount = m_io.readLine( m_response );

            if ( setStatusInfo(m_response, l_byteCount, m_responseMessage) )
            {
                m_notifySink.listStart();
            }
            else
            {
                m_notifySink.error( m_responseMessage );
                return;
            }

            m_multiLineState = true;
        }

        l_byteCount = m_io.readLine( m_response );

        while( ('.' != (char)m_response[0]) || ( l_byteCount != 1 ) )
        {
            l_offset = getNextToken( m_response, l_offset, m_tokenBuffer );
            l_messageNumber = m_common.atoi( m_tokenBuffer );
            l_offset = getNextToken( m_response, l_offset, m_tokenBuffer );
            l_octetCount = m_common.atoi( m_tokenBuffer );
            l_offset = 0;

            m_notifySink.list( l_messageNumber, l_octetCount );

            l_byteCount = m_io.readLine( m_response );
        }

        m_multiLineState = false;
        m_notifySink.listComplete();
    }

    private final void parseNoop() throws IOException
    {
        int l_byteCount = m_io.readLine( m_response );

        if ( setStatusInfo( m_response, l_byteCount, m_responseMessage ) )
        {
            m_notifySink.noop();
        }
        else
        {
            m_notifySink.error( m_responseMessage );
        }
    }

    private final void parsePass() throws IOException
    {
        int l_byteCount = m_io.readLine( m_response );

        if ( setStatusInfo( m_response, l_byteCount, m_responseMessage ) )
        {
            m_notifySink.pass( m_responseMessage );
        }
        else
        {
            m_notifySink.error( m_responseMessage );
        }
    }

    private final void parseQuit() throws IOException
    {
        int l_byteCount = m_io.readLine( m_response );

        if ( setStatusInfo( m_response, l_byteCount, m_responseMessage ) )
        {
            m_notifySink.quit( m_responseMessage );
        }
        else
        {
            m_notifySink.error( m_responseMessage );
        }
    }