001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018 package org.apache.commons.net.smtp; 019 020 import java.io.BufferedReader; 021 import java.io.BufferedWriter; 022 import java.io.IOException; 023 import java.io.InputStreamReader; 024 import java.io.OutputStreamWriter; 025 import java.util.ArrayList; 026 import java.util.Arrays; 027 028 import org.apache.commons.net.MalformedServerReplyException; 029 import org.apache.commons.net.ProtocolCommandListener; 030 import org.apache.commons.net.ProtocolCommandSupport; 031 import org.apache.commons.net.SocketClient; 032 033 /*** 034 * SMTP provides the basic the functionality necessary to implement your 035 * own SMTP client. To derive the full benefits of the SMTP class requires 036 * some knowledge of the FTP protocol defined in RFC 821. However, there 037 * is no reason why you should have to use the SMTP class. The 038 * {@link org.apache.commons.net.smtp.SMTPClient} class, 039 * derived from SMTP, 040 * implements all the functionality required of an SMTP client. The 041 * SMTP class is made public to provide access to various SMTP constants 042 * and to make it easier for adventurous programmers (or those with 043 * special needs) to interact with the SMTP protocol and implement their 044 * own clients. A set of methods with names corresponding to the SMTP 045 * command names are provided to facilitate this interaction. 046 * <p> 047 * You should keep in mind that the SMTP server may choose to prematurely 048 * close a connection for various reasons. The SMTP class will detect a 049 * premature SMTP server connection closing when it receives a 050 * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE SMTPReply.SERVICE_NOT_AVAILABLE } 051 * response to a command. 052 * When that occurs, the SMTP class method encountering that reply will throw 053 * an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} 054 * . 055 * <code>SMTPConectionClosedException</code> 056 * is a subclass of <code> IOException </code> and therefore need not be 057 * caught separately, but if you are going to catch it separately, its 058 * catch block must appear before the more general <code> IOException </code> 059 * catch block. When you encounter an 060 * {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} 061 * , you must disconnect the connection with 062 * {@link org.apache.commons.net.SocketClient#disconnect disconnect() } 063 * to properly clean up the system resources used by SMTP. Before 064 * disconnecting, you may check the 065 * last reply code and text with 066 * {@link #getReplyCode getReplyCode }, 067 * {@link #getReplyString getReplyString }, 068 * and {@link #getReplyStrings getReplyStrings}. 069 * <p> 070 * Rather than list it separately for each method, we mention here that 071 * every method communicating with the server and throwing an IOException 072 * can also throw a 073 * {@link org.apache.commons.net.MalformedServerReplyException} 074 * , which is a subclass 075 * of IOException. A MalformedServerReplyException will be thrown when 076 * the reply received from the server deviates enough from the protocol 077 * specification that it cannot be interpreted in a useful manner despite 078 * attempts to be as lenient as possible. 079 * <p> 080 * <p> 081 * @author Daniel F. Savarese 082 * @see SMTPClient 083 * @see SMTPConnectionClosedException 084 * @see org.apache.commons.net.MalformedServerReplyException 085 ***/ 086 087 public class SMTP extends SocketClient 088 { 089 /*** The default SMTP port (25). ***/ 090 public static final int DEFAULT_PORT = 25; 091 092 // We have to ensure that the protocol communication is in ASCII 093 // but we use ISO-8859-1 just in case 8-bit characters cross 094 // the wire. 095 private static final String __DEFAULT_ENCODING = "ISO-8859-1"; 096 097 /** The encoding to use (user-settable) */ 098 private String encoding = __DEFAULT_ENCODING; 099 100 private StringBuffer __commandBuffer; 101 102 BufferedReader _reader; 103 BufferedWriter _writer; 104 int _replyCode; 105 ArrayList<String> _replyLines; 106 boolean _newReplyString; 107 String _replyString; 108 109 /*** 110 * A ProtocolCommandSupport object used to manage the registering of 111 * ProtocolCommandListeners and te firing of ProtocolCommandEvents. 112 ***/ 113 protected ProtocolCommandSupport _commandSupport_; 114 115 /*** 116 * The default SMTP constructor. Sets the default port to 117 * <code>DEFAULT_PORT</code> and initializes internal data structures 118 * for saving SMTP reply information. 119 ***/ 120 public SMTP() 121 { 122 setDefaultPort(DEFAULT_PORT); 123 __commandBuffer = new StringBuffer(); 124 _replyLines = new ArrayList<String>(); 125 _newReplyString = false; 126 _replyString = null; 127 _commandSupport_ = new ProtocolCommandSupport(this); 128 } 129 130 /** 131 * Overloaded constructor where the user may specify a default encoding. 132 * @param encoding 133 * @since 2.0 134 */ 135 public SMTP(String encoding) { 136 this(); 137 this.encoding = encoding; 138 } 139 140 private int __sendCommand(String command, String args, boolean includeSpace) 141 throws IOException 142 { 143 String message; 144 145 __commandBuffer.setLength(0); 146 __commandBuffer.append(command); 147 148 if (args != null) 149 { 150 if (includeSpace) 151 __commandBuffer.append(' '); 152 __commandBuffer.append(args); 153 } 154 155 __commandBuffer.append(SocketClient.NETASCII_EOL); 156 157 _writer.write(message = __commandBuffer.toString()); 158 _writer.flush(); 159 160 if (_commandSupport_.getListenerCount() > 0) 161 _commandSupport_.fireCommandSent(command, message); 162 163 __getReply(); 164 return _replyCode; 165 } 166 167 private int __sendCommand(int command, String args, boolean includeSpace) 168 throws IOException 169 { 170 return __sendCommand(SMTPCommand._commands[command], args, includeSpace); 171 } 172 173 private void __getReply() throws IOException 174 { 175 int length; 176 177 _newReplyString = true; 178 _replyLines.clear(); 179 180 String line = _reader.readLine(); 181 182 if (line == null) 183 throw new SMTPConnectionClosedException( 184 "Connection closed without indication."); 185 186 // In case we run into an anomaly we don't want fatal index exceptions 187 // to be thrown. 188 length = line.length(); 189 if (length < 3) 190 throw new MalformedServerReplyException( 191 "Truncated server reply: " + line); 192 193 try 194 { 195 String code = line.substring(0, 3); 196 _replyCode = Integer.parseInt(code); 197 } 198 catch (NumberFormatException e) 199 { 200 throw new MalformedServerReplyException( 201 "Could not parse response code.\nServer Reply: " + line); 202 } 203 204 _replyLines.add(line); 205 206 // Get extra lines if message continues. 207 if (length > 3 && line.charAt(3) == '-') 208 { 209 do 210 { 211 line = _reader.readLine(); 212 213 if (line == null) 214 throw new SMTPConnectionClosedException( 215 "Connection closed without indication."); 216 217 _replyLines.add(line); 218 219 // The length() check handles problems that could arise from readLine() 220 // returning too soon after encountering a naked CR or some other 221 // anomaly. 222 } 223 while (!(line.length() >= 4 && line.charAt(3) != '-' && 224 Character.isDigit(line.charAt(0)))); 225 // This is too strong a condition because a non-conforming server 226 // could screw things up like ftp.funet.fi does for FTP 227 // line.startsWith(code))); 228 } 229 230 if (_commandSupport_.getListenerCount() > 0) 231 _commandSupport_.fireReplyReceived(_replyCode, getReplyString()); 232 233 if (_replyCode == SMTPReply.SERVICE_NOT_AVAILABLE) 234 throw new SMTPConnectionClosedException( 235 "SMTP response 421 received. Server closed connection."); 236 } 237 238 /*** Initiates control connections and gets initial reply. ***/ 239 @Override 240 protected void _connectAction_() throws IOException 241 { 242 super._connectAction_(); 243 _reader = 244 new BufferedReader(new InputStreamReader(_input_, 245 encoding)); 246 _writer = 247 new BufferedWriter(new OutputStreamWriter(_output_, 248 encoding)); 249 __getReply(); 250 251 } 252 253 254 /*** 255 * Adds a ProtocolCommandListener. Delegates this task to 256 * {@link #_commandSupport_ _commandSupport_ }. 257 * <p> 258 * @param listener The ProtocolCommandListener to add. 259 ***/ 260 public void addProtocolCommandListener(ProtocolCommandListener listener) 261 { 262 _commandSupport_.addProtocolCommandListener(listener); 263 } 264 265 /*** 266 * Removes a ProtocolCommandListener. Delegates this task to 267 * {@link #_commandSupport_ _commandSupport_ }. 268 * <p> 269 * @param listener The ProtocolCommandListener to remove. 270 ***/ 271 public void removeProtocolCommandistener(ProtocolCommandListener listener) 272 { 273 _commandSupport_.removeProtocolCommandListener(listener); 274 } 275 276 277 /*** 278 * Closes the connection to the SMTP server and sets to null 279 * some internal data so that the memory may be reclaimed by the 280 * garbage collector. The reply text and code information from the 281 * last command is voided so that the memory it used may be reclaimed. 282 * <p> 283 * @exception IOException If an error occurs while disconnecting. 284 ***/ 285 @Override 286 public void disconnect() throws IOException 287 { 288 super.disconnect(); 289 _reader = null; 290 _writer = null; 291 _replyString = null; 292 _replyLines.clear(); 293 _newReplyString = false; 294 } 295 296 297 /*** 298 * Sends an SMTP command to the server, waits for a reply and returns the 299 * numerical response code. After invocation, for more detailed 300 * information, the actual reply text can be accessed by calling 301 * {@link #getReplyString getReplyString } or 302 * {@link #getReplyStrings getReplyStrings }. 303 * <p> 304 * @param command The text representation of the SMTP command to send. 305 * @param args The arguments to the SMTP command. If this parameter is 306 * set to null, then the command is sent with no argument. 307 * @return The integer value of the SMTP reply code returned by the server 308 * in response to the command. 309 * @exception SMTPConnectionClosedException 310 * If the SMTP server prematurely closes the connection as a result 311 * of the client being idle or some other reason causing the server 312 * to send SMTP reply code 421. This exception may be caught either 313 * as an IOException or independently as itself. 314 * @exception IOException If an I/O error occurs while either sending the 315 * command or receiving the server reply. 316 ***/ 317 public int sendCommand(String command, String args) throws IOException 318 { 319 return __sendCommand(command, args, true); 320 } 321 322 323 /*** 324 * Sends an SMTP command to the server, waits for a reply and returns the 325 * numerical response code. After invocation, for more detailed 326 * information, the actual reply text can be accessed by calling 327 * {@link #getReplyString getReplyString } or 328 * {@link #getReplyStrings getReplyStrings }. 329 * <p> 330 * @param command The SMTPCommand constant corresponding to the SMTP command 331 * to send. 332 * @param args The arguments to the SMTP command. If this parameter is 333 * set to null, then the command is sent with no argument. 334 * @return The integer value of the SMTP reply code returned by the server 335 * in response to the command. 336 * @exception SMTPConnectionClosedException 337 * If the SMTP server prematurely closes the connection as a result 338 * of the client being idle or some other reason causing the server 339 * to send SMTP reply code 421. This exception may be caught either 340 * as an IOException or independently as itself. 341 * @exception IOException If an I/O error occurs while either sending the 342 * command or receiving the server reply. 343 ***/ 344 public int sendCommand(int command, String args) throws IOException 345 { 346 return sendCommand(SMTPCommand._commands[command], args); 347 } 348 349 350 /*** 351 * Sends an SMTP command with no arguments to the server, waits for a 352 * reply and returns the numerical response code. After invocation, for 353 * more detailed information, the actual reply text can be accessed by 354 * calling {@link #getReplyString getReplyString } or 355 * {@link #getReplyStrings getReplyStrings }. 356 * <p> 357 * @param command The text representation of the SMTP command to send. 358 * @return The integer value of the SMTP reply code returned by the server 359 * in response to the command. 360 * @exception SMTPConnectionClosedException 361 * If the SMTP server prematurely closes the connection as a result 362 * of the client being idle or some other reason causing the server 363 * to send SMTP reply code 421. This exception may be caught either 364 * as an IOException or independently as itself. 365 * @exception IOException If an I/O error occurs while either sending the 366 * command or receiving the server reply. 367 ***/ 368 public int sendCommand(String command) throws IOException 369 { 370 return sendCommand(command, null); 371 } 372 373 374 /*** 375 * Sends an SMTP command with no arguments to the server, waits for a 376 * reply and returns the numerical response code. After invocation, for 377 * more detailed information, the actual reply text can be accessed by 378 * calling {@link #getReplyString getReplyString } or 379 * {@link #getReplyStrings getReplyStrings }. 380 * <p> 381 * @param command The SMTPCommand constant corresponding to the SMTP command 382 * to send. 383 * @return The integer value of the SMTP reply code returned by the server 384 * in response to the command. 385 * @exception SMTPConnectionClosedException 386 * If the SMTP server prematurely closes the connection as a result 387 * of the client being idle or some other reason causing the server 388 * to send SMTP reply code 421. This exception may be caught either 389 * as an IOException or independently as itself. 390 * @exception IOException If an I/O error occurs while either sending the 391 * command or receiving the server reply. 392 ***/ 393 public int sendCommand(int command) throws IOException 394 { 395 return sendCommand(command, null); 396 } 397 398 399 /*** 400 * Returns the integer value of the reply code of the last SMTP reply. 401 * You will usually only use this method after you connect to the 402 * SMTP server to check that the connection was successful since 403 * <code> connect </code> is of type void. 404 * <p> 405 * @return The integer value of the reply code of the last SMTP reply. 406 ***/ 407 public int getReplyCode() 408 { 409 return _replyCode; 410 } 411 412 /*** 413 * Fetches a reply from the SMTP server and returns the integer reply 414 * code. After calling this method, the actual reply text can be accessed 415 * from either calling {@link #getReplyString getReplyString } or 416 * {@link #getReplyStrings getReplyStrings }. Only use this 417 * method if you are implementing your own SMTP client or if you need to 418 * fetch a secondary response from the SMTP server. 419 * <p> 420 * @return The integer value of the reply code of the fetched SMTP reply. 421 * @exception SMTPConnectionClosedException 422 * If the SMTP server prematurely closes the connection as a result 423 * of the client being idle or some other reason causing the server 424 * to send SMTP reply code 421. This exception may be caught either 425 * as an IOException or independently as itself. 426 * @exception IOException If an I/O error occurs while receiving the 427 * server reply. 428 ***/ 429 public int getReply() throws IOException 430 { 431 __getReply(); 432 return _replyCode; 433 } 434 435 436 /*** 437 * Returns the lines of text from the last SMTP server response as an array 438 * of strings, one entry per line. The end of line markers of each are 439 * stripped from each line. 440 * <p> 441 * @return The lines of text from the last SMTP response as an array. 442 ***/ 443 public String[] getReplyStrings() 444 { 445 String[] lines; 446 lines = new String[_replyLines.size()]; 447 _replyLines.addAll(Arrays.asList(lines)); 448 return lines; 449 } 450 451 /*** 452 * Returns the entire text of the last SMTP server response exactly 453 * as it was received, including all end of line markers in NETASCII 454 * format. 455 * <p> 456 * @return The entire text from the last SMTP response as a String. 457 ***/ 458 public String getReplyString() 459 { 460 StringBuilder buffer; 461 462 if (!_newReplyString) 463 return _replyString; 464 465 buffer = new StringBuilder(); 466 467 for (String line : _replyLines) 468 { 469 buffer.append(line); 470 buffer.append(SocketClient.NETASCII_EOL); 471 } 472 473 _newReplyString = false; 474 475 return (_replyString = buffer.toString()); 476 } 477 478 479 /*** 480 * A convenience method to send the SMTP HELO command to the server, 481 * receive the reply, and return the reply code. 482 * <p> 483 * @param hostname The hostname of the sender. 484 * @return The reply code received from the server. 485 * @exception SMTPConnectionClosedException 486 * If the SMTP server prematurely closes the connection as a result 487 * of the client being idle or some other reason causing the server 488 * to send SMTP reply code 421. This exception may be caught either 489 * as an IOException or independently as itself. 490 * @exception IOException If an I/O error occurs while either sending the 491 * command or receiving the server reply. 492 ***/ 493 public int helo(String hostname) throws IOException 494 { 495 return sendCommand(SMTPCommand.HELO, hostname); 496 } 497 498 499 /*** 500 * A convenience method to send the SMTP MAIL command to the server, 501 * receive the reply, and return the reply code. 502 * <p> 503 * @param reversePath The reverese path. 504 * @return The reply code received from the server. 505 * @exception SMTPConnectionClosedException 506 * If the SMTP server prematurely closes the connection as a result 507 * of the client being idle or some other reason causing the server 508 * to send SMTP reply code 421. This exception may be caught either 509 * as an IOException or independently as itself. 510 * @exception IOException If an I/O error occurs while either sending the 511 * command or receiving the server reply. 512 ***/ 513 public int mail(String reversePath) throws IOException 514 { 515 return __sendCommand(SMTPCommand.MAIL, reversePath, false); 516 } 517 518 519 /*** 520 * A convenience method to send the SMTP RCPT command to the server, 521 * receive the reply, and return the reply code. 522 * <p> 523 * @param forwardPath The forward path. 524 * @return The reply code received from the server. 525 * @exception SMTPConnectionClosedException 526 * If the SMTP server prematurely closes the connection as a result 527 * of the client being idle or some other reason causing the server 528 * to send SMTP reply code 421. This exception may be caught either 529 * as an IOException or independently as itself. 530 * @exception IOException If an I/O error occurs while either sending the 531 * command or receiving the server reply. 532 ***/ 533 public int rcpt(String forwardPath) throws IOException 534 { 535 return __sendCommand(SMTPCommand.RCPT, forwardPath, false); 536 } 537 538 539 /*** 540 * A convenience method to send the SMTP DATA command to the server, 541 * receive the reply, and return the reply code. 542 * <p> 543 * @return The reply code received from the server. 544 * @exception SMTPConnectionClosedException 545 * If the SMTP server prematurely closes the connection as a result 546 * of the client being idle or some other reason causing the server 547 * to send SMTP reply code 421. This exception may be caught either 548 * as an IOException or independently as itself. 549 * @exception IOException If an I/O error occurs while either sending the 550 * command or receiving the server reply. 551 ***/ 552 public int data() throws IOException 553 { 554 return sendCommand(SMTPCommand.DATA); 555 } 556 557 558 /*** 559 * A convenience method to send the SMTP SEND command to the server, 560 * receive the reply, and return the reply code. 561 * <p> 562 * @param reversePath The reverese path. 563 * @return The reply code received from the server. 564 * @exception SMTPConnectionClosedException 565 * If the SMTP server prematurely closes the connection as a result 566 * of the client being idle or some other reason causing the server 567 * to send SMTP reply code 421. This exception may be caught either 568 * as an IOException or independently as itself. 569 * @exception IOException If an I/O error occurs while either sending the 570 * command or receiving the server reply. 571 ***/ 572 public int send(String reversePath) throws IOException 573 { 574 return sendCommand(SMTPCommand.SEND, reversePath); 575 } 576 577 578 /*** 579 * A convenience method to send the SMTP SOML command to the server, 580 * receive the reply, and return the reply code. 581 * <p> 582 * @param reversePath The reverese path. 583 * @return The reply code received from the server. 584 * @exception SMTPConnectionClosedException 585 * If the SMTP server prematurely closes the connection as a result 586 * of the client being idle or some other reason causing the server 587 * to send SMTP reply code 421. This exception may be caught either 588 * as an IOException or independently as itself. 589 * @exception IOException If an I/O error occurs while either sending the 590 * command or receiving the server reply. 591 ***/ 592 public int soml(String reversePath) throws IOException 593 { 594 return sendCommand(SMTPCommand.SOML, reversePath); 595 } 596 597 598 /*** 599 * A convenience method to send the SMTP SAML command to the server, 600 * receive the reply, and return the reply code. 601 * <p> 602 * @param reversePath The reverese path. 603 * @return The reply code received from the server. 604 * @exception SMTPConnectionClosedException 605 * If the SMTP server prematurely closes the connection as a result 606 * of the client being idle or some other reason causing the server 607 * to send SMTP reply code 421. This exception may be caught either 608 * as an IOException or independently as itself. 609 * @exception IOException If an I/O error occurs while either sending the 610 * command or receiving the server reply. 611 ***/ 612 public int saml(String reversePath) throws IOException 613 { 614 return sendCommand(SMTPCommand.SAML, reversePath); 615 } 616 617 618 /*** 619 * A convenience method to send the SMTP RSET command to the server, 620 * receive the reply, and return the reply code. 621 * <p> 622 * @return The reply code received from the server. 623 * @exception SMTPConnectionClosedException 624 * If the SMTP server prematurely closes the connection as a result 625 * of the client being idle or some other reason causing the server 626 * to send SMTP reply code 421. This exception may be caught either 627 * as an IOException or independently as itself. 628 * @exception IOException If an I/O error occurs while either sending the 629 * command or receiving the server reply. 630 ***/ 631 public int rset() throws IOException 632 { 633 return sendCommand(SMTPCommand.RSET); 634 } 635 636 637 /*** 638 * A convenience method to send the SMTP VRFY command to the server, 639 * receive the reply, and return the reply code. 640 * <p> 641 * @param user The user address to verify. 642 * @return The reply code received from the server. 643 * @exception SMTPConnectionClosedException 644 * If the SMTP server prematurely closes the connection as a result 645 * of the client being idle or some other reason causing the server 646 * to send SMTP reply code 421. This exception may be caught either 647 * as an IOException or independently as itself. 648 * @exception IOException If an I/O error occurs while either sending the 649 * command or receiving the server reply. 650 ***/ 651 public int vrfy(String user) throws IOException 652 { 653 return sendCommand(SMTPCommand.VRFY, user); 654 } 655 656 657 /*** 658 * A convenience method to send the SMTP VRFY command to the server, 659 * receive the reply, and return the reply code. 660 * <p> 661 * @param name The name to expand. 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 expn(String name) throws IOException 672 { 673 return sendCommand(SMTPCommand.EXPN, name); 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 * @return The reply code received from the server. 681 * @exception SMTPConnectionClosedException 682 * If the SMTP server prematurely closes the connection as a result 683 * of the client being idle or some other reason causing the server 684 * to send SMTP reply code 421. This exception may be caught either 685 * as an IOException or independently as itself. 686 * @exception IOException If an I/O error occurs while either sending the 687 * command or receiving the server reply. 688 ***/ 689 public int help() throws IOException 690 { 691 return sendCommand(SMTPCommand.HELP); 692 } 693 694 /*** 695 * A convenience method to send the SMTP HELP command to the server, 696 * receive the reply, and return the reply code. 697 * <p> 698 * @param command The command name on which to request help. 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 help(String command) throws IOException 709 { 710 return sendCommand(SMTPCommand.HELP, command); 711 } 712 713 /*** 714 * A convenience method to send the SMTP NOOP command to the server, 715 * receive the reply, and return the reply code. 716 * <p> 717 * @return The reply code received from the server. 718 * @exception SMTPConnectionClosedException 719 * If the SMTP server prematurely closes the connection as a result 720 * of the client being idle or some other reason causing the server 721 * to send SMTP reply code 421. This exception may be caught either 722 * as an IOException or independently as itself. 723 * @exception IOException If an I/O error occurs while either sending the 724 * command or receiving the server reply. 725 ***/ 726 public int noop() throws IOException 727 { 728 return sendCommand(SMTPCommand.NOOP); 729 } 730 731 732 /*** 733 * A convenience method to send the SMTP TURN command to the server, 734 * receive the reply, and return the reply code. 735 * <p> 736 * @return The reply code received from the server. 737 * @exception SMTPConnectionClosedException 738 * If the SMTP server prematurely closes the connection as a result 739 * of the client being idle or some other reason causing the server 740 * to send SMTP reply code 421. This exception may be caught either 741 * as an IOException or independently as itself. 742 * @exception IOException If an I/O error occurs while either sending the 743 * command or receiving the server reply. 744 ***/ 745 public int turn() throws IOException 746 { 747 return sendCommand(SMTPCommand.TURN); 748 } 749 750 751 /*** 752 * A convenience method to send the SMTP QUIT command to the server, 753 * receive the reply, and return the reply code. 754 * <p> 755 * @return The reply code received from the server. 756 * @exception SMTPConnectionClosedException 757 * If the SMTP server prematurely closes the connection as a result 758 * of the client being idle or some other reason causing the server 759 * to send SMTP reply code 421. This exception may be caught either 760 * as an IOException or independently as itself. 761 * @exception IOException If an I/O error occurs while either sending the 762 * command or receiving the server reply. 763 ***/ 764 public int quit() throws IOException 765 { 766 return sendCommand(SMTPCommand.QUIT); 767 } 768 769 } 770 771 /* Emacs configuration 772 * Local variables: ** 773 * mode: java ** 774 * c-basic-offset: 4 ** 775 * indent-tabs-mode: nil ** 776 * End: ** 777 */