View Javadoc

    1   /*
    2    * Copyright 2001-2005 The Apache Software Foundation
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *     http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  package org.apache.commons.net.ftp;
    17  import java.io.BufferedReader;
    18  import java.io.BufferedWriter;
    19  import java.io.IOException;
    20  import java.io.InputStreamReader;
    21  import java.io.OutputStreamWriter;
    22  import java.lang.reflect.InvocationTargetException;
    23  import java.lang.reflect.Method;
    24  import java.net.InetAddress;
    25  import java.net.Socket;
    26  import java.net.SocketException;
    27  import java.util.Enumeration;
    28  import java.util.Vector;
    29
    30  import org.apache.commons.net.MalformedServerReplyException;
    31  import org.apache.commons.net.ProtocolCommandListener;
    32  import org.apache.commons.net.ProtocolCommandSupport;
    33  import org.apache.commons.net.SocketClient;
    34  import org.apache.commons.net.telnet.TelnetClient;
    35
    36  /****
    37   * FTP provides the basic the functionality necessary to implement your
    38   * own FTP client.  It extends org.apache.commons.net.TelnetClient
    39   * simply because it saves the writing of extra code to handle the FTP
    40   * control connection which always remains open during an FTP session and
    41   * uses the Telnet protocol.  Aggregation would require writing new
    42   * wrapper methods and wouldn't leverage the functionality already
    43   * present in org.apache.commons.net.SocketClient.
    44   * <p>
    45   * To derive the full benefits of the FTP class requires some knowledge
    46   * of the FTP protocol defined in RFC 959.  However, there is no reason
    47   * why you should have to use the FTP class.  The
    48   * {@link org.apache.commons.net.ftp.FTPClient} class,
    49   * derived from FTP,
    50   * implements all the functionality required of an FTP client.  The
    51   * FTP class is made public to provide access to various FTP constants
    52   * and to make it easier for adventurous programmers (or those with
    53   * special needs) to interact with the FTP protocol and implement their
    54   * own clients.  A set of methods with names corresponding to the FTP
    55   * command names are provided to facilitate this interaction.
    56   * <p>
    57   * You should keep in mind that the FTP server may choose to prematurely
    58   * close a connection if the client has been idle for longer than a
    59   * given time period (usually 900 seconds).  The FTP class will detect a
    60   * premature FTP server connection closing when it receives a
    61   * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
    62   *  response to a command.
    63   * When that occurs, the FTP class method encountering that reply will throw
    64   * an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
    65   * .  <code>FTPConectionClosedException</code>
    66   * is a subclass of <code> IOException </code> and therefore need not be
    67   * caught separately, but if you are going to catch it separately, its
    68   * catch block must appear before the more general <code> IOException </code>
    69   * catch block.  When you encounter an
    70   * {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
    71   * , you must disconnect the connection with
    72   * {@link #disconnect  disconnect() } to properly clean up the
    73   * system resources used by FTP.  Before disconnecting, you may check the
    74   * last reply code and text with
    75   * {@link #getReplyCode  getReplyCode },
    76   * {@link #getReplyString  getReplyString },
    77   * and {@link #getReplyStrings  getReplyStrings}.
    78   * You may avoid server disconnections while the client is idle by
    79   * periodicaly sending NOOP commands to the server.
    80   * <p>
    81   * Rather than list it separately for each method, we mention here that
    82   * every method communicating with the server and throwing an IOException
    83   * can also throw a
    84   * {@link org.apache.commons.net.MalformedServerReplyException}
    85   * , which is a subclass
    86   * of IOException.  A MalformedServerReplyException will be thrown when
    87   * the reply received from the server deviates enough from the protocol
    88   * specification that it cannot be interpreted in a useful manner despite
    89   * attempts to be as lenient as possible.
    90   * <p>
    91   * <p>
    92   * @author Daniel F. Savarese
    93   * @see FTPClient
    94   * @see FTPConnectionClosedException
    95   * @see org.apache.commons.net.MalformedServerReplyException
    96   ***/
    97
    98  public class FTP extends TelnetClient
    99  {
    100     /**** The default FTP data port (20). ***/
    101     public static final int DEFAULT_DATA_PORT = 20;
    102     /**** The default FTP control port (21). ***/
    103     public static final int DEFAULT_PORT = 21;
    104
    105     /****
    106      * A constant used to indicate the file(s) being transfered should
    107      * be treated as ASCII.  This is the default file type.  All constants
    108      * ending in <code>FILE_TYPE</code> are used to indicate file types.
    109      ***/
    110     public static final int ASCII_FILE_TYPE = 0;
    111
    112     /****
    113      * A constant used to indicate the file(s) being transfered should
    114      * be treated as EBCDIC.  Note however that there are several different
    115      * EBCDIC formats.  All constants ending in <code>FILE_TYPE</code>
    116      * are used to indicate file types.
    117      ***/
    118     public static final int EBCDIC_FILE_TYPE = 1;
    119
    120     /****
    121      * A constant used to indicate the file(s) being transfered should
    122      * be treated as a binary image, i.e., no translations should be
    123      * performed.  All constants ending in <code>FILE_TYPE</code> are used to
    124      * indicate file types.
    125      ***/
    126     public static final int IMAGE_FILE_TYPE = 2;
    127
    128     /****
    129      * A constant used to indicate the file(s) being transfered should
    130      * be treated as a binary image, i.e., no translations should be
    131      * performed.  All constants ending in <code>FILE_TYPE</code> are used to
    132      * indicate file types.
    133      ***/
    134     public static final int BINARY_FILE_TYPE = 2;
    135
    136     /****
    137      * A constant used to indicate the file(s) being transfered should
    138      * be treated as a local type.  All constants ending in
    139      * <code>FILE_TYPE</code> are used to indicate file types.
    140      ***/
    141     public static final int LOCAL_FILE_TYPE = 3;
    142
    143     /****
    144      * A constant used for text files to indicate a non-print text format.
    145      * This is the default format.
    146      * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
    147      * text formatting for text transfers (both ASCII and EBCDIC).
    148      ***/
    149     public static final int NON_PRINT_TEXT_FORMAT = 4;
    150
    151     /****
    152      * A constant used to indicate a text file contains format vertical format
    153      * control characters.
    154      * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
    155      * text formatting for text transfers (both ASCII and EBCDIC).
    156      ***/
    157     public static final int TELNET_TEXT_FORMAT = 5;
    158
    159     /****
    160      * A constant used to indicate a text file contains ASA vertical format
    161      * control characters.
    162      * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
    163      * text formatting for text transfers (both ASCII and EBCDIC).
    164      ***/
    165     public static final int CARRIAGE_CONTROL_TEXT_FORMAT = 6;
    166
    167     /****
    168      * A constant used to indicate a file is to be treated as a continuous
    169      * sequence of bytes.  This is the default structure.  All constants ending
    170      * in <code>_STRUCTURE</code> are used to indicate file structure for
    171      * file transfers.
    172      ***/
    173     public static final int FILE_STRUCTURE = 7;
    174
    175     /****
    176      * A constant used to indicate a file is to be treated as a sequence
    177      * of records.  All constants ending in <code>_STRUCTURE</code>
    178      * are used to indicate file structure for file transfers.
    179      ***/
    180     public static final int RECORD_STRUCTURE = 8;
    181
    182     /****
    183      * A constant used to indicate a file is to be treated as a set of
    184      * independent indexed pages.  All constants ending in
    185      * <code>_STRUCTURE</code> are used to indicate file structure for file
    186      * transfers.
    187      ***/
    188     public static final int PAGE_STRUCTURE = 9;
    189
    190     /****
    191      * A constant used to indicate a file is to be transfered as a stream
    192      * of bytes.  This is the default transfer mode.  All constants ending
    193      * in <code>TRANSFER_MODE</code> are used to indicate file transfer
    194      * modes.
    195      ***/
    196     public static final int STREAM_TRANSFER_MODE = 10;
    197
    198     /****
    199      * A constant used to indicate a file is to be transfered as a series
    200      * of blocks.  All constants ending in <code>TRANSFER_MODE</code> are used
    201      * to indicate file transfer modes.
    202      ***/
    203     public static final int BLOCK_TRANSFER_MODE = 11;
    204
    205     /****
    206      * A constant used to indicate a file is to be transfered as FTP
    207      * compressed data.  All constants ending in <code>TRANSFER_MODE</code>
    208      * are used to indicate file transfer modes.
    209      ***/
    210     public static final int COMPRESSED_TRANSFER_MODE = 12;
    211
    212     // We have to ensure that the protocol communication is in ASCII
    213     // but we use ISO-8859-1 just in case 8-bit characters cross
    214     // the wire.
    215     /***
    216      * The default character encoding used for communicating over an
    217      * FTP control connection.  The default encoding is an
    218      * ASCII-compatible encoding.  Some FTP servers expect other
    219      * encodings.  You can change the encoding used by an FTP instance
    220      * with {@link #setControlEncoding setControlEncoding}.
    221      */
    222     public static final String DEFAULT_CONTROL_ENCODING = "ISO-8859-1";
    223     private static final String __modes = "ABILNTCFRPSBC";
    224
    225     private StringBuffer __commandBuffer;
    226
    227     BufferedReader _controlInput;
    228     BufferedWriter _controlOutput;
    229     int _replyCode;
    230     Vector _replyLines;
    231     boolean _newReplyString;
    232     String _replyString;
    233     String _controlEncoding;
    234
    235     /****
    236      * A ProtocolCommandSupport object used to manage the registering of
    237      * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
    238      ***/
    239     protected ProtocolCommandSupport _commandSupport_;
    240
    241     /****
    242      * The default FTP constructor.  Sets the default port to
    243      * <code>DEFAULT_PORT</code> and initializes internal data structures
    244      * for saving FTP reply information.
    245      ***/
    246     public FTP()
    247     {
    248         setDefaultPort(DEFAULT_PORT);
    249         __commandBuffer = new StringBuffer();
    250         _replyLines = new Vector();
    251         _newReplyString = false;
    252         _replyString = null;
    253         _commandSupport_ = new ProtocolCommandSupport(this);
    254         _controlEncoding = DEFAULT_CONTROL_ENCODING;
    255     }
    256
    257     private void __getReply() throws IOException
    258     {
    259         int length;
    260
    261         _newReplyString = true;
    262         _replyLines.setSize(0);
    263
    264         String line = _controlInput.readLine();
    265
    266         if (line == null)
    267             throw new FTPConnectionClosedException(
    268                 "Connection closed without indication.");
    269
    270         // In case we run into an anomaly we don't want fatal index exceptions
    271         // to be thrown.
    272         length = line.length();
    273         if (length < 3)
    274             throw new MalformedServerReplyException(
    275                 "Truncated server reply: " + line);
    276
    277         try
    278         {
    279             String code = line.substring(0, 3);
    280             _replyCode = Integer.parseInt(code);
    281         }
    282         catch (NumberFormatException e)
    283         {
    284             throw new MalformedServerReplyException(
    285                 "Could not parse response code.\nServer Reply: " + line);
    286         }
    287
    288         _replyLines.addElement(line);
    289
    290         // Get extra lines if message continues.
    291         if (length > 3 && line.charAt(3) == '-')
    292         {
    293             do
    294             {
    295                 line = _controlInput.readLine();
    296
    297                 if (line == null)
    298                     throw new FTPConnectionClosedException(
    299                         "Connection closed without indication.");
    300
    301                 _replyLines.addElement(line);
    302
    303                 // The length() check handles problems that could arise from readLine()
    304                 // returning too soon after encountering a naked CR or some other
    305                 // anomaly.
    306             }
    307             while (!(line.length() >= 4 && line.charAt(3) != '-' &&
    308                      Character.isDigit(line.charAt(0))));
    309             // This is too strong a condition because of non-conforming ftp
    310             // servers like ftp.funet.fi which sent 226 as the last line of a
    311             // 426 multi-line reply in response to ls /.  We relax the condition to
    312             // test that the line starts with a digit rather than starting with
    313             // the code.
    314             // line.startsWith(code)));
    315         }
    316
    317         if (_commandSupport_.getListenerCount() > 0)
    318             _commandSupport_.fireReplyReceived(_replyCode, getReplyString());
    319
    320         if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE)
    321             throw new FTPConnectionClosedException(
    322                 "FTP response 421 received.  Server closed connection.");
    323     }
    324
    325     // initiates control connections and gets initial reply
    326     protected void _connectAction_() throws IOException
    327     {
    328         super._connectAction_();
    329         _controlInput =
    330             new BufferedReader(new InputStreamReader(getInputStream(),
    331                                                      getControlEncoding()));
    332         _controlOutput =
    333             new BufferedWriter(new OutputStreamWriter(getOutputStream(),
    334                                                       getControlEncoding()));
    335         __getReply();
    336         // If we received code 120, we have to fetch completion reply.
    337         if (FTPReply.isPositivePreliminary(_replyCode))
    338             __getReply();
    339     }
    340
    341
    342     /***
    343      * Sets the character encoding used by the FTP control connection.
    344      * Some FTP servers require that commands be issued in a non-ASCII
    345      * encoding like UTF-8 so that filenames with multi-byte character
    346      * representations (e.g, Big 8) can be specified.
    347      *
    348      * @param encoding The new character encoding for the control connection.
    349      */
    350     public void setControlEncoding(String encoding) {
    351         _controlEncoding = encoding;
    352     }
    353
    354
    355     /***
    356      * @return The character encoding used to communicate over the
    357      * control connection.
    358      */
    359     public String getControlEncoding() {
    360         return _controlEncoding;
    361     }
    362
    363
    364     /****
    365      * Adds a ProtocolCommandListener.  Delegates this task to
    366      * {@link #_commandSupport_  _commandSupport_ }.
    367      * <p>
    368      * @param listener  The ProtocolCommandListener to add.
    369      ***/
    370     public void addProtocolCommandListener(ProtocolCommandListener listener)
    371     {
    372         _commandSupport_.addProtocolCommandListener(listener);
    373     }
    374
    375     /****
    376      * Removes a ProtocolCommandListener.  Delegates this task to
    377      * {@link #_commandSupport_  _commandSupport_ }.
    378      * <p>
    379      * @param listener  The ProtocolCommandListener to remove.
    380      ***/
    381     public void removeProtocolCommandListener(ProtocolCommandListener listener)
    382     {
    383         _commandSupport_.removeProtocolCommandListener(listener);
    384     }
    385
    386
    387     /****
    388      * Closes the control connection to the FTP server and sets to null
    389      * some internal data so that the memory may be reclaimed by the
    390      * garbage collector.  The reply text and code information from the
    391      * last command is voided so that the memory it used may be reclaimed.
    392      * <p>
    393      * @exception IOException If an error occurs while disconnecting.
    394      ***/
    395     public void disconnect() throws IOException
    396     {
    397         super.disconnect();
    398         _controlInput = null;
    399         _controlOutput = null;
    400         _replyLines.setSize(0);
    401         _newReplyString = false;
    402         _replyString = null;
    403     }
    404
    405
    406     /****
    407      * Sends an FTP command to the server, waits for a reply and returns the
    408      * numerical response code.  After invocation, for more detailed
    409      * information, the actual reply text can be accessed by calling
    410      * {@link #getReplyString  getReplyString } or
    411      * {@link #getReplyStrings  getReplyStrings }.
    412      * <p>
    413      * @param command  The text representation of the  FTP command to send.
    414      * @param args The arguments to the FTP command.  If this parameter is
    415      *             set to null, then the command is sent with no argument.
    416      * @return The integer value of the FTP reply code returned by the server
    417      *         in response to the command.
    418      * @exception FTPConnectionClosedException
    419      *      If the FTP server prematurely closes the connection as a result
    420      *      of the client being idle or some other reason causing the server
    421      *      to send FTP reply code 421.  This exception may be caught either
    422      *      as an IOException or independently as itself.
    423      * @exception IOException  If an I/O error occurs while either sending the
    424      *      command or receiving the server reply.
    425      ***/
    426     public int sendCommand(String command, String args) throws IOException
    427     {
    428         String message;
    429
    430         __commandBuffer.setLength(0);
    431         __commandBuffer.append(command);
    432
    433         if (args != null)
    434         {
    435             __commandBuffer.append(' ');
    436             __commandBuffer.append(args);
    437         }
    438         __commandBuffer.append(SocketClient.NETASCII_EOL);
    439
    440         try{
    441 	    _controlOutput.write(message = __commandBuffer.toString());
    442         _controlOutput.flush();
    443         }
    444         catch (SocketException e)
    445         {
    446             if (!isConnected() || !socketIsConnected(_socket_))
    447             {
    448                 throw new FTPConnectionClosedException("Connection unexpectedly closed.");
    449             }
    450             else
    451             {
    452                 throw e;
    453             }
    454         }
    455
    456
    457         if (_commandSupport_.getListenerCount() > 0)
    458             _commandSupport_.fireCommandSent(command, message);
    459
    460         __getReply();
    461         return _replyCode;
    462     }
    463
    464     /***
    465      * Checks if the socket is connected using reflection to be backward compatible.
    466      * The return value of this method is only meaningful in an java 1.4 environment.
    467      *
    468      * @param socket
    469      * @return true if connected or pre java 1.4
    470      */
    471     private boolean socketIsConnected(Socket socket)
    472     {
    473         if (socket == null)
    474         {
    475             return false;
    476         }
    477
    478         try
    479         {
    480             Method isConnected = socket.getClass().getMethod("isConnected", null);
    481             return ((Boolean) isConnected.invoke(socket, null)).booleanValue();
    482         }
    483         catch (NoSuchMethodException e)
    484         {
    485             return true;
    486         }
    487         catch (IllegalAccessException e)
    488         {
    489             return true;
    490         }
    491         catch (InvocationTargetException e)
    492         {
    493             return true;
    494         }
    495     }
    496
    497     /****
    498      * Sends an FTP command to the server, waits for a reply and returns the
    499      * numerical response code.  After invocation, for more detailed
    500      * information, the actual reply text can be accessed by calling
    501      * {@link #getReplyString  getReplyString } or
    502      * {@link #getReplyStrings  getReplyStrings }.
    503      * <p>
    504      * @param command  The FTPCommand constant corresponding to the FTP command
    505      *                 to send.
    506      * @param args The arguments to the FTP command.  If this parameter is
    507      *             set to null, then the command is sent with no argument.
    508      * @return The integer value of the FTP reply code returned by the server
    509      *         in response to the command.
    510      * @exception FTPConnectionClosedException
    511      *      If the FTP server prematurely closes the connection as a result
    512      *      of the client being idle or some other reason causing the server
    513      *      to send FTP reply code 421.  This exception may be caught either
    514      *      as an IOException or independently as itself.
    515      * @exception IOException  If an I/O error occurs while either sending the
    516      *      command or receiving the server reply.
    517      ***/
    518     public int sendCommand(int command, String args) throws IOException
    519     {
    520         return sendCommand(FTPCommand._commands[command], args);
    521     }
    522
    523
    524     /****
    525      * Sends an FTP command with no arguments to the server, waits for a
    526      * reply and returns the numerical response code.  After invocation, for
    527      * more detailed information, the actual reply text can be accessed by
    528      * calling {@link #getReplyString  getReplyString } or
    529      * {@link #getReplyStrings  getReplyStrings }.
    530      * <p>
    531      * @param command  The text representation of the  FTP command to send.
    532      * @return The integer value of the FTP reply code returned by the server
    533      *         in response to the command.
    534      * @exception FTPConnectionClosedException
    535      *      If the FTP server prematurely closes the connection as a result
    536      *      of the client being idle or some other reason causing the server
    537      *      to send FTP reply code 421.  This exception may be caught either
    538      *      as an IOException or independently as itself.
    539      * @exception IOException  If an I/O error occurs while either sending the
    540      *      command or receiving the server reply.
    541      ***/
    542     public int sendCommand(String command) throws IOException
    543     {
    544         return sendCommand(command, null);
    545     }
    546
    547
    548     /****
    549      * Sends an FTP command with no arguments to the server, waits for a
    550      * reply and returns the numerical response code.  After invocation, for
    551      * more detailed information, the actual reply text can be accessed by
    552      * calling {@link #getReplyString  getReplyString } or
    553      * {@link #getReplyStrings  getReplyStrings }.
    554      * <p>
    555      * @param command  The FTPCommand constant corresponding to the FTP command
    556      *                 to send.
    557      * @return The integer value of the FTP reply code returned by the server
    558      *         in response to the command.
    559      * @exception FTPConnectionClosedException
    560      *      If the FTP server prematurely closes the connection as a result
    561      *      of the client being idle or some other reason causing the server
    562      *      to send FTP reply code 421.  This exception may be caught either
    563      *      as an IOException or independently as itself.
    564      * @exception IOException  If an I/O error occurs while either sending the
    565      *      command or receiving the server reply.
    566      ***/
    567     public int sendCommand(int command) throws IOException
    568     {
    569         return sendCommand(command, null);
    570     }
    571
    572
    573     /****
    574      * Returns the integer value of the reply code of the last FTP reply.
    575      * You will usually only use this method after you connect to the
    576      * FTP server to check that the connection was successful since
    577      * <code> connect </code> is of type void.
    578      * <p>
    579      * @return The integer value of the reply code of the last FTP reply.
    580      ***/
    581     public int getReplyCode()
    582     {
    583         return _replyCode;
    584     }
    585
    586     /****
    587      * Fetches a reply from the FTP server and returns the integer reply
    588      * code.  After calling this method, the actual reply text can be accessed
    589      * from either  calling {@link #getReplyString  getReplyString } or
    590      * {@link #getReplyStrings  getReplyStrings }.  Only use this
    591      * method if you are implementing your own FTP client or if you need to
    592      * fetch a secondary response from the FTP server.
    593      * <p>
    594      * @return The integer value of the reply code of the fetched FTP reply.
    595      * @exception FTPConnectionClosedException
    596      *      If the FTP server prematurely closes the connection as a result
    597      *      of the client being idle or some other reason causing the server
    598      *      to send FTP reply code 421.  This exception may be caught either
    599      *      as an IOException or independently as itself.
    600      * @exception IOException  If an I/O error occurs while receiving the
    601      *                         server reply.
    602      ***/
    603     public int getReply() throws IOException
    604     {
    605         __getReply();
    606         return _replyCode;
    607     }
    608
    609
    610     /****
    611      * Returns the lines of text from the last FTP server response as an array
    612      * of strings, one entry per line.  The end of line markers of each are
    613      * stripped from each line.
    614      * <p>
    615      * @return The lines of text from the last FTP response as an array.
    616      ***/
    617     public String[] getReplyStrings()
    618     {
    619         String[] lines;
    620         lines = new String[_replyLines.size()];
    621         _replyLines.copyInto(lines);
    622         return lines;
    623     }
    624
    625     /****
    626      * Returns the entire text of the last FTP server response exactly
    627      * as it was received, including all end of line markers in NETASCII
    628      * format.
    629      * <p>
    630      * @return The entire text from the last FTP response as a String.
    631      ***/
    632     public String getReplyString()
    633     {
    634         Enumeration en;
    635         StringBuffer buffer;
    636
    637         if (!_newReplyString)
    638             return _replyString;
    639
    640         buffer = new StringBuffer(256);
    641         en = _replyLines.elements();
    642         while (en.hasMoreElements())
    643         {
    644             buffer.append((String)en.nextElement());
    645             buffer.append(SocketClient.NETASCII_EOL);
    646         }
    647
    648         _newReplyString = false;
    649
    650         return (_replyString = buffer.toString());
    651     }
    652
    653
    654     /****
    655      * A convenience method to send the FTP USER command to the server,
    656      * receive the reply, and return the reply code.
    657      * <p>
    658      * @param username  The username to login under.
    659      * @return The reply code received from the server.
    660      * @exception FTPConnectionClosedException
    661      *      If the FTP server prematurely closes the connection as a result
    662      *      of the client being idle or some other reason causing the server
    663      *      to send FTP reply code 421.  This exception may be caught either
    664      *      as an IOException or independently as itself.
    665      * @exception IOException  If an I/O error occurs while either sending the
    666      *      command or receiving the server reply.
    667      ***/
    668     public int user(String username) throws IOException
    669     {
    670         return sendCommand(FTPCommand.USER, username);
    671     }
    672
    673     /***
    674      * A convenience method to send the FTP PASS command to the server,
    675      * receive the reply, and return the reply code.
    676      * @param password The plain text password of the username being logged into.
    677      * @return The reply code received from the server.
    678      * @exception FTPConnectionClosedException
    679      *      If the FTP server prematurely closes the connection as a result
    680      *      of the client being idle or some other reason causing the server
    681      *      to send FTP reply code 421.  This exception may be caught either
    682      *      as an IOException or independently as itself.
    683      * @exception IOException  If an I/O error occurs while either sending the
    684      *      command or receiving the server reply.
    685      */
    686     public int pass(String password) throws IOException
    687     {
    688         return sendCommand(FTPCommand.PASS, password);
    689     }
    690
    691     /****
    692      * A convenience method to send the FTP ACCT command to the server,
    693      * receive the reply, and return the reply code.
    694      * <p>
    695      * @param account  The account name to access.
    696      * @return The reply code received from the server.
    697      * @exception FTPConnectionClosedException
    698      *      If the FTP server prematurely closes the connection as a result
    699      *      of the client being idle or some other reason causing the server
    700      *      to send FTP reply code 421.  This exception may be caught either
    701      *      as an IOException or independently as itself.
    702      * @exception IOException  If an I/O error occurs while either sending the
    703      *      command or receiving the server reply.
    704      ***/
    705     public int acct(String account) throws IOException
    706     {
    707         return sendCommand(FTPCommand.ACCT, account);
    708     }
    709
    710
    711     /****
    712      * A convenience method to send the FTP ABOR command to the server,
    713      * receive the reply, and return the reply code.
    714      * <p>
    715      * @return The reply code received from the server.
    716      * @exception FTPConnectionClosedException
    717      *      If the FTP server prematurely closes the connection as a result
    718      *      of the client being idle or some other reason causing the server
    719      *      to send FTP reply code 421.  This exception may be caught either
    720      *      as an IOException or independently as itself.
    721      * @exception IOException  If an I/O error occurs while either sending the
    722      *      command or receiving the server reply.
    723      ***/
    724     public int abor() throws IOException
    725     {
    726         return sendCommand(FTPCommand.ABOR);
    727     }
    728
    729     /****
    730      * A convenience method to send the FTP CWD command to the server,
    731      * receive the reply, and return the reply code.
    732      * <p>
    733      * @param directory The new working directory.
    734      * @return The reply code received from the server.
    735      * @exception FTPConnectionClosedException
    736      *      If the FTP server prematurely closes the connection as a result
    737      *      of the client being idle or some other reason causing the server
    738      *      to send FTP reply code 421.  This exception may be caught either
    739      *      as an IOException or independently as itself.
    740      * @exception IOException  If an I/O error occurs while either sending the
    741      *      command or receiving the server reply.
    742      ***/
    743     public int cwd(String directory) throws IOException
    744     {
    745         return sendCommand(FTPCommand.CWD, directory);
    746     }
    747
    748     /****
    749      * A convenience method to send the FTP CDUP command to the server,
    750      * receive the reply, and return the reply code.
    751      * <p>
    752      * @return The reply code received from the server.
    753      * @exception FTPConnectionClosedException
    754      *      If the FTP server prematurely closes the connection as a result
    755      *      of the client being idle or some other reason causing the server
    756      *      to send FTP reply code 421.  This exception may be caught either
    757      *      as an IOException or independently as itself.
    758      * @exception IOException  If an I/O error occurs while either sending the
    759      *      command or receiving the server reply.
    760      ***/
    761     public int cdup() throws IOException
    762     {
    763         return sendCommand(FTPCommand.CDUP);
    764     }
    765
    766     /****
    767      * A convenience method to send the FTP QUIT command to the server,
    768      * receive the reply, and return the reply code.
    769      * <p>
    770      * @return The reply code received from the server.
    771      * @exception FTPConnectionClosedException
    772      *      If the FTP server prematurely closes the connection as a result
    773      *      of the client being idle or some other reason causing the server
    774      *      to send FTP reply code 421.  This exception may be caught either
    775      *      as an IOException or independently as itself.
    776      * @exception IOException  If an I/O error occurs while either sending the
    777      *      command or receiving the server reply.
    778      ***/
    779     public int quit() throws IOException
    780     {
    781         return sendCommand(FTPCommand.QUIT);
    782     }
    783
    784     /****
    785      * A convenience method to send the FTP REIN command to the server,
    786      * receive the reply, and return the reply code.
    787      * <p>
    788      * @return The reply code received from the server.
    789      * @exception FTPConnectionClosedException
    790      *      If the FTP server prematurely closes the connection as a result
    791      *      of the client being idle or some other reason causing the server
    792      *      to send FTP reply code 421.  This exception may be caught either
    793      *      as an IOException or independently as itself.
    794      * @exception IOException  If an I/O error occurs while either sending the
    795      *      command or receiving the server reply.
    796      ***/
    797     public int rein() throws IOException
    798     {
    799         return sendCommand(FTPCommand.REIN);
    800     }
    801
    802     /****
    803      * A convenience method to send the FTP SMNT command to the server,
    804      * receive the reply, and return the reply code.
    805      * <p>
    806      * @param dir  The directory name.
    807      * @return The reply code received from the server.
    808      * @exception FTPConnectionClosedException
    809      *      If the FTP server prematurely closes the connection as a result
    810      *      of the client being idle or some other reason causing the server
    811      *      to send FTP reply code 421.  This exception may be caught either
    812      *      as an IOException or independently as itself.
    813      * @exception IOException  If an I/O error occurs while either sending the
    814      *      command or receiving the server reply.
    815      ***/
    816     public int smnt(String dir) throws IOException
    817     {
    818         return sendCommand(FTPCommand.SMNT, dir);
    819     }
    820
    821     /****
    822      * A convenience method to send the FTP PORT command to the server,
    823      * receive the reply, and return the reply code.
    824      * <p>
    825      * @param host  The host owning the port.
    826      * @param port  The new port.
    827      * @return The reply code received from the server.
    828      * @exception FTPConnectionClosedException
    829      *      If the FTP server prematurely closes the connection as a result
    830      *      of the client being idle or some other reason causing the server
    831      *      to send FTP reply code 421.  This exception may be caught either
    832      *      as an IOException or independently as itself.
    833      * @exception IOException  If an I/O error occurs while either sending the
    834      *      command or receiving the server reply.
    835      ***/
    836     public int port(InetAddress host, int port) throws IOException
    837     {
    838         int num;
    839         StringBuffer info = new StringBuffer(24);
    840
    841         info.append(host.getHostAddress().replace('.', ','));
    842         num = port >>> 8;
    843         info.append(',');
    844         info.append(num);
    845         info.append(',');
    846         num = port & 0xff;
    847         info.append(num);
    848
    849         return sendCommand(FTPCommand.PORT, info.toString());
    850     }
    851
    852     /****
    853      * A convenience method to send the FTP PASV command to the server,
    854      * receive the reply, and return the reply code.  Remember, it's up
    855      * to you to interpret the reply string containing the host/port
    856      * information.
    857      * <p>
    858      * @return The reply code received from the server.
    859      * @exception FTPConnectionClosedException
    860      *      If the FTP server prematurely closes the connection as a result
    861      *      of the client being idle or some other reason causing the server
    862      *      to send FTP reply code 421.  This exception may be caught either
    863      *      as an IOException or independently as itself.
    864      * @exception IOException  If an I/O error occurs while either sending the
    865      *      command or receiving the server reply.
    866      ***/
    867     public int pasv() throws IOException
    868     {
    869         return sendCommand(FTPCommand.PASV);
    870     }
    871
    872     /***
    873      * A convenience method to send the FTP TYPE command for text files
    874      * to the server, receive the reply, and return the reply code.
    875      * @param fileType  The type of the file (one of the <code>FILE_TYPE</code>
    876      *              constants).
    877      * @param formatOrByteSize  The format of the file (one of the
    878      *              <code>_FORMAT</code> constants.  In the case of
    879      *              <code>LOCAL_FILE_TYPE</code>, the byte size.
    880      * @return The reply code received from the server.
    881      * @exception FTPConnectionClosedException
    882      *      If the FTP server prematurely closes the connection as a result
    883      *      of the client being idle or some other reason causing the server
    884      *      to send FTP reply code 421.  This exception may be caught either
    885      *      as an IOException or independently as itself.
    886      * @exception IOException  If an I/O error occurs while either sending the
    887      *      command or receiving the server reply.
    888      */
    889     public int type(int fileType, int formatOrByteSize) throws IOException
    890     {
    891         StringBuffer arg = new StringBuffer();
    892
    893         arg.append(__modes.charAt(fileType));
    894         arg.append(' ');
    895         if (fileType == LOCAL_FILE_TYPE)
    896             arg.append(formatOrByteSize);
    897         else
    898             arg.append(__modes.charAt(formatOrByteSize));
    899
    900         return sendCommand(FTPCommand.TYPE, arg.toString());
    901     }
    902
    903
    904     /***
    905      * A convenience method to send the FTP TYPE command to the server,
    906      * receive the reply, and return the reply code.
    907      * <p>
    908      * @param fileType  The type of the file (one of the <code>FILE_TYPE</code>
    909      *              constants).
    910      * @return The reply code received from the server.
    911      * @exception FTPConnectionClosedException
    912      *      If the FTP server prematurely closes the connection as a result
    913      *      of the client being idle or some other reason causing the server
    914      *      to send FTP reply code 421.  This exception may be caught either
    915      *      as an IOException or independently as itself.
    916      * @exception IOException  If an I/O error occurs while either sending the
    917      *      command or receiving the server reply.
    918      */
    919     public int type(int fileType) throws IOException
    920     {
    921         return sendCommand(FTPCommand.TYPE,
    922                            __modes.substring(fileType, fileType + 1));
    923     }
    924
    925     /****
    926      * A convenience method to send the FTP STRU command to the server,
    927      * receive the reply, and return the reply code.
    928      * <p>
    929      * @param structure  The structure of the file (one of the
    930      *         <code>_STRUCTURE</code> constants).
    931      * @return The reply code received from the server.
    932      * @exception FTPConnectionClosedException
    933      *      If the FTP server prematurely closes the connection as a result
    934      *      of the client being idle or some other reason causing the server
    935      *      to send FTP reply code 421.  This exception may be caught either
    936      *      as an IOException or independently as itself.
    937      * @exception IOException  If an I/O error occurs while either sending the
    938      *      command or receiving the server reply.
    939      ***/
    940     public int stru(int structure) throws IOException
    941     {
    942         return sendCommand(FTPCommand.STRU,
    943                            __modes.substring(structure, structure + 1));
    944     }
    945
    946     /****
    947      * A convenience method to send the FTP MODE command to the server,
    948      * receive the reply, and return the reply code.
    949      * <p>
    950      * @param mode  The transfer mode to use (one of the
    951      *         <code>TRANSFER_MODE</code> constants).
    952      * @return The reply code received from the server.
    953      * @exception FTPConnectionClosedException
    954      *      If the FTP server prematurely closes the connection as a result
    955      *      of the client being idle or some other reason causing the server
    956      *      to send FTP reply code 421.  This exception may be caught either
    957      *      as an IOException or independently as itself.
    958      * @exception IOException  If an I/O error occurs while either sending the
    959      *      command or receiving the server reply.
    960      ***/
    961     public int mode(int mode) throws IOException
    962     {
    963         return sendCommand(FTPCommand.MODE,
    964                            __modes.substring(mode, mode + 1));
    965     }
    966
    967     /****
    968      * A convenience method to send the FTP RETR command to the server,
    969      * receive the reply, and return the reply code.  Remember, it is up
    970      * to you to manage the data connection.  If you don't need this low
    971      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    972      * , which will handle all low level details for you.
    973      * <p>
    974      * @param pathname  The pathname of the file to retrieve.
    975      * @return The reply code received from the server.
    976      * @exception FTPConnectionClosedException
    977      *      If the FTP server prematurely closes the connection as a result
    978      *      of the client being idle or some other reason causing the server
    979      *      to send FTP reply code 421.  This exception may be caught either
    980      *      as an IOException or independently as itself.
    981      * @exception IOException  If an I/O error occurs while either sending the
    982      *      command or receiving the server reply.
    983      ***/
    984     public int retr(String pathname) throws IOException
    985     {
    986         return sendCommand(FTPCommand.RETR, pathname);
    987     }
    988
    989     /****
    990      * A convenience method to send the FTP STOR command to the server,
    991      * receive the reply, and return the reply code.  Remember, it is up
    992      * to you to manage the data connection.  If you don't need this low
    993      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    994      * , which will handle all low level details for you.
    995      * <p>
    996      * @param pathname  The pathname to use for the file when stored at
    997      *                  the remote end of the transfer.
    998      * @return The reply code received from the server.
    999      * @exception FTPConnectionClosedException
    1000      *      If the FTP server prematurely closes the connection as a result
    1001      *      of the client being idle or some other reason causing the server
    1002      *      to send FTP reply code 421.  This exception may be caught either
    1003      *      as an IOException or independently as itself.
    1004      * @exception IOException  If an I/O error occurs while either sending the
    1005      *      command or receiving the server reply.
    1006      ***/
    1007     public int stor(String pathname) throws IOException
    1008     {
    1009         return sendCommand(FTPCommand.STOR, pathname);
    1010     }
    1011
    1012     /****
    1013      * A convenience method to send the FTP STOU command to the server,
    1014      * receive the reply, and return the reply code.  Remember, it is up
    1015      * to you to manage the data connection.  If you don't need this low
    1016      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1017      * , which will handle all low level details for you.
    1018      * <p>
    1019      * @return The reply code received from the server.
    1020      * @exception FTPConnectionClosedException
    1021      *      If the FTP server prematurely closes the connection as a result
    1022      *      of the client being idle or some other reason causing the server
    1023      *      to send FTP reply code 421.  This exception may be caught either
    1024      *      as an IOException or independently as itself.
    1025      * @exception IOException  If an I/O error occurs while either sending the
    1026      *      command or receiving the server reply.
    1027      ***/
    1028     public int stou() throws IOException
    1029     {
    1030         return sendCommand(FTPCommand.STOU);
    1031     }
    1032
    1033     /****
    1034      * A convenience method to send the FTP STOU command to the server,
    1035      * receive the reply, and return the reply code.  Remember, it is up
    1036      * to you to manage the data connection.  If you don't need this low
    1037      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1038      * , which will handle all low level details for you.
    1039      * @param pathname  The base pathname to use for the file when stored at
    1040      *                  the remote end of the transfer.  Some FTP servers
    1041      *                  require this.
    1042      * @return The reply code received from the server.
    1043      * @exception FTPConnectionClosedException
    1044      *      If the FTP server prematurely closes the connection as a result
    1045      *      of the client being idle or some other reason causing the server
    1046      *      to send FTP reply code 421.  This exception may be caught either
    1047      *      as an IOException or independently as itself.
    1048      * @exception IOException  If an I/O error occurs while either sending the
    1049      *      command or receiving the server reply.
    1050      */
    1051     public int stou(String pathname) throws IOException
    1052     {
    1053         return sendCommand(FTPCommand.STOU, pathname);
    1054     }
    1055
    1056     /****
    1057      * A convenience method to send the FTP APPE command to the server,
    1058      * receive the reply, and return the reply code.  Remember, it is up
    1059      * to you to manage the data connection.  If you don't need this low
    1060      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1061      * , which will handle all low level details for you.
    1062      * <p>
    1063      * @param pathname  The pathname to use for the file when stored at
    1064      *                  the remote end of the transfer.
    1065      * @return The reply code received from the server.
    1066      * @exception FTPConnectionClosedException
    1067      *      If the FTP server prematurely closes the connection as a result
    1068      *      of the client being idle or some other reason causing the server
    1069      *      to send FTP reply code 421.  This exception may be caught either
    1070      *      as an IOException or independently as itself.
    1071      * @exception IOException  If an I/O error occurs while either sending the
    1072      *      command or receiving the server reply.
    1073      ***/
    1074     public int appe(String pathname) throws IOException
    1075     {
    1076         return sendCommand(FTPCommand.APPE, pathname);
    1077     }
    1078
    1079     /****
    1080      * A convenience method to send the FTP ALLO command to the server,
    1081      * receive the reply, and return the reply code.
    1082      * <p>
    1083      * @param bytes The number of bytes to allocate.
    1084      * @return The reply code received from the server.
    1085      * @exception FTPConnectionClosedException
    1086      *      If the FTP server prematurely closes the connection as a result
    1087      *      of the client being idle or some other reason causing the server
    1088      *      to send FTP reply code 421.  This exception may be caught either
    1089      *      as an IOException or independently as itself.
    1090      * @exception IOException  If an I/O error occurs while either sending the
    1091      *      command or receiving the server reply.
    1092      ***/
    1093     public int allo(int bytes) throws IOException
    1094     {
    1095         return sendCommand(FTPCommand.ALLO, Integer.toString(bytes));
    1096     }
    1097
    1098     /****
    1099      * A convenience method to send the FTP ALLO command to the server,
    1100      * receive the reply, and return the reply code.
    1101      * <p>
    1102      * @param bytes The number of bytes to allocate.
    1103      * @param recordSize  The size of a record.
    1104      * @return The reply code received from the server.
    1105      * @exception FTPConnectionClosedException
    1106      *      If the FTP server prematurely closes the connection as a result
    1107      *      of the client being idle or some other reason causing the server
    1108      *      to send FTP reply code 421.  This exception may be caught either
    1109      *      as an IOException or independently as itself.
    1110      * @exception IOException  If an I/O error occurs while either sending the
    1111      *      command or receiving the server reply.
    1112      ***/
    1113     public int allo(int bytes, int recordSize) throws IOException
    1114     {
    1115         return sendCommand(FTPCommand.ALLO, Integer.toString(bytes) + " R " +
    1116                            Integer.toString(recordSize));
    1117     }
    1118
    1119     /****
    1120      * A convenience method to send the FTP REST command to the server,
    1121      * receive the reply, and return the reply code.
    1122      * <p>
    1123      * @param marker The marker at which to restart a transfer.
    1124      * @return The reply code received from the server.
    1125      * @exception FTPConnectionClosedException
    1126      *      If the FTP server prematurely closes the connection as a result
    1127      *      of the client being idle or some other reason causing the server
    1128      *      to send FTP reply code 421.  This exception may be caught either
    1129      *      as an IOException or independently as itself.
    1130      * @exception IOException  If an I/O error occurs while either sending the
    1131      *      command or receiving the server reply.
    1132      ***/
    1133     public int rest(String marker) throws IOException
    1134     {
    1135         return sendCommand(FTPCommand.REST, marker);
    1136     }
    1137
    1138     /****
    1139      * A convenience method to send the FTP RNFR command to the server,
    1140      * receive the reply, and return the reply code.
    1141      * <p>
    1142      * @param pathname The pathname to rename from.
    1143      * @return The reply code received from the server.
    1144      * @exception FTPConnectionClosedException
    1145      *      If the FTP server prematurely closes the connection as a result
    1146      *      of the client being idle or some other reason causing the server
    1147      *      to send FTP reply code 421.  This exception may be caught either
    1148      *      as an IOException or independently as itself.
    1149      * @exception IOException  If an I/O error occurs while either sending the
    1150      *      command or receiving the server reply.
    1151      ***/
    1152     public int rnfr(String pathname) throws IOException
    1153     {
    1154         return sendCommand(FTPCommand.RNFR, pathname);
    1155     }
    1156
    1157     /****
    1158      * A convenience method to send the FTP RNTO command to the server,
    1159      * receive the reply, and return the reply code.
    1160      * <p>
    1161      * @param pathname The pathname to rename to
    1162      * @return The reply code received from the server.
    1163      * @exception FTPConnectionClosedException
    1164      *      If the FTP server prematurely closes the connection as a result
    1165      *      of the client being idle or some other reason causing the server
    1166      *      to send FTP reply code 421.  This exception may be caught either
    1167      *      as an IOException or independently as itself.
    1168      * @exception IOException  If an I/O error occurs while either sending the
    1169      *      command or receiving the server reply.
    1170      ***/
    1171     public int rnto(String pathname) throws IOException
    1172     {
    1173         return sendCommand(FTPCommand.RNTO, pathname);
    1174     }
    1175
    1176     /****
    1177      * A convenience method to send the FTP DELE command to the server,
    1178      * receive the reply, and return the reply code.
    1179      * <p>
    1180      * @param pathname The pathname to delete.
    1181      * @return The reply code received from the server.
    1182      * @exception FTPConnectionClosedException
    1183      *      If the FTP server prematurely closes the connection as a result
    1184      *      of the client being idle or some other reason causing the server
    1185      *      to send FTP reply code 421.  This exception may be caught either
    1186      *      as an IOException or independently as itself.
    1187      * @exception IOException  If an I/O error occurs while either sending the
    1188      *      command or receiving the server reply.
    1189      ***/
    1190     public int dele(String pathname) throws IOException
    1191     {
    1192         return sendCommand(FTPCommand.DELE, pathname);
    1193     }
    1194
    1195     /****
    1196      * A convenience method to send the FTP RMD command to the server,
    1197      * receive the reply, and return the reply code.
    1198      * <p>
    1199      * @param pathname The pathname of the directory to remove.
    1200      * @return The reply code received from the server.
    1201      * @exception FTPConnectionClosedException
    1202      *      If the FTP server prematurely closes the connection as a result
    1203      *      of the client being idle or some other reason causing the server
    1204      *      to send FTP reply code 421.  This exception may be caught either
    1205      *      as an IOException or independently as itself.
    1206      * @exception IOException  If an I/O error occurs while either sending the
    1207      *      command or receiving the server reply.
    1208      ***/
    1209     public int rmd(String pathname) throws IOException
    1210     {
    1211         return sendCommand(FTPCommand.RMD, pathname);
    1212     }
    1213
    1214     /****
    1215      * A convenience method to send the FTP MKD command to the server,
    1216      * receive the reply, and return the reply code.
    1217      * <p>
    1218      * @param pathname The pathname of the new directory to create.
    1219      * @return The reply code received from the server.
    1220      * @exception FTPConnectionClosedException
    1221      *      If the FTP server prematurely closes the connection as a result
    1222      *      of the client being idle or some other reason causing the server
    1223      *      to send FTP reply code 421.  This exception may be caught either
    1224      *      as an IOException or independently as itself.
    1225      * @exception IOException  If an I/O error occurs while either sending the
    1226      *      command or receiving the server reply.
    1227      ***/
    1228     public int mkd(String pathname) throws IOException
    1229     {
    1230         return sendCommand(FTPCommand.MKD, pathname);
    1231     }
    1232
    1233     /****
    1234      * A convenience method to send the FTP PWD command to the server,
    1235      * receive the reply, and return the reply code.
    1236      * <p>
    1237      * @return The reply code received from the server.
    1238      * @exception FTPConnectionClosedException
    1239      *      If the FTP server prematurely closes the connection as a result
    1240      *      of the client being idle or some other reason causing the server
    1241      *      to send FTP reply code 421.  This exception may be caught either
    1242      *      as an IOException or independently as itself.
    1243      * @exception IOException  If an I/O error occurs while either sending the
    1244      *      command or receiving the server reply.
    1245      ***/
    1246     public int pwd() throws IOException
    1247     {
    1248         return sendCommand(FTPCommand.PWD);
    1249     }
    1250
    1251     /****
    1252      * A convenience method to send the FTP LIST command to the server,
    1253      * receive the reply, and return the reply code.  Remember, it is up
    1254      * to you to manage the data connection.  If you don't need this low
    1255      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1256      * , which will handle all low level details for you.
    1257      * <p>
    1258      * @return The reply code received from the server.
    1259      * @exception FTPConnectionClosedException
    1260      *      If the FTP server prematurely closes the connection as a result
    1261      *      of the client being idle or some other reason causing the server
    1262      *      to send FTP reply code 421.  This exception may be caught either
    1263      *      as an IOException or independently as itself.
    1264      * @exception IOException  If an I/O error occurs while either sending the
    1265      *      command or receiving the server reply.
    1266      ***/
    1267     public int list() throws IOException
    1268     {
    1269         return sendCommand(FTPCommand.LIST);
    1270     }
    1271
    1272     /****
    1273      * A convenience method to send the FTP LIST command to the server,
    1274      * receive the reply, and return the reply code.  Remember, it is up
    1275      * to you to manage the data connection.  If you don't need this low
    1276      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1277      * , which will handle all low level details for you.
    1278      * <p>
    1279      * @param pathname  The pathname to list.
    1280      * @return The reply code received from the server.
    1281      * @exception FTPConnectionClosedException
    1282      *      If the FTP server prematurely closes the connection as a result
    1283      *      of the client being idle or some other reason causing the server
    1284      *      to send FTP reply code 421.  This exception may be caught either
    1285      *      as an IOException or independently as itself.
    1286      * @exception IOException  If an I/O error occurs while either sending the
    1287      *      command or receiving the server reply.
    1288      ***/
    1289     public int list(String pathname) throws IOException
    1290     {
    1291         return sendCommand(FTPCommand.LIST, pathname);
    1292     }
    1293
    1294     /****
    1295      * A convenience method to send the FTP NLST command to the server,
    1296      * receive the reply, and return the reply code.  Remember, it is up
    1297      * to you to manage the data connection.  If you don't need this low
    1298      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1299      * , which will handle all low level details for you.
    1300      * <p>
    1301      * @return The reply code received from the server.
    1302      * @exception FTPConnectionClosedException
    1303      *      If the FTP server prematurely closes the connection as a result
    1304      *      of the client being idle or some other reason causing the server
    1305      *      to send FTP reply code 421.  This exception may be caught either
    1306      *      as an IOException or independently as itself.
    1307      * @exception IOException  If an I/O error occurs while either sending the
    1308      *      command or receiving the server reply.
    1309      ***/
    1310     public int nlst() throws IOException
    1311     {
    1312         return sendCommand(FTPCommand.NLST);
    1313     }
    1314
    1315     /****
    1316      * A convenience method to send the FTP NLST command to the server,
    1317      * receive the reply, and return the reply code.  Remember, it is up
    1318      * to you to manage the data connection.  If you don't need this low
    1319      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1320      * , which will handle all low level details for you.
    1321      * <p>
    1322      * @param pathname  The pathname to list.
    1323      * @return The reply code received from the server.
    1324      * @exception FTPConnectionClosedException
    1325      *      If the FTP server prematurely closes the connection as a result
    1326      *      of the client being idle or some other reason causing the server
    1327      *      to send FTP reply code 421.  This exception may be caught either
    1328      *      as an IOException or independently as itself.
    1329      * @exception IOException  If an I/O error occurs while either sending the
    1330      *      command or receiving the server reply.
    1331      ***/
    1332     public int nlst(String pathname) throws IOException
    1333     {
    1334         return sendCommand(FTPCommand.NLST, pathname);
    1335     }
    1336
    1337     /****
    1338      * A convenience method to send the FTP SITE command to the server,
    1339      * receive the reply, and return the reply code.
    1340      * <p>
    1341      * @param parameters  The site parameters to send.
    1342      * @return The reply code received from the server.
    1343      * @exception FTPConnectionClosedException
    1344      *      If the FTP server prematurely closes the connection as a result
    1345      *      of the client being idle or some other reason causing the server
    1346      *      to send FTP reply code 421.  This exception may be caught either
    1347      *      as an IOException or independently as itself.
    1348      * @exception IOException  If an I/O error occurs while either sending the
    1349      *      command or receiving the server reply.
    1350      ***/
    1351     public int site(String parameters) throws IOException
    1352     {
    1353         return sendCommand(FTPCommand.SITE, parameters);
    1354     }
    1355
    1356     /****
    1357      * A convenience method to send the FTP SYST command to the server,
    1358      * receive the reply, and return the reply code.
    1359      * <p>
    1360      * @return The reply code received from the server.
    1361      * @exception FTPConnectionClosedException
    1362      *      If the FTP server prematurely closes the connection as a result
    1363      *      of the client being idle or some other reason causing the server
    1364      *      to send FTP reply code 421.  This exception may be caught either
    1365      *      as an IOException or independently as itself.
    1366      * @exception IOException  If an I/O error occurs while either sending the
    1367      *      command or receiving the server reply.
    1368      ***/
    1369     public int syst() throws IOException
    1370     {
    1371         return sendCommand(FTPCommand.SYST);
    1372     }
    1373
    1374     /****
    1375      * A convenience method to send the FTP STAT command to the server,
    1376      * receive the reply, and return the reply code.
    1377      * <p>
    1378      * @return The reply code received from the server.
    1379      * @exception FTPConnectionClosedException
    1380      *      If the FTP server prematurely closes the connection as a result
    1381      *      of the client being idle or some other reason causing the server
    1382      *      to send FTP reply code 421.  This exception may be caught either
    1383      *      as an IOException or independently as itself.
    1384      * @exception IOException  If an I/O error occurs while either sending the
    1385      *      command or receiving the server reply.
    1386      ***/
    1387     public int stat() throws IOException
    1388     {
    1389         return sendCommand(FTPCommand.STAT);
    1390     }
    1391
    1392     /****
    1393      * A convenience method to send the FTP STAT command to the server,
    1394      * receive the reply, and return the reply code.
    1395      * <p>
    1396      * @param pathname  A pathname to list.
    1397      * @return The reply code received from the server.
    1398      * @exception FTPConnectionClosedException
    1399      *      If the FTP server prematurely closes the connection as a result
    1400      *      of the client being idle or some other reason causing the server
    1401      *      to send FTP reply code 421.  This exception may be caught either
    1402      *      as an IOException or independently as itself.
    1403      * @exception IOException  If an I/O error occurs while either sending the
    1404      *      command or receiving the server reply.
    1405      ***/
    1406     public int stat(String pathname) throws IOException
    1407     {
    1408         return sendCommand(FTPCommand.STAT, pathname);
    1409     }
    1410
    1411     /****
    1412      * A convenience method to send the FTP HELP command to the server,
    1413      * receive the reply, and return the reply code.
    1414      * <p>
    1415      * @return The reply code received from the server.
    1416      * @exception FTPConnectionClosedException
    1417      *      If the FTP server prematurely closes the connection as a result
    1418      *      of the client being idle or some other reason causing the server
    1419      *      to send FTP reply code 421.  This exception may be caught either
    1420      *      as an IOException or independently as itself.
    1421      * @exception IOException  If an I/O error occurs while either sending the
    1422      *      command or receiving the server reply.
    1423      ***/
    1424     public int help() throws IOException
    1425     {
    1426         return sendCommand(FTPCommand.HELP);
    1427     }
    1428
    1429     /****
    1430      * A convenience method to send the FTP HELP command to the server,
    1431      * receive the reply, and return the reply code.
    1432      * <p>
    1433      * @param command  The command name on which to request help.
    1434      * @return The reply code received from the server.
    1435      * @exception FTPConnectionClosedException
    1436      *      If the FTP server prematurely closes the connection as a result
    1437      *      of the client being idle or some other reason causing the server
    1438      *      to send FTP reply code 421.  This exception may be caught either
    1439      *      as an IOException or independently as itself.
    1440      * @exception IOException  If an I/O error occurs while either sending the
    1441      *      command or receiving the server reply.
    1442      ***/
    1443     public int help(String command) throws IOException
    1444     {
    1445         return sendCommand(FTPCommand.HELP, command);
    1446     }
    1447
    1448     /****
    1449      * A convenience method to send the FTP NOOP command to the server,
    1450      * receive the reply, and return the reply code.
    1451      * <p>
    1452      * @return The reply code received from the server.
    1453      * @exception FTPConnectionClosedException
    1454      *      If the FTP server prematurely closes the connection as a result
    1455      *      of the client being idle or some other reason causing the server
    1456      *      to send FTP reply code 421.  This exception may be caught either
    1457      *      as an IOException or independently as itself.
    1458      * @exception IOException  If an I/O error occurs while either sending the
    1459      *      command or receiving the server reply.
    1460      ***/
    1461     public int noop() throws IOException
    1462     {
    1463         return sendCommand(FTPCommand.NOOP);
    1464     }
    1465
    1466 }
    1467
    1468 /* Emacs configuration
    1469  * Local variables:        **
    1470  * mode:             java  **
    1471  * c-basic-offset:   4     **
    1472  * indent-tabs-mode: nil   **
    1473  * End:                    **
    1474  */