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