%line	%branch
org.apache.commons.net.smtp.SMTP	0%	0%

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

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