Coverage report

  %line %branch
org.apache.commons.net.smtp.SMTPClient
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.IOException;
 19  
 import java.io.Writer;
 20  
 import java.net.InetAddress;
 21  
 import org.apache.commons.net.io.DotTerminatedMessageWriter;
 22  
 
 23  
 /***
 24  
  * SMTPClient encapsulates all the functionality necessary to send files
 25  
  * through an SMTP server.  This class takes care of all
 26  
  * low level details of interacting with an SMTP server and provides
 27  
  * a convenient higher level interface.  As with all classes derived
 28  
  * from {@link org.apache.commons.net.SocketClient},
 29  
  * you must first connect to the server with
 30  
  * {@link org.apache.commons.net.SocketClient#connect  connect }
 31  
  * before doing anything, and finally
 32  
  * {@link org.apache.commons.net.SocketClient#disconnect  disconnect }
 33  
  * after you're completely finished interacting with the server.
 34  
  * Then you need to check the SMTP reply code to see if the connection
 35  
  * was successful.  For example:
 36  
  * <pre>
 37  
  *    try {
 38  
  *      int reply;
 39  
  *      client.connect("mail.foobar.com");
 40  
  *      System.out.print(client.getReplyString());
 41  
  *
 42  
  *      // After connection attempt, you should check the reply code to verify
 43  
  *      // success.
 44  
  *      reply = client.getReplyCode();
 45  
  *
 46  
  *      if(!SMTPReply.isPositiveCompletion(reply)) {
 47  
  *        client.disconnect();
 48  
  *        System.err.println("SMTP server refused connection.");
 49  
  *        System.exit(1);
 50  
  *      }
 51  
  *
 52  
  *      // Do useful stuff here.
 53  
  *      ...
 54  
  *    } catch(IOException e) {
 55  
  *      if(client.isConnected()) {
 56  
  *        try {
 57  
  *          client.disconnect();
 58  
  *        } catch(IOException f) {
 59  
  *          // do nothing
 60  
  *        }
 61  
  *      }
 62  
  *      System.err.println("Could not connect to server.");
 63  
  *      e.printStackTrace();
 64  
  *      System.exit(1);
 65  
  *    }
 66  
  * </pre>
 67  
  * <p>
 68  
  * Immediately after connecting is the only real time you need to check the
 69  
  * reply code (because connect is of type void).  The convention for all the
 70  
  * SMTP command methods in SMTPClient is such that they either return a
 71  
  * boolean value or some other value.
 72  
  * The boolean methods return true on a successful completion reply from
 73  
  * the SMTP server and false on a reply resulting in an error condition or
 74  
  * failure.  The methods returning a value other than boolean return a value
 75  
  * containing the higher level data produced by the SMTP command, or null if a
 76  
  * reply resulted in an error condition or failure.  If you want to access
 77  
  * the exact SMTP reply code causing a success or failure, you must call
 78  
  * {@link org.apache.commons.net.smtp.SMTP#getReplyCode  getReplyCode } after
 79  
  * a success or failure.
 80  
  * <p>
 81  
  * You should keep in mind that the SMTP server may choose to prematurely
 82  
  * close a connection for various reasons.  The SMTPClient class will detect a
 83  
  * premature SMTP server connection closing when it receives a
 84  
  * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE SMTPReply.SERVICE_NOT_AVAILABLE }
 85  
  *  response to a command.
 86  
  * When that occurs, the method encountering that reply will throw
 87  
  * an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException}
 88  
  * .
 89  
  * <code>SMTPConectionClosedException</code>
 90  
  * is a subclass of <code> IOException </code> and therefore need not be
 91  
  * caught separately, but if you are going to catch it separately, its
 92  
  * catch block must appear before the more general <code> IOException </code>
 93  
  * catch block.  When you encounter an
 94  
  * {@link org.apache.commons.net.smtp.SMTPConnectionClosedException}
 95  
  * , you must disconnect the connection with
 96  
  * {@link #disconnect  disconnect() } to properly clean up the
 97  
  * system resources used by SMTPClient.  Before disconnecting, you may check
 98  
  * the last reply code and text with
 99  
  * {@link org.apache.commons.net.smtp.SMTP#getReplyCode  getReplyCode },
 100  
  * {@link org.apache.commons.net.smtp.SMTP#getReplyString  getReplyString },
 101  
  * and
 102  
  * {@link org.apache.commons.net.smtp.SMTP#getReplyStrings getReplyStrings}.
 103  
  * <p>
 104  
  * Rather than list it separately for each method, we mention here that
 105  
  * every method communicating with the server and throwing an IOException
 106  
  * can also throw a
 107  
  * {@link org.apache.commons.net.MalformedServerReplyException}
 108  
  * , which is a subclass
 109  
  * of IOException.  A MalformedServerReplyException will be thrown when
 110  
  * the reply received from the server deviates enough from the protocol
 111  
  * specification that it cannot be interpreted in a useful manner despite
 112  
  * attempts to be as lenient as possible.
 113  
  * <p>
 114  
  * <p>
 115  
  * @author Daniel F. Savarese
 116  
  * @see SMTP
 117  
  * @see SimpleSMTPHeader
 118  
  * @see RelayPath
 119  
  * @see SMTPConnectionClosedException
 120  
  * @see org.apache.commons.net.MalformedServerReplyException
 121  
  ***/
 122  
 
 123  0
 public class SMTPClient extends SMTP
 124  
 {
 125  
 
 126  
     /*
 127  
      * Default SMTPClient constructor.  Creates a new SMTPClient instance.
 128  
      */
 129  
     //public SMTPClient() {  }
 130  
 
 131  
 
 132  
     /***
 133  
      * At least one SMTPClient method ({@link #sendMessageData  sendMessageData })
 134  
      * does not complete the entire sequence of SMTP commands to complete a
 135  
      * transaction.  These types of commands require some action by the
 136  
      * programmer after the reception of a positive intermediate command.
 137  
      * After the programmer's code completes its actions, it must call this
 138  
      * method to receive the completion reply from the server and verify the
 139  
      * success of the entire transaction.
 140  
      * <p>
 141  
      * For example,
 142  
      * <pre>
 143  
      * writer = client.sendMessage();
 144  
      * if(writer == null) // failure
 145  
      *   return false;
 146  
      * header =
 147  
      *  new SimpleSMTPHeader("foobar@foo.com", "foo@foobar.com", "Re: Foo");
 148  
      * writer.write(header.toString());
 149  
      * writer.write("This is just a test");
 150  
      * writer.close();
 151  
      * if(!client.completePendingCommand()) // failure
 152  
      *   return false;
 153  
      * </pre>
 154  
      * <p>
 155  
      * @return True if successfully completed, false if not.
 156  
      * @exception SMTPConnectionClosedException
 157  
      *      If the SMTP server prematurely closes the connection as a result
 158  
      *      of the client being idle or some other reason causing the server
 159  
      *      to send SMTP reply code 421.  This exception may be caught either
 160  
      *      as an IOException or independently as itself.
 161  
      * @exception IOException  If an I/O error occurs while either sending a
 162  
      *      command to the server or receiving a reply from the server.
 163  
      ***/
 164  
     public boolean completePendingCommand() throws IOException
 165  
     {
 166  0
         return SMTPReply.isPositiveCompletion(getReply());
 167  
     }
 168  
 
 169  
 
 170  
     /***
 171  
      * Login to the SMTP server by sending the HELO command with the
 172  
      * given hostname as an argument.  Before performing any mail commands,
 173  
      * you must first login.
 174  
      * <p>
 175  
      * @param hostname  The hostname with which to greet the SMTP server.
 176  
      * @return True if successfully completed, false if not.
 177  
      * @exception SMTPConnectionClosedException
 178  
      *      If the SMTP server prematurely closes the connection as a result
 179  
      *      of the client being idle or some other reason causing the server
 180  
      *      to send SMTP reply code 421.  This exception may be caught either
 181  
      *      as an IOException or independently as itself.
 182  
      * @exception IOException  If an I/O error occurs while either sending a
 183  
      *      command to the server or receiving a reply from the server.
 184  
      ***/
 185  
     public boolean login(String hostname) throws IOException
 186  
     {
 187  0
         return SMTPReply.isPositiveCompletion(helo(hostname));
 188  
     }
 189  
 
 190  
 
 191  
     /***
 192  
      * Login to the SMTP server by sending the HELO command with the
 193  
      * client hostname as an argument.  Before performing any mail commands,
 194  
      * you must first login.
 195  
      * <p>
 196  
      * @return True if successfully completed, false if not.
 197  
      * @exception SMTPConnectionClosedException
 198  
      *      If the SMTP server prematurely closes the connection as a result
 199  
      *      of the client being idle or some other reason causing the server
 200  
      *      to send SMTP reply code 421.  This exception may be caught either
 201  
      *      as an IOException or independently as itself.
 202  
      * @exception IOException  If an I/O error occurs while either sending a
 203  
      *      command to the server or receiving a reply from the server.
 204  
      ***/
 205  
     public boolean login() throws IOException
 206  
     {
 207  
         String name;
 208  
         InetAddress host;
 209  
 
 210  0
         host = getLocalAddress();
 211  0
         name = host.getHostName();
 212  
 
 213  0
         if (name == null)
 214  0
             return false;
 215  
 
 216  0
         return SMTPReply.isPositiveCompletion(helo(name));
 217  
     }
 218  
 
 219  
 
 220  
     /***
 221  
      * Set the sender of a message using the SMTP MAIL command, specifying
 222  
      * a reverse relay path.  The sender must be set first before any
 223  
      * recipients may be specified, otherwise the mail server will reject
 224  
      * your commands.
 225  
      * <p>
 226  
      * @param path  The reverse relay path pointing back to the sender.
 227  
      * @return True if successfully completed, false if not.
 228  
      * @exception SMTPConnectionClosedException
 229  
      *      If the SMTP server prematurely closes the connection as a result
 230  
      *      of the client being idle or some other reason causing the server
 231  
      *      to send SMTP reply code 421.  This exception may be caught either
 232  
      *      as an IOException or independently as itself.
 233  
      * @exception IOException  If an I/O error occurs while either sending a
 234  
      *      command to the server or receiving a reply from the server.
 235  
      ***/
 236  
     public boolean setSender(RelayPath path) throws IOException
 237  
     {
 238  0
         return SMTPReply.isPositiveCompletion(mail(path.toString()));
 239  
     }
 240  
 
 241  
 
 242  
     /***
 243  
      * Set the sender of a message using the SMTP MAIL command, specifying
 244  
      * the sender's email address. The sender must be set first before any
 245  
      * recipients may be specified, otherwise the mail server will reject
 246  
      * your commands.
 247  
      * <p>
 248  
      * @param address  The sender's email address.
 249  
      * @return True if successfully completed, false if not.
 250  
      * @exception SMTPConnectionClosedException
 251  
      *      If the SMTP server prematurely closes the connection as a result
 252  
      *      of the client being idle or some other reason causing the server
 253  
      *      to send SMTP reply code 421.  This exception may be caught either
 254  
      *      as an IOException or independently as itself.
 255  
      * @exception IOException  If an I/O error occurs while either sending a
 256  
      *      command to the server or receiving a reply from the server.
 257  
      ***/
 258  
     public boolean setSender(String address) throws IOException
 259  
     {
 260  0
         return SMTPReply.isPositiveCompletion(mail("<" + address + ">"));
 261  
     }
 262  
 
 263  
 
 264  
     /***
 265  
      * Add a recipient for a message using the SMTP RCPT command, specifying
 266  
      * a forward relay path.  The sender must be set first before any
 267  
      * recipients may be specified, otherwise the mail server will reject
 268  
      * your commands.
 269  
      * <p>
 270  
      * @param path  The forward relay path pointing to the recipient.
 271  
      * @return True if successfully completed, false if not.
 272  
      * @exception SMTPConnectionClosedException
 273  
      *      If the SMTP server prematurely closes the connection as a result
 274  
      *      of the client being idle or some other reason causing the server
 275  
      *      to send SMTP reply code 421.  This exception may be caught either
 276  
      *      as an IOException or independently as itself.
 277  
      * @exception IOException  If an I/O error occurs while either sending a
 278  
      *      command to the server or receiving a reply from the server.
 279  
      ***/
 280  
     public boolean addRecipient(RelayPath path) throws IOException
 281  
     {
 282  0
         return SMTPReply.isPositiveCompletion(rcpt(path.toString()));
 283  
     }
 284  
 
 285  
 
 286  
     /***
 287  
      * Add a recipient for a message using the SMTP RCPT command, the
 288  
      * recipient's email address.  The sender must be set first before any
 289  
      * recipients may be specified, otherwise the mail server will reject
 290  
      * your commands.
 291  
      * <p>
 292  
      * @param address  The recipient's email address.
 293  
      * @return True if successfully completed, false if not.
 294  
      * @exception SMTPConnectionClosedException
 295  
      *      If the SMTP server prematurely closes the connection as a result
 296  
      *      of the client being idle or some other reason causing the server
 297  
      *      to send SMTP reply code 421.  This exception may be caught either
 298  
      *      as an IOException or independently as itself.
 299  
      * @exception IOException  If an I/O error occurs while either sending a
 300  
      *      command to the server or receiving a reply from the server.
 301  
      ***/
 302  
     public boolean addRecipient(String address) throws IOException
 303  
     {
 304  0
         return SMTPReply.isPositiveCompletion(rcpt("<" + address + ">"));
 305  
     }
 306  
 
 307  
 
 308  
 
 309  
     /***
 310  
      * Send the SMTP DATA command in preparation to send an email message.
 311  
      * This method returns a DotTerminatedMessageWriter instance to which
 312  
      * the message can be written.  Null is returned if the DATA command
 313  
      * fails.
 314  
      * <p>
 315  
      * You must not issue any commands to the SMTP server (i.e., call any
 316  
      * (other methods) until you finish writing to the returned Writer
 317  
      * instance and close it.  The SMTP protocol uses the same stream for
 318  
      * issuing commands as it does for returning results.  Therefore the
 319  
      * returned Writer actually writes directly to the SMTP connection.
 320  
      * After you close the writer, you can execute new commands.  If you
 321  
      * do not follow these requirements your program will not work properly.
 322  
      * <p>
 323  
      * You can use the provided
 324  
      * {@link org.apache.commons.net.smtp.SimpleSMTPHeader}
 325  
      * class to construct a bare minimum header.
 326  
      * To construct more complicated headers you should
 327  
      * refer to RFC 822.  When the Java Mail API is finalized, you will be
 328  
      * able to use it to compose fully compliant Internet text messages.
 329  
      * The DotTerminatedMessageWriter takes care of doubling line-leading
 330  
      * dots and ending the message with a single dot upon closing, so all
 331  
      * you have to worry about is writing the header and the message.
 332  
      * <p>
 333  
      * Upon closing the returned Writer, you need to call
 334  
      * {@link #completePendingCommand  completePendingCommand() }
 335  
      * to finalize the transaction and verify its success or failure from
 336  
      * the server reply.
 337  
      * <p>
 338  
      * @return A DotTerminatedMessageWriter to which the message (including
 339  
      *      header) can be written.  Returns null if the command fails.
 340  
      * @exception SMTPConnectionClosedException
 341  
      *      If the SMTP server prematurely closes the connection as a result
 342  
      *      of the client being idle or some other reason causing the server
 343  
      *      to send SMTP reply code 421.  This exception may be caught either
 344  
      *      as an IOException or independently as itself.
 345  
      * @exception IOException  If an I/O error occurs while either sending a
 346  
      *      command to the server or receiving a reply from the server.
 347  
      ***/
 348  
     public Writer sendMessageData() throws IOException
 349  
     {
 350  0
         if (!SMTPReply.isPositiveIntermediate(data()))
 351  0
             return null;
 352  
 
 353  0
         return new DotTerminatedMessageWriter(_writer);
 354  
     }
 355  
 
 356  
 
 357  
     /***
 358  
      * A convenience method for sending short messages.  This method fetches
 359  
      * the Writer returned by {@link #sendMessageData  sendMessageData() }
 360  
      * and writes the specified String to it.  After writing the message,
 361  
      * this method calls {@link #completePendingCommand completePendingCommand() }
 362  
      *  to finalize the transaction and returns
 363  
      * its success or failure.
 364  
      * <p>
 365  
      * @param message  The short email message to send.
 366  
      * @return True if successfully completed, false if not.
 367  
      * @exception SMTPConnectionClosedException
 368  
      *      If the SMTP server prematurely closes the connection as a result
 369  
      *      of the client being idle or some other reason causing the server
 370  
      *      to send SMTP reply code 421.  This exception may be caught either
 371  
      *      as an IOException or independently as itself.
 372  
      * @exception IOException  If an I/O error occurs while either sending a
 373  
      *      command to the server or receiving a reply from the server.
 374  
      ***/
 375  
     public boolean sendShortMessageData(String message) throws IOException
 376  
     {
 377  
         Writer writer;
 378  
 
 379  0
         writer = sendMessageData();
 380  
 
 381  0
         if (writer == null)
 382  0
             return false;
 383  
 
 384  0
         writer.write(message);
 385  0
         writer.close();
 386  
 
 387  0
         return completePendingCommand();
 388  
     }
 389  
 
 390  
 
 391  
     /***
 392  
      * A convenience method for a sending short email without having to
 393  
      * explicitly set the sender and recipient(s).  This method
 394  
      * sets the sender and recipient using
 395  
      * {@link #setSender  setSender } and
 396  
      * {@link #addRecipient  addRecipient }, and then sends the
 397  
      * message using {@link #sendShortMessageData  sendShortMessageData }.
 398  
      * <p>
 399  
      * @param sender  The email address of the sender.
 400  
      * @param recipient  The email address of the recipient.
 401  
      * @param message  The short email message to send.
 402  
      * @return True if successfully completed, false if not.
 403  
      * @exception SMTPConnectionClosedException
 404  
      *      If the SMTP server prematurely closes the connection as a result
 405  
      *      of the client being idle or some other reason causing the server
 406  
      *      to send SMTP reply code 421.  This exception may be caught either
 407  
      *      as an IOException or independently as itself.
 408  
      * @exception IOException  If an I/O error occurs while either sending a
 409  
      *      command to the server or receiving a reply from the server.
 410  
      ***/
 411  
     public boolean sendSimpleMessage(String sender, String recipient,
 412  
                                      String message)
 413  
     throws IOException
 414  
     {
 415  0
         if (!setSender(sender))
 416  0
             return false;
 417  
 
 418  0
         if (!addRecipient(recipient))
 419  0
             return false;
 420  
 
 421  0
         return sendShortMessageData(message);
 422  
     }
 423  
 
 424  
 
 425  
 
 426  
     /***
 427  
      * A convenience method for a sending short email without having to
 428  
      * explicitly set the sender and recipient(s).  This method
 429  
      * sets the sender and recipients using
 430  
      * {@link #setSender  setSender } and
 431  
      * {@link #addRecipient  addRecipient }, and then sends the
 432  
      * message using {@link #sendShortMessageData  sendShortMessageData }.
 433  
      * <p>
 434  
      * @param sender  The email address of the sender.
 435  
      * @param recipients  An array of recipient email addresses.
 436  
      * @param message  The short email message to send.
 437  
      * @return True if successfully completed, false if not.
 438  
      * @exception SMTPConnectionClosedException
 439  
      *      If the SMTP server prematurely closes the connection as a result
 440  
      *      of the client being idle or some other reason causing the server
 441  
      *      to send SMTP reply code 421.  This exception may be caught either
 442  
      *      as an IOException or independently as itself.
 443  
      * @exception IOException  If an I/O error occurs while either sending a
 444  
      *      command to the server or receiving a reply from the server.
 445  
      ***/
 446  
     public boolean sendSimpleMessage(String sender, String[] recipients,
 447  
                                      String message)
 448  
     throws IOException
 449  
     {
 450  0
         boolean oneSuccess = false;
 451  
         int count;
 452  
 
 453  0
         if (!setSender(sender))
 454  0
             return false;
 455  
 
 456  0
         for (count = 0; count < recipients.length; count++)
 457  
         {
 458  0
             if (addRecipient(recipients[count]))
 459  0
                 oneSuccess = true;
 460  
         }
 461  
 
 462  0
         if (!oneSuccess)
 463  0
             return false;
 464  
 
 465  0
         return sendShortMessageData(message);
 466  
     }
 467  
 
 468  
 
 469  
     /***
 470  
      * Logout of the SMTP server by sending the QUIT command.
 471  
      * <p>
 472  
      * @return True if successfully completed, false if not.
 473  
      * @exception SMTPConnectionClosedException
 474  
      *      If the SMTP server prematurely closes the connection as a result
 475  
      *      of the client being idle or some other reason causing the server
 476  
      *      to send SMTP reply code 421.  This exception may be caught either
 477  
      *      as an IOException or independently as itself.
 478  
      * @exception IOException  If an I/O error occurs while either sending a
 479  
      *      command to the server or receiving a reply from the server.
 480  
      ***/
 481  
     public boolean logout() throws IOException
 482  
     {
 483  0
         return SMTPReply.isPositiveCompletion(quit());
 484  
     }
 485  
 
 486  
 
 487  
 
 488  
     /***
 489  
      * Aborts the current mail transaction, resetting all server stored
 490  
      * sender, recipient, and mail data, cleaing all buffers and tables.
 491  
      * <p>
 492  
      * @return True if successfully completed, false if not.
 493  
      * @exception SMTPConnectionClosedException
 494  
      *      If the SMTP server prematurely closes the connection as a result
 495  
      *      of the client being idle or some other reason causing the server
 496  
      *      to send SMTP reply code 421.  This exception may be caught either
 497  
      *      as an IOException or independently as itself.
 498  
      * @exception IOException  If an I/O error occurs while either sending a
 499  
      *      command to the server or receiving a reply from the server.
 500  
      ***/
 501  
     public boolean reset() throws IOException
 502  
     {
 503  0
         return SMTPReply.isPositiveCompletion(rset());
 504  
     }
 505  
 
 506  
 
 507  
     /***
 508  
      * Verify that a username or email address is valid, i.e., that mail
 509  
      * can be delivered to that mailbox on the server.
 510  
      * <p>
 511  
      * @param username  The username or email address to validate.
 512  
      * @return True if the username is valid, false if not.
 513  
      * @exception SMTPConnectionClosedException
 514  
      *      If the SMTP server prematurely closes the connection as a result
 515  
      *      of the client being idle or some other reason causing the server
 516  
      *      to send SMTP reply code 421.  This exception may be caught either
 517  
      *      as an IOException or independently as itself.
 518  
      * @exception IOException  If an I/O error occurs while either sending a
 519  
      *      command to the server or receiving a reply from the server.
 520  
      ***/
 521  
     public boolean verify(String username) throws IOException
 522  
     {
 523  
         int result;
 524  
 
 525  0
         result = vrfy(username);
 526  
 
 527  0
         return (result == SMTPReply.ACTION_OK ||
 528  
                 result == SMTPReply.USER_NOT_LOCAL_WILL_FORWARD);
 529  
     }
 530  
 
 531  
 
 532  
     /***
 533  
      * Fetches the system help information from the server and returns the
 534  
      * full string.
 535  
      * <p>
 536  
      * @return The system help string obtained from the server.  null if the
 537  
      *       information could not be obtained.
 538  
      * @exception SMTPConnectionClosedException
 539  
      *      If the SMTP server prematurely closes the connection as a result
 540  
      *      of the client being idle or some other reason causing the server
 541  
      *      to send SMTP reply code 421.  This exception may be caught either
 542  
      *      as an IOException or independently as itself.
 543  
      * @exception IOException  If an I/O error occurs while either sending a
 544  
      *  command to the server or receiving a reply from the server.
 545  
      ***/
 546  
     public String listHelp() throws IOException
 547  
     {
 548  0
         if (SMTPReply.isPositiveCompletion(help()))
 549  0
             return getReplyString();
 550  0
         return null;
 551  
     }
 552  
 
 553  
 
 554  
     /***
 555  
      * Fetches the help information for a given command from the server and
 556  
      * returns the full string.
 557  
      * <p>
 558  
      * @param command The command on which to ask for help.
 559  
      * @return The command help string obtained from the server.  null if the
 560  
      *       information could not be obtained.
 561  
      * @exception SMTPConnectionClosedException
 562  
      *      If the SMTP server prematurely closes the connection as a result
 563  
      *      of the client being idle or some other reason causing the server
 564  
      *      to send SMTP reply code 421.  This exception may be caught either
 565  
      *      as an IOException or independently as itself.
 566  
      * @exception IOException  If an I/O error occurs while either sending a
 567  
      *  command to the server or receiving a reply from the server.
 568  
      ***/
 569  
     public String listHelp(String command) throws IOException
 570  
     {
 571  0
         if (SMTPReply.isPositiveCompletion(help(command)))
 572  0
             return getReplyString();
 573  0
         return null;
 574  
     }
 575  
 
 576  
 
 577  
     /***
 578  
      * Sends a NOOP command to the SMTP server.  This is useful for preventing
 579  
      * server timeouts.
 580  
      * <p>
 581  
      * @return True if successfully completed, false if not.
 582  
      * @exception SMTPConnectionClosedException
 583  
      *      If the SMTP server prematurely closes the connection as a result
 584  
      *      of the client being idle or some other reason causing the server
 585  
      *      to send SMTP reply code 421.  This exception may be caught either
 586  
      *      as an IOException or independently as itself.
 587  
      * @exception IOException  If an I/O error occurs while either sending a
 588  
      *      command to the server or receiving a reply from the server.
 589  
      ***/
 590  
     public boolean sendNoOp() throws IOException
 591  
     {
 592  0
         return SMTPReply.isPositiveCompletion(noop());
 593  
     }
 594  
 
 595  
 }

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