Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.smtp.SMTP |
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.smtp;
17 |  |
18 |  |
     import java.io.BufferedReader;
19 |  |
     import java.io.BufferedWriter;
20 |  |
     import java.io.IOException;
21 |  |
     import java.io.InputStreamReader;
22 |  |
     import java.io.OutputStreamWriter;
23 |  |
     import java.util.Enumeration;
24 |  |
     import java.util.Vector;
25 |  |
     import org.apache.commons.net.MalformedServerReplyException;
26 |  |
     import org.apache.commons.net.ProtocolCommandListener;
27 |  |
     import org.apache.commons.net.ProtocolCommandSupport;
28 |  |
     import org.apache.commons.net.SocketClient;
29 |  |
30 |  |
     /***
31 |  |
      * SMTP provides the basic the functionality necessary to implement your
32 |  |
      * own SMTP client.  To derive the full benefits of the SMTP class requires
33 |  |
      * some knowledge of the FTP protocol defined in RFC 821.  However, there
34 |  |
      * is no reason why you should have to use the SMTP class.  The
35 |  |
      * {@link org.apache.commons.net.smtp.SMTPClient} class,
36 |  |
      * derived from SMTP,
37 |  |
      * implements all the functionality required of an SMTP client.  The
38 |  |
      * SMTP class is made public to provide access to various SMTP constants
39 |  |
      * and to make it easier for adventurous programmers (or those with
40 |  |
      * special needs) to interact with the SMTP protocol and implement their
41 |  |
      * own clients.  A set of methods with names corresponding to the SMTP
42 |  |
      * command names are provided to facilitate this interaction.
43 |  |
      * <p>
44 |  |
      * You should keep in mind that the SMTP server may choose to prematurely
45 |  |
      * close a connection for various reasons.  The SMTP class will detect a
46 |  |
      * premature SMTP server connection closing when it receives a
47 |  |
      * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE SMTPReply.SERVICE_NOT_AVAILABLE }
48 |  |
      *  response to a command.
49 |  |
      * When that occurs, the SMTP class method encountering that reply will throw
50 |  |
      * an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException}
51 |  |
      * .
52 |  |
      * <code>SMTPConectionClosedException</code>
53 |  |
      * is a subclass of <code> IOException </code> and therefore need not be
54 |  |
      * caught separately, but if you are going to catch it separately, its
55 |  |
      * catch block must appear before the more general <code> IOException </code>
56 |  |
      * catch block.  When you encounter an
57 |  |
      * {@link org.apache.commons.net.smtp.SMTPConnectionClosedException}
58 |  |
      * , you must disconnect the connection with
59 |  |
      * {@link org.apache.commons.net.SocketClient#disconnect  disconnect() }
60 |  |
      * to properly clean up the system resources used by SMTP.  Before
61 |  |
      * disconnecting, you may check the
62 |  |
      * last reply code and text with
63 |  |
      * {@link #getReplyCode  getReplyCode },
64 |  |
      * {@link #getReplyString  getReplyString },
65 |  |
      * and {@link #getReplyStrings  getReplyStrings}.
66 |  |
      * <p>
67 |  |
      * Rather than list it separately for each method, we mention here that
68 |  |
      * every method communicating with the server and throwing an IOException
69 |  |
      * can also throw a
70 |  |
      * {@link org.apache.commons.net.MalformedServerReplyException}
71 |  |
      * , which is a subclass
72 |  |
      * of IOException.  A MalformedServerReplyException will be thrown when
73 |  |
      * the reply received from the server deviates enough from the protocol
74 |  |
      * specification that it cannot be interpreted in a useful manner despite
75 |  |
      * attempts to be as lenient as possible.
76 |  |
      * <p>
77 |  |
      * <p>
78 |  |
      * @author Daniel F. Savarese
79 |  |
      * @see SMTPClient
80 |  |
      * @see SMTPConnectionClosedException
81 |  |
      * @see org.apache.commons.net.MalformedServerReplyException
82 |  |
      ***/
83 |  |
84 |  |
     public class SMTP extends SocketClient
85 |  |
     {
86 |  |
         /*** The default SMTP port (25). ***/
87 |  |
         public static final int DEFAULT_PORT = 25;
88 |  |
89 |  |
         // We have to ensure that the protocol communication is in ASCII
90 |  |
         // but we use ISO-8859-1 just in case 8-bit characters cross
91 |  |
         // the wire.
92 |  |
         private static final String __DEFAULT_ENCODING = "ISO-8859-1";
93 |  |
94 |  |
         private StringBuffer __commandBuffer;
95 |  |
96 |  |
         BufferedReader _reader;
97 |  |
         BufferedWriter _writer;
98 |  |
         int _replyCode;
99 |  |
         Vector _replyLines;
100 |  |
         boolean _newReplyString;
101 |  |
         String _replyString;
102 |  |
103 |  |
         /***
104 |  |
          * A ProtocolCommandSupport object used to manage the registering of
105 |  |
          * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
106 |  |
          ***/
107 |  |
         protected ProtocolCommandSupport _commandSupport_;
108 |  |
109 |  |
         /***
110 |  |
          * The default SMTP constructor.  Sets the default port to
111 |  |
          * <code>DEFAULT_PORT</code> and initializes internal data structures
112 |  |
          * for saving SMTP reply information.
113 |  |
          ***/
114 |  |
         public SMTP()
115 | 0 |
         {
116 | 0 |
             setDefaultPort(DEFAULT_PORT);
117 | 0 |
             __commandBuffer = new StringBuffer();
118 | 0 |
             _replyLines = new Vector();
119 | 0 |
             _newReplyString = false;
120 | 0 |
             _replyString = null;
121 | 0 |
             _commandSupport_ = new ProtocolCommandSupport(this);
122 | 0 |
         }
123 |  |
124 |  |
         private int __sendCommand(String command, String args, boolean includeSpace)
125 |  |
         throws IOException
126 |  |
         {
127 |  |
             String message;
128 |  |
129 | 0 |
             __commandBuffer.setLength(0);
130 | 0 |
             __commandBuffer.append(command);
131 |  |
132 | 0 |
             if (args != null)
133 |  |
             {
134 | 0 |
                 if (includeSpace)
135 | 0 |
                     __commandBuffer.append(' ');
136 | 0 |
                 __commandBuffer.append(args);
137 |  |
             }
138 |  |
139 | 0 |
             __commandBuffer.append(SocketClient.NETASCII_EOL);
140 |  |
141 | 0 |
             _writer.write(message = __commandBuffer.toString());
142 | 0 |
             _writer.flush();
143 |  |
144 | 0 |
             if (_commandSupport_.getListenerCount() > 0)
145 | 0 |
                 _commandSupport_.fireCommandSent(command, message);
146 |  |
147 | 0 |
             __getReply();
148 | 0 |
             return _replyCode;
149 |  |
         }
150 |  |
151 |  |
         private int __sendCommand(class="keyword">int command, String args, boolean includeSpace)
152 |  |
         throws IOException
153 |  |
         {
154 | 0 |
             return __sendCommand(SMTPCommand._commands[command], args, includeSpace);
155 |  |
         }
156 |  |
157 |  |
         private void __getReply() throws IOException
158 |  |
         {
159 |  |
             int length;
160 |  |
161 | 0 |
             _newReplyString = true;
162 | 0 |
             _replyLines.setSize(0);
163 |  |
164 | 0 |
             String line = _reader.readLine();
165 |  |
166 | 0 |
             if (line == null)
167 | 0 |
                 throw new SMTPConnectionClosedException(
168 |  |
                     "Connection closed without indication.");
169 |  |
170 |  |
             // In case we run into an anomaly we don't want fatal index exceptions
171 |  |
             // to be thrown.
172 | 0 |
             length = line.length();
173 | 0 |
             if (length < 3)
174 | 0 |
                 throw new MalformedServerReplyException(
175 |  |
                     "Truncated server reply: " + line);
176 |  |
177 |  |
             try
178 |  |
             {
179 | 0 |
                 String code = line.substring(0, 3);
180 | 0 |
                 _replyCode = Integer.parseInt(code);
181 |  |
             }
182 | 0 |
             catch (NumberFormatException e)
183 |  |
             {
184 | 0 |
                 throw new MalformedServerReplyException(
185 |  |
                     "Could not parse response code.\nServer Reply: " + line);
186 | 0 |
             }
187 |  |
188 | 0 |
             _replyLines.addElement(line);
189 |  |
190 |  |
             // Get extra lines if message continues.
191 | 0 |
             if (length > 3 && line.charAt(3) == '-')
192 |  |
             {
193 |  |
                 do
194 |  |
                 {
195 | 0 |
                     line = _reader.readLine();
196 |  |
197 | 0 |
                     if (line == null)
198 | 0 |
                         throw new SMTPConnectionClosedException(
199 |  |
                             "Connection closed without indication.");
200 |  |
201 | 0 |
                     _replyLines.addElement(line);
202 |  |
203 |  |
                     // The length() check handles problems that could arise from readLine()
204 |  |
                     // returning too soon after encountering a naked CR or some other
205 |  |
                     // anomaly.
206 |  |
                 }
207 | 0 |
                 while (!(line.length() >= 4 && line.charAt(3) != '-' &&
208 |  |
                          Character.isDigit(line.charAt(0))));
209 |  |
                 // This is too strong a condition because a non-conforming server
210 |  |
                 // could screw things up like ftp.funet.fi does for FTP
211 |  |
                 // line.startsWith(code)));
212 |  |
             }
213 |  |
214 | 0 |
             if (_commandSupport_.getListenerCount() > 0)
215 | 0 |
                 _commandSupport_.fireReplyReceived(_replyCode, getReplyString());
216 |  |
217 | 0 |
             if (_replyCode == SMTPReply.SERVICE_NOT_AVAILABLE)
218 | 0 |
                 throw new SMTPConnectionClosedException(
219 |  |
                     "SMTP response 421 received.  Server closed connection.");
220 | 0 |
         }
221 |  |
222 |  |
         /*** Initiates control connections and gets initial reply. ***/
223 |  |
         protected void _connectAction_() throws IOException
224 |  |
         {
225 | 0 |
             super._connectAction_();
226 | 0 |
             _reader =
227 |  |
                 new BufferedReader(class="keyword">new InputStreamReader(_input_,
228 |  |
                                                          __DEFAULT_ENCODING));
229 | 0 |
             _writer =
230 |  |
                 new BufferedWriter(class="keyword">new OutputStreamWriter(_output_,
231 |  |
                                                           __DEFAULT_ENCODING));
232 | 0 |
             __getReply();
233 | 0 |
         }
234 |  |
235 |  |
236 |  |
         /***
237 |  |
          * Adds a ProtocolCommandListener.  Delegates this task to
238 |  |
          * {@link #_commandSupport_  _commandSupport_ }.
239 |  |
          * <p>
240 |  |
          * @param listener  The ProtocolCommandListener to add.
241 |  |
          ***/
242 |  |
         public void addProtocolCommandListener(ProtocolCommandListener listener)
243 |  |
         {
244 | 0 |
             _commandSupport_.addProtocolCommandListener(listener);
245 | 0 |
         }
246 |  |
247 |  |
         /***
248 |  |
          * Removes a ProtocolCommandListener.  Delegates this task to
249 |  |
          * {@link #_commandSupport_  _commandSupport_ }.
250 |  |
          * <p>
251 |  |
          * @param listener  The ProtocolCommandListener to remove.
252 |  |
          ***/
253 |  |
         public void removeProtocolCommandistener(ProtocolCommandListener listener)
254 |  |
         {
255 | 0 |
             _commandSupport_.removeProtocolCommandListener(listener);
256 | 0 |
         }
257 |  |
258 |  |
259 |  |
         /***
260 |  |
          * Closes the connection to the SMTP server and sets to null
261 |  |
          * some internal data so that the memory may be reclaimed by the
262 |  |
          * garbage collector.  The reply text and code information from the
263 |  |
          * last command is voided so that the memory it used may be reclaimed.
264 |  |
          * <p>
265 |  |
          * @exception IOException If an error occurs while disconnecting.
266 |  |
          ***/
267 |  |
         public void disconnect() throws IOException
268 |  |
         {
269 | 0 |
             super.disconnect();
270 | 0 |
             _reader = null;
271 | 0 |
             _writer = null;
272 | 0 |
             _replyString = null;
273 | 0 |
             _replyLines.setSize(0);
274 | 0 |
             _newReplyString = false;
275 | 0 |
         }
276 |  |
277 |  |
278 |  |
         /***
279 |  |
          * Sends an SMTP command to the server, waits for a reply and returns the
280 |  |
          * numerical response code.  After invocation, for more detailed
281 |  |
          * information, the actual reply text can be accessed by calling
282 |  |
          * {@link #getReplyString  getReplyString } or
283 |  |
          * {@link #getReplyStrings  getReplyStrings }.
284 |  |
          * <p>
285 |  |
          * @param command  The text representation of the  SMTP command to send.
286 |  |
          * @param args The arguments to the SMTP command.  If this parameter is
287 |  |
          *             set to null, then the command is sent with no argument.
288 |  |
          * @return The integer value of the SMTP reply code returned by the server
289 |  |
          *         in response to the command.
290 |  |
          * @exception SMTPConnectionClosedException
291 |  |
          *      If the SMTP server prematurely closes the connection as a result
292 |  |
          *      of the client being idle or some other reason causing the server
293 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
294 |  |
          *      as an IOException or independently as itself.
295 |  |
          * @exception IOException  If an I/O error occurs while either sending the
296 |  |
          *      command or receiving the server reply.
297 |  |
          ***/
298 |  |
         public int sendCommand(String command, String args) throws IOException
299 |  |
         {
300 | 0 |
             return __sendCommand(command, args, true);
301 |  |
         }
302 |  |
303 |  |
304 |  |
         /***
305 |  |
          * Sends an SMTP command to the server, waits for a reply and returns the
306 |  |
          * numerical response code.  After invocation, for more detailed
307 |  |
          * information, the actual reply text can be accessed by calling
308 |  |
          * {@link #getReplyString  getReplyString } or
309 |  |
          * {@link #getReplyStrings  getReplyStrings }.
310 |  |
          * <p>
311 |  |
          * @param command  The SMTPCommand constant corresponding to the SMTP command
312 |  |
          *                 to send.
313 |  |
          * @param args The arguments to the SMTP command.  If this parameter is
314 |  |
          *             set to null, then the command is sent with no argument.
315 |  |
          * @return The integer value of the SMTP reply code returned by the server
316 |  |
          *         in response to the command.
317 |  |
          * @exception SMTPConnectionClosedException
318 |  |
          *      If the SMTP server prematurely closes the connection as a result
319 |  |
          *      of the client being idle or some other reason causing the server
320 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
321 |  |
          *      as an IOException or independently as itself.
322 |  |
          * @exception IOException  If an I/O error occurs while either sending the
323 |  |
          *      command or receiving the server reply.
324 |  |
          ***/
325 |  |
         public int sendCommand(class="keyword">int command, String args) throws IOException
326 |  |
         {
327 | 0 |
             return sendCommand(SMTPCommand._commands[command], args);
328 |  |
         }
329 |  |
330 |  |
331 |  |
         /***
332 |  |
          * Sends an SMTP command with no arguments to the server, waits for a
333 |  |
          * reply and returns the numerical response code.  After invocation, for
334 |  |
          * more detailed information, the actual reply text can be accessed by
335 |  |
          * calling {@link #getReplyString  getReplyString } or
336 |  |
          * {@link #getReplyStrings  getReplyStrings }.
337 |  |
          * <p>
338 |  |
          * @param command  The text representation of the  SMTP command to send.
339 |  |
          * @return The integer value of the SMTP reply code returned by the server
340 |  |
          *         in response to the command.
341 |  |
          * @exception SMTPConnectionClosedException
342 |  |
          *      If the SMTP server prematurely closes the connection as a result
343 |  |
          *      of the client being idle or some other reason causing the server
344 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
345 |  |
          *      as an IOException or independently as itself.
346 |  |
          * @exception IOException  If an I/O error occurs while either sending the
347 |  |
          *      command or receiving the server reply.
348 |  |
          ***/
349 |  |
         public int sendCommand(String command) throws IOException
350 |  |
         {
351 | 0 |
             return sendCommand(command, null);
352 |  |
         }
353 |  |
354 |  |
355 |  |
         /***
356 |  |
          * Sends an SMTP command with no arguments to the server, waits for a
357 |  |
          * reply and returns the numerical response code.  After invocation, for
358 |  |
          * more detailed information, the actual reply text can be accessed by
359 |  |
          * calling {@link #getReplyString  getReplyString } or
360 |  |
          * {@link #getReplyStrings  getReplyStrings }.
361 |  |
          * <p>
362 |  |
          * @param command  The SMTPCommand constant corresponding to the SMTP command
363 |  |
          *                 to send.
364 |  |
          * @return The integer value of the SMTP reply code returned by the server
365 |  |
          *         in response to the command.
366 |  |
          * @exception SMTPConnectionClosedException
367 |  |
          *      If the SMTP server prematurely closes the connection as a result
368 |  |
          *      of the client being idle or some other reason causing the server
369 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
370 |  |
          *      as an IOException or independently as itself.
371 |  |
          * @exception IOException  If an I/O error occurs while either sending the
372 |  |
          *      command or receiving the server reply.
373 |  |
          ***/
374 |  |
         public int sendCommand(class="keyword">int command) throws IOException
375 |  |
         {
376 | 0 |
             return sendCommand(command, null);
377 |  |
         }
378 |  |
379 |  |
380 |  |
         /***
381 |  |
          * Returns the integer value of the reply code of the last SMTP reply.
382 |  |
          * You will usually only use this method after you connect to the
383 |  |
          * SMTP server to check that the connection was successful since
384 |  |
          * <code> connect </code> is of type void.
385 |  |
          * <p>
386 |  |
          * @return The integer value of the reply code of the last SMTP reply.
387 |  |
          ***/
388 |  |
         public int getReplyCode()
389 |  |
         {
390 | 0 |
             return _replyCode;
391 |  |
         }
392 |  |
393 |  |
         /***
394 |  |
          * Fetches a reply from the SMTP server and returns the integer reply
395 |  |
          * code.  After calling this method, the actual reply text can be accessed
396 |  |
          * from either  calling {@link #getReplyString  getReplyString } or
397 |  |
          * {@link #getReplyStrings  getReplyStrings }.  Only use this
398 |  |
          * method if you are implementing your own SMTP client or if you need to
399 |  |
          * fetch a secondary response from the SMTP server.
400 |  |
          * <p>
401 |  |
          * @return The integer value of the reply code of the fetched SMTP reply.
402 |  |
          * @exception SMTPConnectionClosedException
403 |  |
          *      If the SMTP server prematurely closes the connection as a result
404 |  |
          *      of the client being idle or some other reason causing the server
405 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
406 |  |
          *      as an IOException or independently as itself.
407 |  |
          * @exception IOException  If an I/O error occurs while receiving the
408 |  |
          *                         server reply.
409 |  |
          ***/
410 |  |
         public int getReply() throws IOException
411 |  |
         {
412 | 0 |
             __getReply();
413 | 0 |
             return _replyCode;
414 |  |
         }
415 |  |
416 |  |
417 |  |
         /***
418 |  |
          * Returns the lines of text from the last SMTP server response as an array
419 |  |
          * of strings, one entry per line.  The end of line markers of each are
420 |  |
          * stripped from each line.
421 |  |
          * <p>
422 |  |
          * @return The lines of text from the last SMTP response as an array.
423 |  |
          ***/
424 |  |
         public String[] getReplyStrings()
425 |  |
         {
426 |  |
             String[] lines;
427 | 0 |
             lines = new String[_replyLines.size()];
428 | 0 |
             _replyLines.copyInto(lines);
429 | 0 |
             return lines;
430 |  |
         }
431 |  |
432 |  |
         /***
433 |  |
          * Returns the entire text of the last SMTP server response exactly
434 |  |
          * as it was received, including all end of line markers in NETASCII
435 |  |
          * format.
436 |  |
          * <p>
437 |  |
          * @return The entire text from the last SMTP response as a String.
438 |  |
          ***/
439 |  |
         public String getReplyString()
440 |  |
         {
441 |  |
             Enumeration en;
442 |  |
             StringBuffer buffer;
443 |  |
444 | 0 |
             if (!_newReplyString)
445 | 0 |
                 return _replyString;
446 |  |
447 | 0 |
             buffer = new StringBuffer(256);
448 | 0 |
             en = _replyLines.elements();
449 | 0 |
             while (en.hasMoreElements())
450 |  |
             {
451 | 0 |
                 buffer.append((String)en.nextElement());
452 | 0 |
                 buffer.append(SocketClient.NETASCII_EOL);
453 |  |
             }
454 |  |
455 | 0 |
             _newReplyString = false;
456 |  |
457 | 0 |
             return (_replyString = buffer.toString());
458 |  |
         }
459 |  |
460 |  |
461 |  |
         /***
462 |  |
          * A convenience method to send the SMTP HELO command to the server,
463 |  |
          * receive the reply, and return the reply code.
464 |  |
          * <p>
465 |  |
          * @param hostname The hostname of the sender.
466 |  |
          * @return The reply code received from the server.
467 |  |
          * @exception SMTPConnectionClosedException
468 |  |
          *      If the SMTP server prematurely closes the connection as a result
469 |  |
          *      of the client being idle or some other reason causing the server
470 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
471 |  |
          *      as an IOException or independently as itself.
472 |  |
          * @exception IOException  If an I/O error occurs while either sending the
473 |  |
          *      command or receiving the server reply.
474 |  |
          ***/
475 |  |
         public int helo(String hostname) throws IOException
476 |  |
         {
477 | 0 |
             return sendCommand(SMTPCommand.HELO, hostname);
478 |  |
         }
479 |  |
480 |  |
481 |  |
         /***
482 |  |
          * A convenience method to send the SMTP MAIL command to the server,
483 |  |
          * receive the reply, and return the reply code.
484 |  |
          * <p>
485 |  |
          * @param reversePath The reverese path.
486 |  |
          * @return The reply code received from the server.
487 |  |
          * @exception SMTPConnectionClosedException
488 |  |
          *      If the SMTP server prematurely closes the connection as a result
489 |  |
          *      of the client being idle or some other reason causing the server
490 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
491 |  |
          *      as an IOException or independently as itself.
492 |  |
          * @exception IOException  If an I/O error occurs while either sending the
493 |  |
          *      command or receiving the server reply.
494 |  |
          ***/
495 |  |
         public int mail(String reversePath) throws IOException
496 |  |
         {
497 | 0 |
             return __sendCommand(SMTPCommand.MAIL, reversePath, false);
498 |  |
         }
499 |  |
500 |  |
501 |  |
         /***
502 |  |
          * A convenience method to send the SMTP RCPT command to the server,
503 |  |
          * receive the reply, and return the reply code.
504 |  |
          * <p>
505 |  |
          * @param forwardPath The forward path.
506 |  |
          * @return The reply code received from the server.
507 |  |
          * @exception SMTPConnectionClosedException
508 |  |
          *      If the SMTP server prematurely closes the connection as a result
509 |  |
          *      of the client being idle or some other reason causing the server
510 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
511 |  |
          *      as an IOException or independently as itself.
512 |  |
          * @exception IOException  If an I/O error occurs while either sending the
513 |  |
          *      command or receiving the server reply.
514 |  |
          ***/
515 |  |
         public int rcpt(String forwardPath) throws IOException
516 |  |
         {
517 | 0 |
             return __sendCommand(SMTPCommand.RCPT, forwardPath, false);
518 |  |
         }
519 |  |
520 |  |
521 |  |
         /***
522 |  |
          * A convenience method to send the SMTP DATA command to the server,
523 |  |
          * receive the reply, and return the reply code.
524 |  |
          * <p>
525 |  |
          * @return The reply code received from the server.
526 |  |
          * @exception SMTPConnectionClosedException
527 |  |
          *      If the SMTP server prematurely closes the connection as a result
528 |  |
          *      of the client being idle or some other reason causing the server
529 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
530 |  |
          *      as an IOException or independently as itself.
531 |  |
          * @exception IOException  If an I/O error occurs while either sending the
532 |  |
          *      command or receiving the server reply.
533 |  |
          ***/
534 |  |
         public int data() throws IOException
535 |  |
         {
536 | 0 |
             return sendCommand(SMTPCommand.DATA);
537 |  |
         }
538 |  |
539 |  |
540 |  |
         /***
541 |  |
          * A convenience method to send the SMTP SEND command to the server,
542 |  |
          * receive the reply, and return the reply code.
543 |  |
          * <p>
544 |  |
          * @param reversePath The reverese path.
545 |  |
          * @return The reply code received from the server.
546 |  |
          * @exception SMTPConnectionClosedException
547 |  |
          *      If the SMTP server prematurely closes the connection as a result
548 |  |
          *      of the client being idle or some other reason causing the server
549 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
550 |  |
          *      as an IOException or independently as itself.
551 |  |
          * @exception IOException  If an I/O error occurs while either sending the
552 |  |
          *      command or receiving the server reply.
553 |  |
          ***/
554 |  |
         public int send(String reversePath) throws IOException
555 |  |
         {
556 | 0 |
             return sendCommand(SMTPCommand.SEND, reversePath);
557 |  |
         }
558 |  |
559 |  |
560 |  |
         /***
561 |  |
          * A convenience method to send the SMTP SOML command to the server,
562 |  |
          * receive the reply, and return the reply code.
563 |  |
          * <p>
564 |  |
          * @param reversePath The reverese path.
565 |  |
          * @return The reply code received from the server.
566 |  |
          * @exception SMTPConnectionClosedException
567 |  |
          *      If the SMTP server prematurely closes the connection as a result
568 |  |
          *      of the client being idle or some other reason causing the server
569 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
570 |  |
          *      as an IOException or independently as itself.
571 |  |
          * @exception IOException  If an I/O error occurs while either sending the
572 |  |
          *      command or receiving the server reply.
573 |  |
          ***/
574 |  |
         public int soml(String reversePath) throws IOException
575 |  |
         {
576 | 0 |
             return sendCommand(SMTPCommand.SOML, reversePath);
577 |  |
         }
578 |  |
579 |  |
580 |  |
         /***
581 |  |
          * A convenience method to send the SMTP SAML command to the server,
582 |  |
          * receive the reply, and return the reply code.
583 |  |
          * <p>
584 |  |
          * @param reversePath The reverese path.
585 |  |
          * @return The reply code received from the server.
586 |  |
          * @exception SMTPConnectionClosedException
587 |  |
          *      If the SMTP server prematurely closes the connection as a result
588 |  |
          *      of the client being idle or some other reason causing the server
589 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
590 |  |
          *      as an IOException or independently as itself.
591 |  |
          * @exception IOException  If an I/O error occurs while either sending the
592 |  |
          *      command or receiving the server reply.
593 |  |
          ***/
594 |  |
         public int saml(String reversePath) throws IOException
595 |  |
         {
596 | 0 |
             return sendCommand(SMTPCommand.SAML, reversePath);
597 |  |
         }
598 |  |
599 |  |
600 |  |
         /***
601 |  |
          * A convenience method to send the SMTP RSET command to the server,
602 |  |
          * receive the reply, and return the reply code.
603 |  |
          * <p>
604 |  |
          * @return The reply code received from the server.
605 |  |
          * @exception SMTPConnectionClosedException
606 |  |
          *      If the SMTP server prematurely closes the connection as a result
607 |  |
          *      of the client being idle or some other reason causing the server
608 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
609 |  |
          *      as an IOException or independently as itself.
610 |  |
          * @exception IOException  If an I/O error occurs while either sending the
611 |  |
          *      command or receiving the server reply.
612 |  |
          ***/
613 |  |
         public int rset() throws IOException
614 |  |
         {
615 | 0 |
             return sendCommand(SMTPCommand.RSET);
616 |  |
         }
617 |  |
618 |  |
619 |  |
         /***
620 |  |
          * A convenience method to send the SMTP VRFY command to the server,
621 |  |
          * receive the reply, and return the reply code.
622 |  |
          * <p>
623 |  |
          * @param user The user address to verify.
624 |  |
          * @return The reply code received from the server.
625 |  |
          * @exception SMTPConnectionClosedException
626 |  |
          *      If the SMTP server prematurely closes the connection as a result
627 |  |
          *      of the client being idle or some other reason causing the server
628 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
629 |  |
          *      as an IOException or independently as itself.
630 |  |
          * @exception IOException  If an I/O error occurs while either sending the
631 |  |
          *      command or receiving the server reply.
632 |  |
          ***/
633 |  |
         public int vrfy(String user) throws IOException
634 |  |
         {
635 | 0 |
             return sendCommand(SMTPCommand.VRFY, user);
636 |  |
         }
637 |  |
638 |  |
639 |  |
         /***
640 |  |
          * A convenience method to send the SMTP VRFY command to the server,
641 |  |
          * receive the reply, and return the reply code.
642 |  |
          * <p>
643 |  |
          * @param name The name to expand.
644 |  |
          * @return The reply code received from the server.
645 |  |
          * @exception SMTPConnectionClosedException
646 |  |
          *      If the SMTP server prematurely closes the connection as a result
647 |  |
          *      of the client being idle or some other reason causing the server
648 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
649 |  |
          *      as an IOException or independently as itself.
650 |  |
          * @exception IOException  If an I/O error occurs while either sending the
651 |  |
          *      command or receiving the server reply.
652 |  |
          ***/
653 |  |
         public int expn(String name) throws IOException
654 |  |
         {
655 | 0 |
             return sendCommand(SMTPCommand.EXPN, name);
656 |  |
         }
657 |  |
658 |  |
         /***
659 |  |
          * A convenience method to send the SMTP HELP command to the server,
660 |  |
          * receive the reply, and return the reply code.
661 |  |
          * <p>
662 |  |
          * @return The reply code received from the server.
663 |  |
          * @exception SMTPConnectionClosedException
664 |  |
          *      If the SMTP server prematurely closes the connection as a result
665 |  |
          *      of the client being idle or some other reason causing the server
666 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
667 |  |
          *      as an IOException or independently as itself.
668 |  |
          * @exception IOException  If an I/O error occurs while either sending the
669 |  |
          *      command or receiving the server reply.
670 |  |
          ***/
671 |  |
         public int help() throws IOException
672 |  |
         {
673 | 0 |
             return sendCommand(SMTPCommand.HELP);
674 |  |
         }
675 |  |
676 |  |
         /***
677 |  |
          * A convenience method to send the SMTP HELP command to the server,
678 |  |
          * receive the reply, and return the reply code.
679 |  |
          * <p>
680 |  |
          * @param command  The command name on which to request help.
681 |  |
          * @return The reply code received from the server.
682 |  |
          * @exception SMTPConnectionClosedException
683 |  |
          *      If the SMTP server prematurely closes the connection as a result
684 |  |
          *      of the client being idle or some other reason causing the server
685 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
686 |  |
          *      as an IOException or independently as itself.
687 |  |
          * @exception IOException  If an I/O error occurs while either sending the
688 |  |
          *      command or receiving the server reply.
689 |  |
          ***/
690 |  |
         public int help(String command) throws IOException
691 |  |
         {
692 | 0 |
             return sendCommand(SMTPCommand.HELP, command);
693 |  |
         }
694 |  |
695 |  |
         /***
696 |  |
          * A convenience method to send the SMTP NOOP command to the server,
697 |  |
          * receive the reply, and return the reply code.
698 |  |
          * <p>
699 |  |
          * @return The reply code received from the server.
700 |  |
          * @exception SMTPConnectionClosedException
701 |  |
          *      If the SMTP server prematurely closes the connection as a result
702 |  |
          *      of the client being idle or some other reason causing the server
703 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
704 |  |
          *      as an IOException or independently as itself.
705 |  |
          * @exception IOException  If an I/O error occurs while either sending the
706 |  |
          *      command or receiving the server reply.
707 |  |
          ***/
708 |  |
         public int noop() throws IOException
709 |  |
         {
710 | 0 |
             return sendCommand(SMTPCommand.NOOP);
711 |  |
         }
712 |  |
713 |  |
714 |  |
         /***
715 |  |
          * A convenience method to send the SMTP TURN command to the server,
716 |  |
          * receive the reply, and return the reply code.
717 |  |
          * <p>
718 |  |
          * @return The reply code received from the server.
719 |  |
          * @exception SMTPConnectionClosedException
720 |  |
          *      If the SMTP server prematurely closes the connection as a result
721 |  |
          *      of the client being idle or some other reason causing the server
722 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
723 |  |
          *      as an IOException or independently as itself.
724 |  |
          * @exception IOException  If an I/O error occurs while either sending the
725 |  |
          *      command or receiving the server reply.
726 |  |
          ***/
727 |  |
         public int turn() throws IOException
728 |  |
         {
729 | 0 |
             return sendCommand(SMTPCommand.TURN);
730 |  |
         }
731 |  |
732 |  |
733 |  |
         /***
734 |  |
          * A convenience method to send the SMTP QUIT command to the server,
735 |  |
          * receive the reply, and return the reply code.
736 |  |
          * <p>
737 |  |
          * @return The reply code received from the server.
738 |  |
          * @exception SMTPConnectionClosedException
739 |  |
          *      If the SMTP server prematurely closes the connection as a result
740 |  |
          *      of the client being idle or some other reason causing the server
741 |  |
          *      to send SMTP reply code 421.  This exception may be caught either
742 |  |
          *      as an IOException or independently as itself.
743 |  |
          * @exception IOException  If an I/O error occurs while either sending the
744 |  |
          *      command or receiving the server reply.
745 |  |
          ***/
746 |  |
         public int quit() throws IOException
747 |  |
         {
748 | 0 |
             return sendCommand(SMTPCommand.QUIT);
749 |  |
         }
750 |  |
751 |  |
     }
752 |  |
753 |  |
     /* Emacs configuration
754 |  |
      * Local variables:        **
755 |  |
      * mode:             java  **
756 |  |
      * c-basic-offset:   4     **
757 |  |
      * indent-tabs-mode: nil   **
758 |  |
      * End:                    **
759 |  |
      */

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