%line | %branch | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
org.apache.commons.net.smtp.SMTP |
|
|
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. |