Coverage report

  %line %branch
org.apache.commons.net.pop3.POP3
0% 
0% 

 1  
 /*
 2  
  * Copyright 2001-2005 The Apache Software Foundation
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *     http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 package org.apache.commons.net.pop3;
 17  
 
 18  
 import java.io.BufferedReader;
 19  
 import java.io.BufferedWriter;
 20  
 import java.io.EOFException;
 21  
 import java.io.IOException;
 22  
 import java.io.InputStreamReader;
 23  
 import java.io.OutputStreamWriter;
 24  
 import java.lang.StringBuffer;
 25  
 import java.util.Enumeration;
 26  
 import java.util.Vector;
 27  
 import org.apache.commons.net.MalformedServerReplyException;
 28  
 import org.apache.commons.net.ProtocolCommandListener;
 29  
 import org.apache.commons.net.ProtocolCommandSupport;
 30  
 import org.apache.commons.net.SocketClient;
 31  
 
 32  
 /***
 33  
  * The POP3 class is not meant to be used by itself and is provided
 34  
  * only so that you may easily implement your own POP3 client if
 35  
  * you so desire.  If you have no need to perform your own implementation,
 36  
  * you should use {@link org.apache.commons.net.pop3.POP3Client}.
 37  
  * <p>
 38  
  * Rather than list it separately for each method, we mention here that
 39  
  * every method communicating with the server and throwing an IOException
 40  
  * can also throw a
 41  
  * {@link org.apache.commons.net.MalformedServerReplyException}
 42  
  * , which is a subclass
 43  
  * of IOException.  A MalformedServerReplyException will be thrown when
 44  
  * the reply received from the server deviates enough from the protocol
 45  
  * specification that it cannot be interpreted in a useful manner despite
 46  
  * attempts to be as lenient as possible.
 47  
  * <p>
 48  
  * <p>
 49  
  * @author Daniel F. Savarese
 50  
  * @see POP3Client
 51  
  * @see org.apache.commons.net.MalformedServerReplyException
 52  
  ***/
 53  
 
 54  
 public class POP3 extends SocketClient
 55  
 {
 56  
     /*** The default POP3 port.  Set to 110 according to RFC 1288. ***/
 57  
     public static final int DEFAULT_PORT = 110;
 58  
     /***
 59  
      * A constant representing the state where the client is not yet connected
 60  
      * to a POP3 server.
 61  
      ***/
 62  
     public static final int DISCONNECTED_STATE = -1;
 63  
     /***  A constant representing the POP3 authorization state. ***/
 64  
     public static final int AUTHORIZATION_STATE = 0;
 65  
     /***  A constant representing the POP3 transaction state. ***/
 66  
     public static final int TRANSACTION_STATE = 1;
 67  
     /***  A constant representing the POP3 update state. ***/
 68  
     public static final int UPDATE_STATE = 2;
 69  
 
 70  
     static final String _OK = "+OK";
 71  
     static final String _ERROR = "-ERR";
 72  
 
 73  
     // We have to ensure that the protocol communication is in ASCII
 74  
     // but we use ISO-8859-1 just in case 8-bit characters cross
 75  
     // the wire.
 76  
     private static final String __DEFAULT_ENCODING = "ISO-8859-1";
 77  
 
 78  
     private int __popState;
 79  
     private BufferedWriter __writer;
 80  
     private StringBuffer __commandBuffer;
 81  
 
 82  
     BufferedReader _reader;
 83  
     int _replyCode;
 84  
     String _lastReplyLine;
 85  
     Vector _replyLines;
 86  
 
 87  
     /***
 88  
      * A ProtocolCommandSupport object used to manage the registering of
 89  
      * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
 90  
      ***/
 91  
     protected ProtocolCommandSupport _commandSupport_;
 92  
 
 93  
     /***
 94  
      * The default POP3Client constructor.  Initializes the state
 95  
      * to <code>DISCONNECTED_STATE</code>.
 96  
      ***/
 97  
     public POP3()
 98  0
     {
 99  0
         setDefaultPort(DEFAULT_PORT);
 100  0
         __commandBuffer = new StringBuffer();
 101  0
         __popState = DISCONNECTED_STATE;
 102  0
         _reader = null;
 103  0
         __writer = null;
 104  0
         _replyLines = new Vector();
 105  0
         _commandSupport_ = new ProtocolCommandSupport(this);
 106  0
     }
 107  
 
 108  
     private void __getReply() throws IOException
 109  
     {
 110  
         String line;
 111  
 
 112  0
         _replyLines.setSize(0);
 113  0
         line = _reader.readLine();
 114  
 
 115  0
         if (line == null)
 116  0
             throw new EOFException("Connection closed without indication.");
 117  
 
 118  0
         if (line.startsWith(_OK))
 119  0
             _replyCode = POP3Reply.OK;
 120  0
         else if (line.startsWith(_ERROR))
 121  0
             _replyCode = POP3Reply.ERROR;
 122  
         else
 123  0
             throw new
 124  
             MalformedServerReplyException(
 125  
                 "Received invalid POP3 protocol response from server.");
 126  
 
 127  0
         _replyLines.addElement(line);
 128  0
         _lastReplyLine = line;
 129  
 
 130  0
         if (_commandSupport_.getListenerCount() > 0)
 131  0
             _commandSupport_.fireReplyReceived(_replyCode, getReplyString());
 132  0
     }
 133  
 
 134  
 
 135  
     /***
 136  
      * Performs connection initialization and sets state to
 137  
      * <code> AUTHORIZATION_STATE </code>.
 138  
      ***/
 139  
     protected void _connectAction_() throws IOException
 140  
     {
 141  0
         super._connectAction_();
 142  0
         _reader =
 143  
           new BufferedReader(class="keyword">new InputStreamReader(_input_,
 144  
                                                    __DEFAULT_ENCODING));
 145  0
         __writer =
 146  
           new BufferedWriter(class="keyword">new OutputStreamWriter(_output_,
 147  
                                                     __DEFAULT_ENCODING));
 148  0
         __getReply();
 149  0
         setState(AUTHORIZATION_STATE);
 150  0
     }
 151  
 
 152  
 
 153  
     /***
 154  
      * Adds a ProtocolCommandListener.  Delegates this task to
 155  
      * {@link #_commandSupport_  _commandSupport_ }.
 156  
      * <p>
 157  
      * @param listener  The ProtocolCommandListener to add.
 158  
      ***/
 159  
     public void addProtocolCommandListener(ProtocolCommandListener listener)
 160  
     {
 161  0
         _commandSupport_.addProtocolCommandListener(listener);
 162  0
     }
 163  
 
 164  
     /***
 165  
      * Removes a ProtocolCommandListener.  Delegates this task to
 166  
      * {@link #_commandSupport_  _commandSupport_ }.
 167  
      * <p>
 168  
      * @param listener  The ProtocolCommandListener to remove.
 169  
      ***/
 170  
     public void removeProtocolCommandistener(ProtocolCommandListener listener)
 171  
     {
 172  0
         _commandSupport_.removeProtocolCommandListener(listener);
 173  0
     }
 174  
 
 175  
 
 176  
     /***
 177  
      * Sets POP3 client state.  This must be one of the
 178  
      * <code>_STATE</code> constants.
 179  
      * <p>
 180  
      * @param state  The new state.
 181  
      ***/
 182  
     public void setState(int state)
 183  
     {
 184  0
         __popState = state;
 185  0
     }
 186  
 
 187  
 
 188  
     /***
 189  
      * Returns the current POP3 client state.
 190  
      * <p>
 191  
      * @return The current POP3 client state.
 192  
      ***/
 193  
     public int getState()
 194  
     {
 195  0
         return __popState;
 196  
     }
 197  
 
 198  
 
 199  
     /***
 200  
      * Retrieves the additional lines of a multi-line server reply.
 201  
      ***/
 202  
     public void getAdditionalReply() throws IOException
 203  
     {
 204  
         String line;
 205  
 
 206  0
         line = _reader.readLine();
 207  0
         while (line != null)
 208  
         {
 209  0
             _replyLines.addElement(line);
 210  0
             if (line.equals("."))
 211  0
                 break;
 212  0
             line = _reader.readLine();
 213  
         }
 214  0
     }
 215  
 
 216  
 
 217  
     /***
 218  
      * Disconnects the client from the server, and sets the state to
 219  
      * <code> DISCONNECTED_STATE </code>.  The reply text information
 220  
      * from the last issued command is voided to allow garbage collection
 221  
      * of the memory used to store that information.
 222  
      * <p>
 223  
      * @exception IOException  If there is an error in disconnecting.
 224  
      ***/
 225  
     public void disconnect() throws IOException
 226  
     {
 227  0
         super.disconnect();
 228  0
         _reader = null;
 229  0
         __writer = null;
 230  0
         _lastReplyLine = null;
 231  0
         _replyLines.setSize(0);
 232  0
         setState(DISCONNECTED_STATE);
 233  0
     }
 234  
 
 235  
 
 236  
     /***
 237  
      * Sends a command an arguments to the server and returns the reply code.
 238  
      * <p>
 239  
      * @param command  The POP3 command to send.
 240  
      * @param args     The command arguments.
 241  
      * @return  The server reply code (either POP3Reply.OK or POP3Reply.ERROR).
 242  
      ***/
 243  
     public int sendCommand(String command, String args) throws IOException
 244  
     {
 245  
         String message;
 246  
 
 247  0
         __commandBuffer.setLength(0);
 248  0
         __commandBuffer.append(command);
 249  
 
 250  0
         if (args != null)
 251  
         {
 252  0
             __commandBuffer.append(' ');
 253  0
             __commandBuffer.append(args);
 254  
         }
 255  0
         __commandBuffer.append(SocketClient.NETASCII_EOL);
 256  
 
 257  0
         __writer.write(message = __commandBuffer.toString());
 258  0
         __writer.flush();
 259  
 
 260  0
         if (_commandSupport_.getListenerCount() > 0)
 261  0
             _commandSupport_.fireCommandSent(command, message);
 262  
 
 263  0
         __getReply();
 264  0
         return _replyCode;
 265  
     }
 266  
 
 267  
     /***
 268  
      * Sends a command with no arguments to the server and returns the
 269  
      * reply code.
 270  
      * <p>
 271  
      * @param command  The POP3 command to send.
 272  
      * @return  The server reply code (either POP3Reply.OK or POP3Reply.ERROR).
 273  
      ***/
 274  
     public int sendCommand(String command) throws IOException
 275  
     {
 276  0
         return sendCommand(command, null);
 277  
     }
 278  
 
 279  
     /***
 280  
      * Sends a command an arguments to the server and returns the reply code.
 281  
      * <p>
 282  
      * @param command  The POP3 command to send
 283  
      *                  (one of the POP3Command constants).
 284  
      * @param args     The command arguments.
 285  
      * @return  The server reply code (either POP3Reply.OK or POP3Reply.ERROR).
 286  
      ***/
 287  
     public int sendCommand(class="keyword">int command, String args) throws IOException
 288  
     {
 289  0
         return sendCommand(POP3Command._commands[command], args);
 290  
     }
 291  
 
 292  
     /***
 293  
      * Sends a command with no arguments to the server and returns the
 294  
      * reply code.
 295  
      * <p>
 296  
      * @param command  The POP3 command to send
 297  
      *                  (one of the POP3Command constants).
 298  
      * @return  The server reply code (either POP3Reply.OK or POP3Reply.ERROR).
 299  
      ***/
 300  
     public int sendCommand(class="keyword">int command) throws IOException
 301  
     {
 302  0
         return sendCommand(POP3Command._commands[command], null);
 303  
     }
 304  
 
 305  
 
 306  
     /***
 307  
      * Returns an array of lines received as a reply to the last command
 308  
      * sent to the server.  The lines have end of lines truncated.  If
 309  
      * the reply is a single line, but its format ndicates it should be
 310  
      * a multiline reply, then you must call
 311  
      * {@link #getAdditionalReply  getAdditionalReply() } to
 312  
      * fetch the rest of the reply, and then call <code>getReplyStrings</code>
 313  
      * again.  You only have to worry about this if you are implementing
 314  
      * your own client using the {@link #sendCommand  sendCommand } methods.
 315  
      * <p>
 316  
      * @return The last server response.
 317  
      ***/
 318  
     public String[] getReplyStrings()
 319  
     {
 320  
         String[] lines;
 321  0
         lines = new String[_replyLines.size()];
 322  0
         _replyLines.copyInto(lines);
 323  0
         return lines;
 324  
     }
 325  
 
 326  
     /***
 327  
      * Returns the reply to the last command sent to the server.
 328  
      * The value is a single string containing all the reply lines including
 329  
      * newlines.  If the reply is a single line, but its format ndicates it
 330  
      * should be a multiline reply, then you must call
 331  
      * {@link #getAdditionalReply  getAdditionalReply() } to
 332  
      * fetch the rest of the reply, and then call <code>getReplyString</code>
 333  
      * again.  You only have to worry about this if you are implementing
 334  
      * your own client using the {@link #sendCommand  sendCommand } methods.
 335  
      * <p>
 336  
      * @return The last server response.
 337  
      ***/
 338  
     public String getReplyString()
 339  
     {
 340  
         Enumeration en;
 341  0
         StringBuffer buffer = new StringBuffer(256);
 342  
 
 343  0
         en = _replyLines.elements();
 344  0
         while (en.hasMoreElements())
 345  
         {
 346  0
             buffer.append((String)en.nextElement());
 347  0
             buffer.append(SocketClient.NETASCII_EOL);
 348  
         }
 349  
 
 350  0
         return buffer.toString();
 351  
     }
 352  
 
 353  
 }
 354  
 

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.