From 063284837c8c366e5502b1b0264b8eb807b61732 Mon Sep 17 00:00:00 2001 From: Joe Robinson Date: Wed, 27 Oct 2010 14:21:09 +0100 Subject: Basic upload functionality to predifined location, with basic file browser --- org/apache/commons/net/smtp/RelayPath.java | 102 +++ org/apache/commons/net/smtp/SMTP.java | 777 +++++++++++++++++++++ org/apache/commons/net/smtp/SMTPClient.java | 607 ++++++++++++++++ org/apache/commons/net/smtp/SMTPCommand.java | 91 +++ .../net/smtp/SMTPConnectionClosedException.java | 56 ++ org/apache/commons/net/smtp/SMTPReply.java | 167 +++++ org/apache/commons/net/smtp/SimpleSMTPHeader.java | 153 ++++ 7 files changed, 1953 insertions(+) create mode 100644 org/apache/commons/net/smtp/RelayPath.java create mode 100644 org/apache/commons/net/smtp/SMTP.java create mode 100644 org/apache/commons/net/smtp/SMTPClient.java create mode 100644 org/apache/commons/net/smtp/SMTPCommand.java create mode 100644 org/apache/commons/net/smtp/SMTPConnectionClosedException.java create mode 100644 org/apache/commons/net/smtp/SMTPReply.java create mode 100644 org/apache/commons/net/smtp/SimpleSMTPHeader.java (limited to 'org/apache/commons/net/smtp') diff --git a/org/apache/commons/net/smtp/RelayPath.java b/org/apache/commons/net/smtp/RelayPath.java new file mode 100644 index 0000000..62d1098 --- /dev/null +++ b/org/apache/commons/net/smtp/RelayPath.java @@ -0,0 +1,102 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.net.smtp; + +import java.util.Enumeration; +import java.util.Vector; + +/*** + * A class used to represent forward and reverse relay paths. The + * SMTP MAIL command requires a reverse relay path while the SMTP RCPT + * command requires a forward relay path. See RFC 821 for more details. + * In general, you will not have to deal with relay paths. + *

+ *

+ * @author Daniel F. Savarese + * @see SMTPClient + ***/ + +public final class RelayPath +{ + Vector _path; + String _emailAddress; + + /*** + * Create a relay path with the specified email address as the ultimate + * destination. + *

+ * @param emailAddress The destination email address. + ***/ + public RelayPath(String emailAddress) + { + _path = new Vector(); + _emailAddress = emailAddress; + } + + /*** + * Add a mail relay host to the relay path. Hosts are added left to + * right. For example, the following will create the path + * < @bar.com,@foo.com:foobar@foo.com > + * 

+     * path = new RelayPath("foobar@foo.com");
+     * path.addRelay("bar.com");
+     * path.addRelay("foo.com");
+     *
+ *

+ * @param hostname The host to add to the relay path. + ***/ + public void addRelay(String hostname) + { + _path.addElement(hostname); + } + + /*** + * Return the properly formatted string representation of the relay path. + *

+ * @return The properly formatted string representation of the relay path. + ***/ + @Override + public String toString() + { + StringBuffer buffer = new StringBuffer(); + Enumeration hosts; + + buffer.append('<'); + + hosts = _path.elements(); + + if (hosts.hasMoreElements()) + { + buffer.append('@'); + buffer.append(hosts.nextElement()); + + while (hosts.hasMoreElements()) + { + buffer.append(",@"); + buffer.append(hosts.nextElement()); + } + buffer.append(':'); + } + + buffer.append(_emailAddress); + buffer.append('>'); + + return buffer.toString(); + } + +} diff --git a/org/apache/commons/net/smtp/SMTP.java b/org/apache/commons/net/smtp/SMTP.java new file mode 100644 index 0000000..0a628b1 --- /dev/null +++ b/org/apache/commons/net/smtp/SMTP.java @@ -0,0 +1,777 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.net.smtp; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.OutputStreamWriter; +import java.util.ArrayList; +import java.util.Arrays; + +import org.apache.commons.net.MalformedServerReplyException; +import org.apache.commons.net.ProtocolCommandListener; +import org.apache.commons.net.ProtocolCommandSupport; +import org.apache.commons.net.SocketClient; + +/*** + * SMTP provides the basic the functionality necessary to implement your + * own SMTP client. To derive the full benefits of the SMTP class requires + * some knowledge of the FTP protocol defined in RFC 821. However, there + * is no reason why you should have to use the SMTP class. The + * {@link org.apache.commons.net.smtp.SMTPClient} class, + * derived from SMTP, + * implements all the functionality required of an SMTP client. The + * SMTP class is made public to provide access to various SMTP constants + * and to make it easier for adventurous programmers (or those with + * special needs) to interact with the SMTP protocol and implement their + * own clients. A set of methods with names corresponding to the SMTP + * command names are provided to facilitate this interaction. + *

+ * You should keep in mind that the SMTP server may choose to prematurely + * close a connection for various reasons. The SMTP class will detect a + * premature SMTP server connection closing when it receives a + * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE SMTPReply.SERVICE_NOT_AVAILABLE } + * response to a command. + * When that occurs, the SMTP class method encountering that reply will throw + * an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} + * . + * SMTPConectionClosedException + * is a subclass of IOException and therefore need not be + * caught separately, but if you are going to catch it separately, its + * catch block must appear before the more general IOException + * catch block. When you encounter an + * {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} + * , you must disconnect the connection with + * {@link org.apache.commons.net.SocketClient#disconnect disconnect() } + * to properly clean up the system resources used by SMTP. Before + * disconnecting, you may check the + * last reply code and text with + * {@link #getReplyCode getReplyCode }, + * {@link #getReplyString getReplyString }, + * and {@link #getReplyStrings getReplyStrings}. + *

+ * Rather than list it separately for each method, we mention here that + * every method communicating with the server and throwing an IOException + * can also throw a + * {@link org.apache.commons.net.MalformedServerReplyException} + * , which is a subclass + * of IOException. A MalformedServerReplyException will be thrown when + * the reply received from the server deviates enough from the protocol + * specification that it cannot be interpreted in a useful manner despite + * attempts to be as lenient as possible. + *

+ *

+ * @author Daniel F. Savarese + * @see SMTPClient + * @see SMTPConnectionClosedException + * @see org.apache.commons.net.MalformedServerReplyException + ***/ + +public class SMTP extends SocketClient +{ + /*** The default SMTP port (25). ***/ + public static final int DEFAULT_PORT = 25; + + // We have to ensure that the protocol communication is in ASCII + // but we use ISO-8859-1 just in case 8-bit characters cross + // the wire. + private static final String __DEFAULT_ENCODING = "ISO-8859-1"; + + /** The encoding to use (user-settable) */ + private String encoding = __DEFAULT_ENCODING; + + private StringBuffer __commandBuffer; + + BufferedReader _reader; + BufferedWriter _writer; + int _replyCode; + ArrayList _replyLines; + boolean _newReplyString; + String _replyString; + + /*** + * A ProtocolCommandSupport object used to manage the registering of + * ProtocolCommandListeners and te firing of ProtocolCommandEvents. + ***/ + protected ProtocolCommandSupport _commandSupport_; + + /*** + * The default SMTP constructor. Sets the default port to + * DEFAULT_PORT and initializes internal data structures + * for saving SMTP reply information. + ***/ + public SMTP() + { + setDefaultPort(DEFAULT_PORT); + __commandBuffer = new StringBuffer(); + _replyLines = new ArrayList(); + _newReplyString = false; + _replyString = null; + _commandSupport_ = new ProtocolCommandSupport(this); + } + + /** + * Overloaded constructor where the user may specify a default encoding. + * @param encoding + * @since 2.0 + */ + public SMTP(String encoding) { + this(); + this.encoding = encoding; + } + + private int __sendCommand(String command, String args, boolean includeSpace) + throws IOException + { + String message; + + __commandBuffer.setLength(0); + __commandBuffer.append(command); + + if (args != null) + { + if (includeSpace) + __commandBuffer.append(' '); + __commandBuffer.append(args); + } + + __commandBuffer.append(SocketClient.NETASCII_EOL); + + _writer.write(message = __commandBuffer.toString()); + _writer.flush(); + + if (_commandSupport_.getListenerCount() > 0) + _commandSupport_.fireCommandSent(command, message); + + __getReply(); + return _replyCode; + } + + private int __sendCommand(int command, String args, boolean includeSpace) + throws IOException + { + return __sendCommand(SMTPCommand._commands[command], args, includeSpace); + } + + private void __getReply() throws IOException + { + int length; + + _newReplyString = true; + _replyLines.clear(); + + String line = _reader.readLine(); + + if (line == null) + throw new SMTPConnectionClosedException( + "Connection closed without indication."); + + // In case we run into an anomaly we don't want fatal index exceptions + // to be thrown. + length = line.length(); + if (length < 3) + throw new MalformedServerReplyException( + "Truncated server reply: " + line); + + try + { + String code = line.substring(0, 3); + _replyCode = Integer.parseInt(code); + } + catch (NumberFormatException e) + { + throw new MalformedServerReplyException( + "Could not parse response code.\nServer Reply: " + line); + } + + _replyLines.add(line); + + // Get extra lines if message continues. + if (length > 3 && line.charAt(3) == '-') + { + do + { + line = _reader.readLine(); + + if (line == null) + throw new SMTPConnectionClosedException( + "Connection closed without indication."); + + _replyLines.add(line); + + // The length() check handles problems that could arise from readLine() + // returning too soon after encountering a naked CR or some other + // anomaly. + } + while (!(line.length() >= 4 && line.charAt(3) != '-' && + Character.isDigit(line.charAt(0)))); + // This is too strong a condition because a non-conforming server + // could screw things up like ftp.funet.fi does for FTP + // line.startsWith(code))); + } + + if (_commandSupport_.getListenerCount() > 0) + _commandSupport_.fireReplyReceived(_replyCode, getReplyString()); + + if (_replyCode == SMTPReply.SERVICE_NOT_AVAILABLE) + throw new SMTPConnectionClosedException( + "SMTP response 421 received. Server closed connection."); + } + + /*** Initiates control connections and gets initial reply. ***/ + @Override + protected void _connectAction_() throws IOException + { + super._connectAction_(); + _reader = + new BufferedReader(new InputStreamReader(_input_, + encoding)); + _writer = + new BufferedWriter(new OutputStreamWriter(_output_, + encoding)); + __getReply(); + + } + + + /*** + * Adds a ProtocolCommandListener. Delegates this task to + * {@link #_commandSupport_ _commandSupport_ }. + *

+ * @param listener The ProtocolCommandListener to add. + ***/ + public void addProtocolCommandListener(ProtocolCommandListener listener) + { + _commandSupport_.addProtocolCommandListener(listener); + } + + /*** + * Removes a ProtocolCommandListener. Delegates this task to + * {@link #_commandSupport_ _commandSupport_ }. + *

+ * @param listener The ProtocolCommandListener to remove. + ***/ + public void removeProtocolCommandistener(ProtocolCommandListener listener) + { + _commandSupport_.removeProtocolCommandListener(listener); + } + + + /*** + * Closes the connection to the SMTP server and sets to null + * some internal data so that the memory may be reclaimed by the + * garbage collector. The reply text and code information from the + * last command is voided so that the memory it used may be reclaimed. + *

+ * @exception IOException If an error occurs while disconnecting. + ***/ + @Override + public void disconnect() throws IOException + { + super.disconnect(); + _reader = null; + _writer = null; + _replyString = null; + _replyLines.clear(); + _newReplyString = false; + } + + + /*** + * Sends an SMTP command to the server, waits for a reply and returns the + * numerical response code. After invocation, for more detailed + * information, the actual reply text can be accessed by calling + * {@link #getReplyString getReplyString } or + * {@link #getReplyStrings getReplyStrings }. + *

+ * @param command The text representation of the SMTP command to send. + * @param args The arguments to the SMTP command. If this parameter is + * set to null, then the command is sent with no argument. + * @return The integer value of the SMTP reply code returned by the server + * in response to the command. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int sendCommand(String command, String args) throws IOException + { + return __sendCommand(command, args, true); + } + + + /*** + * Sends an SMTP command to the server, waits for a reply and returns the + * numerical response code. After invocation, for more detailed + * information, the actual reply text can be accessed by calling + * {@link #getReplyString getReplyString } or + * {@link #getReplyStrings getReplyStrings }. + *

+ * @param command The SMTPCommand constant corresponding to the SMTP command + * to send. + * @param args The arguments to the SMTP command. If this parameter is + * set to null, then the command is sent with no argument. + * @return The integer value of the SMTP reply code returned by the server + * in response to the command. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int sendCommand(int command, String args) throws IOException + { + return sendCommand(SMTPCommand._commands[command], args); + } + + + /*** + * Sends an SMTP command with no arguments to the server, waits for a + * reply and returns the numerical response code. After invocation, for + * more detailed information, the actual reply text can be accessed by + * calling {@link #getReplyString getReplyString } or + * {@link #getReplyStrings getReplyStrings }. + *

+ * @param command The text representation of the SMTP command to send. + * @return The integer value of the SMTP reply code returned by the server + * in response to the command. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int sendCommand(String command) throws IOException + { + return sendCommand(command, null); + } + + + /*** + * Sends an SMTP command with no arguments to the server, waits for a + * reply and returns the numerical response code. After invocation, for + * more detailed information, the actual reply text can be accessed by + * calling {@link #getReplyString getReplyString } or + * {@link #getReplyStrings getReplyStrings }. + *

+ * @param command The SMTPCommand constant corresponding to the SMTP command + * to send. + * @return The integer value of the SMTP reply code returned by the server + * in response to the command. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int sendCommand(int command) throws IOException + { + return sendCommand(command, null); + } + + + /*** + * Returns the integer value of the reply code of the last SMTP reply. + * You will usually only use this method after you connect to the + * SMTP server to check that the connection was successful since + * connect is of type void. + *

+ * @return The integer value of the reply code of the last SMTP reply. + ***/ + public int getReplyCode() + { + return _replyCode; + } + + /*** + * Fetches a reply from the SMTP server and returns the integer reply + * code. After calling this method, the actual reply text can be accessed + * from either calling {@link #getReplyString getReplyString } or + * {@link #getReplyStrings getReplyStrings }. Only use this + * method if you are implementing your own SMTP client or if you need to + * fetch a secondary response from the SMTP server. + *

+ * @return The integer value of the reply code of the fetched SMTP reply. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while receiving the + * server reply. + ***/ + public int getReply() throws IOException + { + __getReply(); + return _replyCode; + } + + + /*** + * Returns the lines of text from the last SMTP server response as an array + * of strings, one entry per line. The end of line markers of each are + * stripped from each line. + *

+ * @return The lines of text from the last SMTP response as an array. + ***/ + public String[] getReplyStrings() + { + String[] lines; + lines = new String[_replyLines.size()]; + _replyLines.addAll(Arrays.asList(lines)); + return lines; + } + + /*** + * Returns the entire text of the last SMTP server response exactly + * as it was received, including all end of line markers in NETASCII + * format. + *

+ * @return The entire text from the last SMTP response as a String. + ***/ + public String getReplyString() + { + StringBuilder buffer; + + if (!_newReplyString) + return _replyString; + + buffer = new StringBuilder(); + + for (String line : _replyLines) + { + buffer.append(line); + buffer.append(SocketClient.NETASCII_EOL); + } + + _newReplyString = false; + + return (_replyString = buffer.toString()); + } + + + /*** + * A convenience method to send the SMTP HELO command to the server, + * receive the reply, and return the reply code. + *

+ * @param hostname The hostname of the sender. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int helo(String hostname) throws IOException + { + return sendCommand(SMTPCommand.HELO, hostname); + } + + + /*** + * A convenience method to send the SMTP MAIL command to the server, + * receive the reply, and return the reply code. + *

+ * @param reversePath The reverese path. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int mail(String reversePath) throws IOException + { + return __sendCommand(SMTPCommand.MAIL, reversePath, false); + } + + + /*** + * A convenience method to send the SMTP RCPT command to the server, + * receive the reply, and return the reply code. + *

+ * @param forwardPath The forward path. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int rcpt(String forwardPath) throws IOException + { + return __sendCommand(SMTPCommand.RCPT, forwardPath, false); + } + + + /*** + * A convenience method to send the SMTP DATA command to the server, + * receive the reply, and return the reply code. + *

+ * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int data() throws IOException + { + return sendCommand(SMTPCommand.DATA); + } + + + /*** + * A convenience method to send the SMTP SEND command to the server, + * receive the reply, and return the reply code. + *

+ * @param reversePath The reverese path. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int send(String reversePath) throws IOException + { + return sendCommand(SMTPCommand.SEND, reversePath); + } + + + /*** + * A convenience method to send the SMTP SOML command to the server, + * receive the reply, and return the reply code. + *

+ * @param reversePath The reverese path. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int soml(String reversePath) throws IOException + { + return sendCommand(SMTPCommand.SOML, reversePath); + } + + + /*** + * A convenience method to send the SMTP SAML command to the server, + * receive the reply, and return the reply code. + *

+ * @param reversePath The reverese path. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int saml(String reversePath) throws IOException + { + return sendCommand(SMTPCommand.SAML, reversePath); + } + + + /*** + * A convenience method to send the SMTP RSET command to the server, + * receive the reply, and return the reply code. + *

+ * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int rset() throws IOException + { + return sendCommand(SMTPCommand.RSET); + } + + + /*** + * A convenience method to send the SMTP VRFY command to the server, + * receive the reply, and return the reply code. + *

+ * @param user The user address to verify. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int vrfy(String user) throws IOException + { + return sendCommand(SMTPCommand.VRFY, user); + } + + + /*** + * A convenience method to send the SMTP VRFY command to the server, + * receive the reply, and return the reply code. + *

+ * @param name The name to expand. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int expn(String name) throws IOException + { + return sendCommand(SMTPCommand.EXPN, name); + } + + /*** + * A convenience method to send the SMTP HELP command to the server, + * receive the reply, and return the reply code. + *

+ * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int help() throws IOException + { + return sendCommand(SMTPCommand.HELP); + } + + /*** + * A convenience method to send the SMTP HELP command to the server, + * receive the reply, and return the reply code. + *

+ * @param command The command name on which to request help. + * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int help(String command) throws IOException + { + return sendCommand(SMTPCommand.HELP, command); + } + + /*** + * A convenience method to send the SMTP NOOP command to the server, + * receive the reply, and return the reply code. + *

+ * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int noop() throws IOException + { + return sendCommand(SMTPCommand.NOOP); + } + + + /*** + * A convenience method to send the SMTP TURN command to the server, + * receive the reply, and return the reply code. + *

+ * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int turn() throws IOException + { + return sendCommand(SMTPCommand.TURN); + } + + + /*** + * A convenience method to send the SMTP QUIT command to the server, + * receive the reply, and return the reply code. + *

+ * @return The reply code received from the server. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending the + * command or receiving the server reply. + ***/ + public int quit() throws IOException + { + return sendCommand(SMTPCommand.QUIT); + } + +} + +/* Emacs configuration + * Local variables: ** + * mode: java ** + * c-basic-offset: 4 ** + * indent-tabs-mode: nil ** + * End: ** + */ diff --git a/org/apache/commons/net/smtp/SMTPClient.java b/org/apache/commons/net/smtp/SMTPClient.java new file mode 100644 index 0000000..8b9ed45 --- /dev/null +++ b/org/apache/commons/net/smtp/SMTPClient.java @@ -0,0 +1,607 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.net.smtp; + +import java.io.IOException; +import java.io.Writer; +import java.net.InetAddress; + +import org.apache.commons.net.io.DotTerminatedMessageWriter; + +/*** + * SMTPClient encapsulates all the functionality necessary to send files + * through an SMTP server. This class takes care of all + * low level details of interacting with an SMTP server and provides + * a convenient higher level interface. As with all classes derived + * from {@link org.apache.commons.net.SocketClient}, + * you must first connect to the server with + * {@link org.apache.commons.net.SocketClient#connect connect } + * before doing anything, and finally + * {@link org.apache.commons.net.SocketClient#disconnect disconnect } + * after you're completely finished interacting with the server. + * Then you need to check the SMTP reply code to see if the connection + * was successful. For example: + * 

+ *    try {
+ *      int reply;
+ *      client.connect("mail.foobar.com");
+ *      System.out.print(client.getReplyString());
+ *
+ *      // After connection attempt, you should check the reply code to verify
+ *      // success.
+ *      reply = client.getReplyCode();
+ *
+ *      if(!SMTPReply.isPositiveCompletion(reply)) {
+ *        client.disconnect();
+ *        System.err.println("SMTP server refused connection.");
+ *        System.exit(1);
+ *      }
+ *
+ *      // Do useful stuff here.
+ *      ...
+ *    } catch(IOException e) {
+ *      if(client.isConnected()) {
+ *        try {
+ *          client.disconnect();
+ *        } catch(IOException f) {
+ *          // do nothing
+ *        }
+ *      }
+ *      System.err.println("Could not connect to server.");
+ *      e.printStackTrace();
+ *      System.exit(1);
+ *    }
+ *
+ *

+ * Immediately after connecting is the only real time you need to check the + * reply code (because connect is of type void). The convention for all the + * SMTP command methods in SMTPClient is such that they either return a + * boolean value or some other value. + * The boolean methods return true on a successful completion reply from + * the SMTP server and false on a reply resulting in an error condition or + * failure. The methods returning a value other than boolean return a value + * containing the higher level data produced by the SMTP command, or null if a + * reply resulted in an error condition or failure. If you want to access + * the exact SMTP reply code causing a success or failure, you must call + * {@link org.apache.commons.net.smtp.SMTP#getReplyCode getReplyCode } after + * a success or failure. + *

+ * You should keep in mind that the SMTP server may choose to prematurely + * close a connection for various reasons. The SMTPClient class will detect a + * premature SMTP server connection closing when it receives a + * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE SMTPReply.SERVICE_NOT_AVAILABLE } + * response to a command. + * When that occurs, the method encountering that reply will throw + * an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} + * . + * SMTPConectionClosedException + * is a subclass of IOException and therefore need not be + * caught separately, but if you are going to catch it separately, its + * catch block must appear before the more general IOException + * catch block. When you encounter an + * {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} + * , you must disconnect the connection with + * {@link #disconnect disconnect() } to properly clean up the + * system resources used by SMTPClient. Before disconnecting, you may check + * the last reply code and text with + * {@link org.apache.commons.net.smtp.SMTP#getReplyCode getReplyCode }, + * {@link org.apache.commons.net.smtp.SMTP#getReplyString getReplyString }, + * and + * {@link org.apache.commons.net.smtp.SMTP#getReplyStrings getReplyStrings}. + *

+ * Rather than list it separately for each method, we mention here that + * every method communicating with the server and throwing an IOException + * can also throw a + * {@link org.apache.commons.net.MalformedServerReplyException} + * , which is a subclass + * of IOException. A MalformedServerReplyException will be thrown when + * the reply received from the server deviates enough from the protocol + * specification that it cannot be interpreted in a useful manner despite + * attempts to be as lenient as possible. + *

+ *

+ * @author Daniel F. Savarese + * @see SMTP + * @see SimpleSMTPHeader + * @see RelayPath + * @see SMTPConnectionClosedException + * @see org.apache.commons.net.MalformedServerReplyException + ***/ + +public class SMTPClient extends SMTP +{ + + /** + * Default SMTPClient constructor. Creates a new SMTPClient instance. + */ + public SMTPClient() { } + + /** + * Overloaded constructor that takes an encoding specification + * @param encoding The encoding to use + * @since 2.0 + */ + public SMTPClient(String encoding) { + super(encoding); + } + + + /*** + * At least one SMTPClient method ({@link #sendMessageData sendMessageData }) + * does not complete the entire sequence of SMTP commands to complete a + * transaction. These types of commands require some action by the + * programmer after the reception of a positive intermediate command. + * After the programmer's code completes its actions, it must call this + * method to receive the completion reply from the server and verify the + * success of the entire transaction. + *

+ * For example, + * 

+     * writer = client.sendMessage();
+     * if(writer == null) // failure
+     *   return false;
+     * header =
+     *  new SimpleSMTPHeader("foobar@foo.com", "foo@foobar.com", "Re: Foo");
+     * writer.write(header.toString());
+     * writer.write("This is just a test");
+     * writer.close();
+     * if(!client.completePendingCommand()) // failure
+     *   return false;
+     *
+ *

+ * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean completePendingCommand() throws IOException + { + return SMTPReply.isPositiveCompletion(getReply()); + } + + + /*** + * Login to the SMTP server by sending the HELO command with the + * given hostname as an argument. Before performing any mail commands, + * you must first login. + *

+ * @param hostname The hostname with which to greet the SMTP server. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean login(String hostname) throws IOException + { + return SMTPReply.isPositiveCompletion(helo(hostname)); + } + + + /*** + * Login to the SMTP server by sending the HELO command with the + * client hostname as an argument. Before performing any mail commands, + * you must first login. + *

+ * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean login() throws IOException + { + String name; + InetAddress host; + + host = getLocalAddress(); + name = host.getHostName(); + + if (name == null) + return false; + + return SMTPReply.isPositiveCompletion(helo(name)); + } + + + /*** + * Set the sender of a message using the SMTP MAIL command, specifying + * a reverse relay path. The sender must be set first before any + * recipients may be specified, otherwise the mail server will reject + * your commands. + *

+ * @param path The reverse relay path pointing back to the sender. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean setSender(RelayPath path) throws IOException + { + return SMTPReply.isPositiveCompletion(mail(path.toString())); + } + + + /*** + * Set the sender of a message using the SMTP MAIL command, specifying + * the sender's email address. The sender must be set first before any + * recipients may be specified, otherwise the mail server will reject + * your commands. + *

+ * @param address The sender's email address. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean setSender(String address) throws IOException + { + return SMTPReply.isPositiveCompletion(mail("<" + address + ">")); + } + + + /*** + * Add a recipient for a message using the SMTP RCPT command, specifying + * a forward relay path. The sender must be set first before any + * recipients may be specified, otherwise the mail server will reject + * your commands. + *

+ * @param path The forward relay path pointing to the recipient. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean addRecipient(RelayPath path) throws IOException + { + return SMTPReply.isPositiveCompletion(rcpt(path.toString())); + } + + + /*** + * Add a recipient for a message using the SMTP RCPT command, the + * recipient's email address. The sender must be set first before any + * recipients may be specified, otherwise the mail server will reject + * your commands. + *

+ * @param address The recipient's email address. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean addRecipient(String address) throws IOException + { + return SMTPReply.isPositiveCompletion(rcpt("<" + address + ">")); + } + + + + /*** + * Send the SMTP DATA command in preparation to send an email message. + * This method returns a DotTerminatedMessageWriter instance to which + * the message can be written. Null is returned if the DATA command + * fails. + *

+ * You must not issue any commands to the SMTP server (i.e., call any + * (other methods) until you finish writing to the returned Writer + * instance and close it. The SMTP protocol uses the same stream for + * issuing commands as it does for returning results. Therefore the + * returned Writer actually writes directly to the SMTP connection. + * After you close the writer, you can execute new commands. If you + * do not follow these requirements your program will not work properly. + *

+ * You can use the provided + * {@link org.apache.commons.net.smtp.SimpleSMTPHeader} + * class to construct a bare minimum header. + * To construct more complicated headers you should + * refer to RFC 822. When the Java Mail API is finalized, you will be + * able to use it to compose fully compliant Internet text messages. + * The DotTerminatedMessageWriter takes care of doubling line-leading + * dots and ending the message with a single dot upon closing, so all + * you have to worry about is writing the header and the message. + *

+ * Upon closing the returned Writer, you need to call + * {@link #completePendingCommand completePendingCommand() } + * to finalize the transaction and verify its success or failure from + * the server reply. + *

+ * @return A DotTerminatedMessageWriter to which the message (including + * header) can be written. Returns null if the command fails. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public Writer sendMessageData() throws IOException + { + if (!SMTPReply.isPositiveIntermediate(data())) + return null; + + return new DotTerminatedMessageWriter(_writer); + } + + + /*** + * A convenience method for sending short messages. This method fetches + * the Writer returned by {@link #sendMessageData sendMessageData() } + * and writes the specified String to it. After writing the message, + * this method calls {@link #completePendingCommand completePendingCommand() } + * to finalize the transaction and returns + * its success or failure. + *

+ * @param message The short email message to send. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean sendShortMessageData(String message) throws IOException + { + Writer writer; + + writer = sendMessageData(); + + if (writer == null) + return false; + + writer.write(message); + writer.close(); + + return completePendingCommand(); + } + + + /*** + * A convenience method for a sending short email without having to + * explicitly set the sender and recipient(s). This method + * sets the sender and recipient using + * {@link #setSender setSender } and + * {@link #addRecipient addRecipient }, and then sends the + * message using {@link #sendShortMessageData sendShortMessageData }. + *

+ * @param sender The email address of the sender. + * @param recipient The email address of the recipient. + * @param message The short email message to send. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean sendSimpleMessage(String sender, String recipient, + String message) + throws IOException + { + if (!setSender(sender)) + return false; + + if (!addRecipient(recipient)) + return false; + + return sendShortMessageData(message); + } + + + + /*** + * A convenience method for a sending short email without having to + * explicitly set the sender and recipient(s). This method + * sets the sender and recipients using + * {@link #setSender setSender } and + * {@link #addRecipient addRecipient }, and then sends the + * message using {@link #sendShortMessageData sendShortMessageData }. + *

+ * @param sender The email address of the sender. + * @param recipients An array of recipient email addresses. + * @param message The short email message to send. + * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean sendSimpleMessage(String sender, String[] recipients, + String message) + throws IOException + { + boolean oneSuccess = false; + int count; + + if (!setSender(sender)) + return false; + + for (count = 0; count < recipients.length; count++) + { + if (addRecipient(recipients[count])) + oneSuccess = true; + } + + if (!oneSuccess) + return false; + + return sendShortMessageData(message); + } + + + /*** + * Logout of the SMTP server by sending the QUIT command. + *

+ * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean logout() throws IOException + { + return SMTPReply.isPositiveCompletion(quit()); + } + + + + /*** + * Aborts the current mail transaction, resetting all server stored + * sender, recipient, and mail data, cleaing all buffers and tables. + *

+ * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean reset() throws IOException + { + return SMTPReply.isPositiveCompletion(rset()); + } + + + /*** + * Verify that a username or email address is valid, i.e., that mail + * can be delivered to that mailbox on the server. + *

+ * @param username The username or email address to validate. + * @return True if the username is valid, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean verify(String username) throws IOException + { + int result; + + result = vrfy(username); + + return (result == SMTPReply.ACTION_OK || + result == SMTPReply.USER_NOT_LOCAL_WILL_FORWARD); + } + + + /*** + * Fetches the system help information from the server and returns the + * full string. + *

+ * @return The system help string obtained from the server. null if the + * information could not be obtained. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public String listHelp() throws IOException + { + if (SMTPReply.isPositiveCompletion(help())) + return getReplyString(); + return null; + } + + + /*** + * Fetches the help information for a given command from the server and + * returns the full string. + *

+ * @param command The command on which to ask for help. + * @return The command help string obtained from the server. null if the + * information could not be obtained. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public String listHelp(String command) throws IOException + { + if (SMTPReply.isPositiveCompletion(help(command))) + return getReplyString(); + return null; + } + + + /*** + * Sends a NOOP command to the SMTP server. This is useful for preventing + * server timeouts. + *

+ * @return True if successfully completed, false if not. + * @exception SMTPConnectionClosedException + * If the SMTP server prematurely closes the connection as a result + * of the client being idle or some other reason causing the server + * to send SMTP reply code 421. This exception may be caught either + * as an IOException or independently as itself. + * @exception IOException If an I/O error occurs while either sending a + * command to the server or receiving a reply from the server. + ***/ + public boolean sendNoOp() throws IOException + { + return SMTPReply.isPositiveCompletion(noop()); + } + +} diff --git a/org/apache/commons/net/smtp/SMTPCommand.java b/org/apache/commons/net/smtp/SMTPCommand.java new file mode 100644 index 0000000..04dbf99 --- /dev/null +++ b/org/apache/commons/net/smtp/SMTPCommand.java @@ -0,0 +1,91 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.net.smtp; + +/*** + * SMTPCommand stores a set of constants for SMTP command codes. To interpret + * the meaning of the codes, familiarity with RFC 821 is assumed. + * The mnemonic constant names are transcriptions from the code descriptions + * of RFC 821. For those who think in terms of the actual SMTP commands, + * a set of constants such as {@link #HELO HELO } are provided + * where the constant name is the same as the SMTP command. + *

+ *

+ * @author Daniel F. Savarese + ***/ + +public final class SMTPCommand +{ + + + public static final int HELO = 0; + public static final int MAIL = 1; + public static final int RCPT = 2; + public static final int DATA = 3; + public static final int SEND = 4; + public static final int SOML = 5; + public static final int SAML = 6; + public static final int RSET = 7; + public static final int VRFY = 8; + public static final int EXPN = 9; + public static final int HELP = 10; + public static final int NOOP = 11; + public static final int TURN = 12; + public static final int QUIT = 13; + + public static final int HELLO = HELO; + public static final int LOGIN = HELO; + public static final int MAIL_FROM = MAIL; + public static final int RECIPIENT = RCPT; + public static final int SEND_MESSAGE_DATA = DATA; + public static final int SEND_FROM = SEND; + public static final int SEND_OR_MAIL_FROM = SOML; + public static final int SEND_AND_MAIL_FROM = SAML; + public static final int RESET = RSET; + public static final int VERIFY = VRFY; + public static final int EXPAND = EXPN; + // public static final int HELP = HELP; + // public static final int NOOP = NOOP; + // public static final int TURN = TURN; + // public static final int QUIT = QUIT; + public static final int LOGOUT = QUIT; + + // Cannot be instantiated + private SMTPCommand() + {} + + static final String[] _commands = { + "HELO", "MAIL FROM:", "RCPT TO:", "DATA", "SEND FROM:", "SOML FROM:", + "SAML FROM:", "RSET", "VRFY", "EXPN", "HELP", "NOOP", "TURN", "QUIT" + }; + + + /*** + * Retrieve the SMTP protocol command string corresponding to a specified + * command code. + *

+ * @param command The command code. + * @return The SMTP protcol command string corresponding to a specified + * command code. + ***/ + public static final String getCommand(int command) + { + return _commands[command]; + } + +} diff --git a/org/apache/commons/net/smtp/SMTPConnectionClosedException.java b/org/apache/commons/net/smtp/SMTPConnectionClosedException.java new file mode 100644 index 0000000..f9a5762 --- /dev/null +++ b/org/apache/commons/net/smtp/SMTPConnectionClosedException.java @@ -0,0 +1,56 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.net.smtp; + +import java.io.IOException; + +/*** + * SMTPConnectionClosedException is used to indicate the premature or + * unexpected closing of an SMTP connection resulting from a + * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE SMTPReply.SERVICE_NOT_AVAILABLE } + * response (SMTP reply code 421) to a + * failed SMTP command. This exception is derived from IOException and + * therefore may be caught either as an IOException or specifically as an + * SMTPConnectionClosedException. + *

+ *

+ * @author Daniel F. Savarese + * @see SMTP + * @see SMTPClient + ***/ + +public final class SMTPConnectionClosedException extends IOException +{ + + /*** Constructs a SMTPConnectionClosedException with no message ***/ + public SMTPConnectionClosedException() + { + super(); + } + + /*** + * Constructs a SMTPConnectionClosedException with a specified message. + *

+ * @param message The message explaining the reason for the exception. + ***/ + public SMTPConnectionClosedException(String message) + { + super(message); + } + +} diff --git a/org/apache/commons/net/smtp/SMTPReply.java b/org/apache/commons/net/smtp/SMTPReply.java new file mode 100644 index 0000000..45fd7c8 --- /dev/null +++ b/org/apache/commons/net/smtp/SMTPReply.java @@ -0,0 +1,167 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.net.smtp; + +/*** + * SMTPReply stores a set of constants for SMTP reply codes. To interpret + * the meaning of the codes, familiarity with RFC 821 is assumed. + * The mnemonic constant names are transcriptions from the code descriptions + * of RFC 821. For those who think in terms of the actual reply code values, + * a set of CODE_NUM constants are provided where NUM is the numerical value + * of the code. + *

+ *

+ * @author Daniel F. Savarese + ***/ + +public final class SMTPReply +{ + + public static final int CODE_211 = 211; + public static final int CODE_214 = 214; + public static final int CODE_215 = 215; + public static final int CODE_220 = 220; + public static final int CODE_221 = 221; + public static final int CODE_250 = 250; + public static final int CODE_251 = 251; + public static final int CODE_354 = 354; + public static final int CODE_421 = 421; + public static final int CODE_450 = 450; + public static final int CODE_451 = 451; + public static final int CODE_452 = 452; + public static final int CODE_500 = 500; + public static final int CODE_501 = 501; + public static final int CODE_502 = 502; + public static final int CODE_503 = 503; + public static final int CODE_504 = 504; + public static final int CODE_550 = 550; + public static final int CODE_551 = 551; + public static final int CODE_552 = 552; + public static final int CODE_553 = 553; + public static final int CODE_554 = 554; + + public static final int SYSTEM_STATUS = CODE_211; + public static final int HELP_MESSAGE = CODE_214; + public static final int SERVICE_READY = CODE_220; + public static final int SERVICE_CLOSING_TRANSMISSION_CHANNEL = CODE_221; + public static final int ACTION_OK = CODE_250; + public static final int USER_NOT_LOCAL_WILL_FORWARD = CODE_251; + public static final int START_MAIL_INPUT = CODE_354; + public static final int SERVICE_NOT_AVAILABLE = CODE_421; + public static final int ACTION_NOT_TAKEN = CODE_450; + public static final int ACTION_ABORTED = CODE_451; + public static final int INSUFFICIENT_STORAGE = CODE_452; + public static final int UNRECOGNIZED_COMMAND = CODE_500; + public static final int SYNTAX_ERROR_IN_ARGUMENTS = CODE_501; + public static final int COMMAND_NOT_IMPLEMENTED = CODE_502; + public static final int BAD_COMMAND_SEQUENCE = CODE_503; + public static final int COMMAND_NOT_IMPLEMENTED_FOR_PARAMETER = CODE_504; + public static final int MAILBOX_UNAVAILABLE = CODE_550; + public static final int USER_NOT_LOCAL = CODE_551; + public static final int STORAGE_ALLOCATION_EXCEEDED = CODE_552; + public static final int MAILBOX_NAME_NOT_ALLOWED = CODE_553; + public static final int TRANSACTION_FAILED = CODE_554; + + // Cannot be instantiated + private SMTPReply() + {} + + /*** + * Determine if a reply code is a positive preliminary response. All + * codes beginning with a 1 are positive preliminary responses. + * Postitive preliminary responses are used to indicate tentative success. + * No further commands can be issued to the SMTP server after a positive + * preliminary response until a follow up response is received from the + * server. + *

+ * Note: No SMTP commands defined in RFC 822 provide this + * type of reply. + *

+ * @param reply The reply code to test. + * @return True if a reply code is a postive preliminary response, false + * if not. + ***/ + public static boolean isPositivePreliminary(int reply) + { + return (reply >= 100 && reply < 200); + } + + /*** + * Determine if a reply code is a positive completion response. All + * codes beginning with a 2 are positive completion responses. + * The SMTP server will send a positive completion response on the final + * successful completion of a command. + *

+ * @param reply The reply code to test. + * @return True if a reply code is a postive completion response, false + * if not. + ***/ + public static boolean isPositiveCompletion(int reply) + { + return (reply >= 200 && reply < 300); + } + + /*** + * Determine if a reply code is a positive intermediate response. All + * codes beginning with a 3 are positive intermediate responses. + * The SMTP server will send a positive intermediate response on the + * successful completion of one part of a multi-part sequence of + * commands. For example, after a successful DATA command, a positive + * intermediate response will be sent to indicate that the server is + * ready to receive the message data. + *

+ * @param reply The reply code to test. + * @return True if a reply code is a postive intermediate response, false + * if not. + ***/ + public static boolean isPositiveIntermediate(int reply) + { + return (reply >= 300 && reply < 400); + } + + /*** + * Determine if a reply code is a negative transient response. All + * codes beginning with a 4 are negative transient responses. + * The SMTP server will send a negative transient response on the + * failure of a command that can be reattempted with success. + *

+ * @param reply The reply code to test. + * @return True if a reply code is a negative transient response, false + * if not. + ***/ + public static boolean isNegativeTransient(int reply) + { + return (reply >= 400 && reply < 500); + } + + /*** + * Determine if a reply code is a negative permanent response. All + * codes beginning with a 5 are negative permanent responses. + * The SMTP server will send a negative permanent response on the + * failure of a command that cannot be reattempted with success. + *

+ * @param reply The reply code to test. + * @return True if a reply code is a negative permanent response, false + * if not. + ***/ + public static boolean isNegativePermanent(int reply) + { + return (reply >= 500 && reply < 600); + } + +} diff --git a/org/apache/commons/net/smtp/SimpleSMTPHeader.java b/org/apache/commons/net/smtp/SimpleSMTPHeader.java new file mode 100644 index 0000000..ed0ea4d --- /dev/null +++ b/org/apache/commons/net/smtp/SimpleSMTPHeader.java @@ -0,0 +1,153 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.net.smtp; + +/*** + * This class is used to construct a bare minimum + * acceptable header for an email message. To construct more + * complicated headers you should refer to RFC 822. When the + * Java Mail API is finalized, you will be + * able to use it to compose fully compliant Internet text messages. + *

+ * The main purpose of the class is to faciliatate the mail sending + * process, by relieving the programmer from having to explicitly format + * a simple message header. For example: + * 

+ * writer = client.sendMessageData();
+ * if(writer == null) // failure
+ *   return false;
+ * header =
+ *    new SimpleSMTPHeader("foobar@foo.com", "foo@bar.com" "Just testing");
+ * header.addCC("bar@foo.com");
+ * header.addHeaderField("Organization", "Foobar, Inc.");
+ * writer.write(header.toString());
+ * writer.write("This is just a test");
+ * writer.close();
+ * if(!client.completePendingCommand()) // failure
+ *   return false;
+ *
+ *

+ *

+ * @author Daniel F. Savarese + * @see SMTPClient + ***/ + +public class SimpleSMTPHeader +{ + private String __subject, __from, __to; + private StringBuffer __headerFields, __cc; + + /*** + * Creates a new SimpleSMTPHeader instance initialized with the given + * from, to, and subject header field values. + *

+ * @param from The value of the From: header field. This + * should be the sender's email address. + * @param to The value of the To: header field. This + * should be the recipient's email address. + * @param subject The value of the Subject: header field. + * This should be the subject of the message. + ***/ + public SimpleSMTPHeader(String from, String to, String subject) + { + __to = to; + __from = from; + __subject = subject; + __headerFields = new StringBuffer(); + __cc = null; + } + + /*** + * Adds an arbitrary header field with the given value to the article + * header. These headers will be written before the From, To, Subject, and + * Cc fields when the SimpleSMTPHeader is convertered to a string. + * An example use would be: + * 

+     * header.addHeaderField("Organization", "Foobar, Inc.");
+     *
+ *

+ * @param headerField The header field to add, not including the colon. + * @param value The value of the added header field. + ***/ + public void addHeaderField(String headerField, String value) + { + __headerFields.append(headerField); + __headerFields.append(": "); + __headerFields.append(value); + __headerFields.append('\n'); + } + + + /*** + * Add an email address to the CC (carbon copy or courtesy copy) list. + *

+ * @param address The email address to add to the CC list. + ***/ + public void addCC(String address) + { + if (__cc == null) + __cc = new StringBuffer(); + else + __cc.append(", "); + + __cc.append(address); + } + + + /*** + * Converts the SimpleSMTPHeader to a properly formatted header in + * the form of a String, including the blank line used to separate + * the header from the article body. The header fields CC and Subject + * are only included when they are non-null. + *

+ * @return The message header in the form of a String. + ***/ + @Override + public String toString() + { + StringBuffer header = new StringBuffer(); + + if (__headerFields.length() > 0) + header.append(__headerFields.toString()); + + header.append("From: "); + header.append(__from); + header.append("\nTo: "); + header.append(__to); + + if (__cc != null) + { + header.append("\nCc: "); + header.append(__cc.toString()); + } + + if (__subject != null) + { + header.append("\nSubject: "); + header.append(__subject); + } + + header.append('\n'); + header.append('\n'); + + return header.toString(); + } +} + + + -- cgit v1.2.3