http://commons.apache.org/proper/commons-net/: Apache Commons Net library contains a collection of network utilities and protocol implementations. Supported protocols include: Echo, Finger, FTP, NNTP, NTP, POP3(S), SMTP(S), Telnet, Whois (The Apache Software Foundation)
  • Henrik Sorensen
  • Jeff Nadler
  • William Noto
  • Stephane ESTE-GRACIAS
  • Dan Armbrust
  • Yuval Kashtan
  • Joseph Hindsley
  • Rob Hasselbaum
  • Mario Ivankovits
  • Naz Irizarry (MITRE Corp)
  • Tapan Karecha
  • Jason Mathews (MITRE Corp)
  • Winston Ojeda (Quad/Graphics, Inc.)
  • Ted Wise
  • Bogdan Drozdowski
  • Jeffrey D. Brekke (Quad/Graphics, Inc.)
  • Steve Cohen (javactivity.org)
  • Bruno D'Avanzo (Hewlett-Packard)
  • Daniel F. Savarese (<a href="http://www.savarese.com/">Savarese Software Research</a>)
  • Rory Winston ()
  • Rory Winston () 
/*
 * 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 org.apache.commons.net.MalformedServerReplyException;
import org.apache.commons.net.ProtocolCommandSupport;
import org.apache.commons.net.SocketClient;
import org.apache.commons.net.io.CRLFLineReader;


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 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 SMTPReply.SERVICE_NOT_AVAILABLE response to a command. When that occurs, the SMTP class method encountering that reply will throw an 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 SMTPConnectionClosedException , you must disconnect the connection with  disconnect() to properly clean up the system resources used by SMTP. Before disconnecting, you may check the last reply code and text with  getReplyCode,  getReplyString, and  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 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. 
See Also:
/***
 * 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.
 * <p>
 * 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}
 * .
 * <code>SMTPConectionClosedException</code>
 * is a subclass of <code> IOException </code> 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 <code> IOException </code>
 * 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}.
 * <p>
 * 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.
 *
 * @see SMTPClient
 * @see SMTPConnectionClosedException
 * @see org.apache.commons.net.MalformedServerReplyException
 ***/

public class SMTP extends SocketClient
{
    
The default SMTP port (25). 
/*** 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).

Since:3.1 (changed from private to protected)
/**
     * The encoding to use (user-settable).
     *
     * @since 3.1 (changed from private to protected)
     */
    protected final String encoding;

    
A ProtocolCommandSupport object used to manage the registering of
ProtocolCommandListeners and te firing of ProtocolCommandEvents.

/**
     * A ProtocolCommandSupport object used to manage the registering of
     * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
     */
    protected ProtocolCommandSupport _commandSupport_;

    BufferedReader _reader;
    BufferedWriter _writer;

    private int _replyCode;
    private final ArrayList<String> _replyLines;
    private boolean _newReplyString;
    private String _replyString;

    
The default SMTP constructor.  Sets the default port to
DEFAULT_PORT and initializes internal data structures
for saving SMTP reply information.

/***
     * The default SMTP constructor.  Sets the default port to
     * <code>DEFAULT_PORT</code> and initializes internal data structures
     * for saving SMTP reply information.
     ***/
    public SMTP()
    {
        this(__DEFAULT_ENCODING);
    }

    
Overloaded constructor where the user may specify a default encoding.

Params:
  • encoding – the encoing to use
Since:2.0
/**
     * Overloaded constructor where the user may specify a default encoding.
     * @param encoding the encoing to use
     * @since 2.0
     */
    public SMTP(String encoding) {
        setDefaultPort(DEFAULT_PORT);
        _replyLines = new ArrayList<String>();
        _newReplyString = false;
        _replyString = null;
        _commandSupport_ = new ProtocolCommandSupport(this);
        this.encoding = encoding;
    }

    
Send a command to the server. May also be used to send text data.

Params:
  • command – the command to send (as a plain String)
  • args – the command arguments, may be null
  • includeSpace – if true, add a space between the command and its arguments
Throws:
Returns:the reply code
/**
     * Send a command to the server. May also be used to send text data.
     *
     * @param command the command to send (as a plain String)
     * @param args the command arguments, may be {@code null}
     * @param includeSpace if {@code true}, add a space between the command and its arguments
     * @return the reply code
     * @throws IOException
     */
    private int __sendCommand(String command, String args, boolean includeSpace)
    throws IOException
    {
        StringBuilder __commandBuffer = new StringBuilder();
        __commandBuffer.append(command);

        if (args != null)
        {
            if (includeSpace) {
                __commandBuffer.append(' ');
            }
            __commandBuffer.append(args);
        }

        __commandBuffer.append(SocketClient.NETASCII_EOL);

        String message;
        _writer.write(message = __commandBuffer.toString());
        _writer.flush();

        fireCommandSent(command, message);

        __getReply();
        return _replyCode;
    }

    
Params:
  • command – the command to send (as an int defined in SMPTCommand)
  • args – the command arguments, may be null
  • includeSpace – if true, add a space between the command and its arguments
Throws:
Returns:the reply code
/**
     *
     * @param command the command to send (as an int defined in {@link SMPTCommand})
     * @param args the command arguments, may be {@code null}
     * @param includeSpace if {@code true}, add a space between the command and its arguments
     * @return the reply code
     * @throws IOException
     */
    private int __sendCommand(int command, String args, boolean includeSpace)
    throws IOException
    {
        return __sendCommand(SMTPCommand.getCommand(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)));
        }

        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. 
/*** Initiates control connections and gets initial reply. ***/
    @Override
    protected void _connectAction_() throws IOException
    {
        super._connectAction_();
        _reader =
            new CRLFLineReader(new InputStreamReader(_input_,
                                                    encoding));
        _writer =
            new BufferedWriter(new OutputStreamWriter(_output_,
                                                      encoding));
        __getReply();

    }


    
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.



Throws:
  • IOException – If an error occurs while disconnecting.
/***
     * 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.
     * <p>
     * @throws 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  getReplyString or  getReplyStrings. 


Params:
  • command –  The text representation of the  SMTP command to send.
  • args – The arguments to the SMTP command.  If this parameter is
            set to null, then the command is sent with no argument.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The integer value of the SMTP reply code returned by the server
        in response to the command.
/***
     * 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 }.
     * <p>
     * @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.
     * @throws 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.
     * @throws 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  getReplyString or  getReplyStrings. 


Params:
  • command –  The SMTPCommand constant corresponding to the SMTP command
                to send.
  • args – The arguments to the SMTP command.  If this parameter is
            set to null, then the command is sent with no argument.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The integer value of the SMTP reply code returned by the server
        in response to the command.
/***
     * 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 }.
     * <p>
     * @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.
     * @throws 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.
     * @throws 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.getCommand(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  getReplyString or  getReplyStrings. 


Params:
  • command –  The text representation of the  SMTP command to send.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The integer value of the SMTP reply code returned by the server
        in response to the command.
/***
     * 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 }.
     * <p>
     * @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.
     * @throws 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.
     * @throws 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  getReplyString or  getReplyStrings. 


Params:
  • command –  The SMTPCommand constant corresponding to the SMTP command
                to send.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The integer value of the SMTP reply code returned by the server
        in response to the command.
/***
     * 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 }.
     * <p>
     * @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.
     * @throws 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.
     * @throws 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.



Returns:The integer value of the reply code of the last SMTP reply.
/***
     * 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
     * <code> connect </code> is of type void.
     * <p>
     * @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  getReplyString or  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. 


Throws:
  • 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.
  • IOException –  If an I/O error occurs while receiving the
                        server reply.
Returns:The integer value of the reply code of the fetched SMTP reply.
/***
     * 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.
     * <p>
     * @return The integer value of the reply code of the fetched SMTP reply.
     * @throws 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.
     * @throws 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.



Returns:The lines of text from the last SMTP response as an array.
/***
     * 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.
     * <p>
     * @return The lines of text from the last SMTP response as an array.
     ***/
    public String[] getReplyStrings()
    {
        return _replyLines.toArray(new String[_replyLines.size()]);
    }

    
Returns the entire text of the last SMTP server response exactly
as it was received, including all end of line markers in NETASCII
format.



Returns:The entire text from the last SMTP response as a String.
/***
     * Returns the entire text of the last SMTP server response exactly
     * as it was received, including all end of line markers in NETASCII
     * format.
     * <p>
     * @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.



Params:
  • hostname – The hostname of the sender.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP HELO command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param hostname The hostname of the sender.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • reversePath – The reverese path.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP MAIL command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param reversePath The reverese path.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • forwardPath – The forward path.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP RCPT command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param forwardPath The forward path.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP DATA command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • reversePath – The reverese path.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP SEND command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param reversePath The reverese path.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • reversePath – The reverese path.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP SOML command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param reversePath The reverese path.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • reversePath – The reverese path.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP SAML command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param reversePath The reverese path.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP RSET command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • user – The user address to verify.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP VRFY command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param user The user address to verify.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • name – The name to expand.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP VRFY command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param name The name to expand.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP HELP command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Params:
  • command –  The command name on which to request help.
Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP HELP command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @param command  The command name on which to request help.
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP NOOP command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP TURN command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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.



Throws:
  • 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.
  • IOException –  If an I/O error occurs while either sending the
     command or receiving the server reply.
Returns:The reply code received from the server.
/***
     * A convenience method to send the SMTP QUIT command to the server,
     * receive the reply, and return the reply code.
     * <p>
     * @return The reply code received from the server.
     * @throws 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.
     * @throws 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);
    }

    
Removes a ProtocolCommandListener. Delegates this incorrectly named method - removeProtocolCommandistener (note the missing "L")- to the correct method SocketClient.removeProtocolCommandListener 
Params:
  • listener – The ProtocolCommandListener to remove
/**
     * Removes a ProtocolCommandListener.
     *
     * Delegates this incorrectly named method - removeProtocolCommandistener (note the missing "L")- to
     * the correct method {@link SocketClient#removeProtocolCommandListener}
     * @param listener The ProtocolCommandListener to remove
     */
    public void removeProtocolCommandistener(org.apache.commons.net.ProtocolCommandListener listener){
        removeProtocolCommandListener(listener);
    }

    
Provide command support to super-class

/**
     * Provide command support to super-class
     */
    @Override
    protected ProtocolCommandSupport getCommandSupport() {
        return _commandSupport_;
    }
}

/* Emacs configuration
 * Local variables:        **
 * mode:             java  **
 * c-basic-offset:   4     **
 * indent-tabs-mode: nil   **
 * End:                    **
 */