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

This page was automatically generated by Maven