Coverage report

  %line %branch
org.apache.commons.net.ftp.FTP
0% 
0% 

 1  
 /*
 2  
  * Copyright 2001-2005 The Apache Software Foundation
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *     http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 package org.apache.commons.net.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  0
     {
 248  0
         setDefaultPort(DEFAULT_PORT);
 249  0
         __commandBuffer = new StringBuffer();
 250  0
         _replyLines = new Vector();
 251  0
         _newReplyString = false;
 252  0
         _replyString = null;
 253  0
         _commandSupport_ = new ProtocolCommandSupport(this);
 254  0
         _controlEncoding = DEFAULT_CONTROL_ENCODING;
 255  0
     }
 256  
 
 257  
     private void __getReply() throws IOException
 258  
     {
 259  
         int length;
 260  
 
 261  0
         _newReplyString = true;
 262  0
         _replyLines.setSize(0);
 263  
 
 264  0
         String line = _controlInput.readLine();
 265  
 
 266  0
         if (line == null)
 267  0
             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  0
         length = line.length();
 273  0
         if (length < 3)
 274  0
             throw new MalformedServerReplyException(
 275  
                 "Truncated server reply: " + line);
 276  
 
 277  
         try
 278  
         {
 279  0
             String code = line.substring(0, 3);
 280  0
             _replyCode = Integer.parseInt(code);
 281  
         }
 282  0
         catch (NumberFormatException e)
 283  
         {
 284  0
             throw new MalformedServerReplyException(
 285  
                 "Could not parse response code.\nServer Reply: " + line);
 286  0
         }
 287  
 
 288  0
         _replyLines.addElement(line);
 289  
 
 290  
         // Get extra lines if message continues.
 291  0
         if (length > 3 && line.charAt(3) == '-')
 292  
         {
 293  
             do
 294  
             {
 295  0
                 line = _controlInput.readLine();
 296  
 
 297  0
                 if (line == null)
 298  0
                     throw new FTPConnectionClosedException(
 299  
                         "Connection closed without indication.");
 300  
 
 301  0
                 _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  0
             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  0
         if (_commandSupport_.getListenerCount() > 0)
 318  0
             _commandSupport_.fireReplyReceived(_replyCode, getReplyString());
 319  
 
 320  0
         if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE)
 321  0
             throw new FTPConnectionClosedException(
 322  
                 "FTP response 421 received.  Server closed connection.");
 323  0
     }
 324  
 
 325  
     // initiates control connections and gets initial reply
 326  
     protected void _connectAction_() throws IOException
 327  
     {
 328  0
         super._connectAction_();
 329  0
         _controlInput =
 330  
             new BufferedReader(class="keyword">new InputStreamReader(getInputStream(),
 331  
                                                      getControlEncoding()));
 332  0
         _controlOutput =
 333  
             new BufferedWriter(class="keyword">new OutputStreamWriter(getOutputStream(),
 334  
                                                       getControlEncoding()));
 335  0
         __getReply();
 336  
         // If we received code 120, we have to fetch completion reply.
 337  0
         if (FTPReply.isPositivePreliminary(_replyCode))
 338  0
             __getReply();
 339  0
     }
 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  0
         _controlEncoding = encoding;
 352  0
     }
 353  
 
 354  
 
 355  
     /**
 356  
      * @return The character encoding used to communicate over the
 357  
      * control connection.
 358  
      */
 359  
     public String getControlEncoding() {
 360  0
         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  0
         _commandSupport_.addProtocolCommandListener(listener);
 373  0
     }
 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  0
         _commandSupport_.removeProtocolCommandListener(listener);
 384  0
     }
 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  0
         super.disconnect();
 398  0
         _controlInput = null;
 399  0
         _controlOutput = null;
 400  0
         _replyLines.setSize(0);
 401  0
         _newReplyString = false;
 402  0
         _replyString = null;
 403  0
     }
 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  0
         __commandBuffer.setLength(0);
 431  0
         __commandBuffer.append(command);
 432  
 
 433  0
         if (args != null)
 434  
         {
 435  0
             __commandBuffer.append(' ');
 436  0
             __commandBuffer.append(args);
 437  
         }
 438  0
         __commandBuffer.append(SocketClient.NETASCII_EOL);
 439  
 
 440  
         try{
 441  0
 	    _controlOutput.write(message = __commandBuffer.toString());
 442  0
         _controlOutput.flush();
 443  
         }
 444  0
         catch (SocketException e)
 445  
         {
 446  0
             if (!isConnected() || !socketIsConnected(_socket_))
 447  
             {
 448  0
                 throw new FTPConnectionClosedException("Connection unexpectedly closed.");
 449  
             }
 450  
             else
 451  
             {
 452  0
                 throw e;
 453  
             }
 454  0
         }
 455  
 	
 456  
 
 457  0
         if (_commandSupport_.getListenerCount() > 0)
 458  0
             _commandSupport_.fireCommandSent(command, message);
 459  
 
 460  0
         __getReply();
 461  0
         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  0
         if (socket == null)
 474  
         {
 475  0
             return false;
 476  
         }
 477  
 
 478  
         try
 479  
         {
 480  0
             Method isConnected = socket.getClass().getMethod("isConnected", null);
 481  0
             return ((Boolean) isConnected.invoke(socket, null)).booleanValue();
 482  
         }
 483  0
         catch (NoSuchMethodException e)
 484  
         {
 485  0
             return true;
 486  
         }
 487  0
         catch (IllegalAccessException e)
 488  
         {
 489  0
             return true;
 490  
         }
 491  0
         catch (InvocationTargetException e)
 492  
         {
 493  0
             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(class="keyword">int command, String args) throws IOException
 519  
     {
 520  0
         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  0
         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(class="keyword">int command) throws IOException
 568  
     {
 569  0
         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  0
         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  0
         __getReply();
 606  0
         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  0
         lines = new String[_replyLines.size()];
 621  0
         _replyLines.copyInto(lines);
 622  0
         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  0
         if (!_newReplyString)
 638  0
             return _replyString;
 639  
 
 640  0
         buffer = new StringBuffer(256);
 641  0
         en = _replyLines.elements();
 642  0
         while (en.hasMoreElements())
 643  
         {
 644  0
             buffer.append((String)en.nextElement());
 645  0
             buffer.append(SocketClient.NETASCII_EOL);
 646  
         }
 647  
 
 648  0
         _newReplyString = false;
 649  
 
 650  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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, class="keyword">int port) throws IOException
 837  
     {
 838  
         int num;
 839  0
         StringBuffer info = new StringBuffer(24);
 840  
 
 841  0
         info.append(host.getHostAddress().replace('.', ','));
 842  0
         num = port >>> 8;
 843  0
         info.append(',');
 844  0
         info.append(num);
 845  0
         info.append(',');
 846  0
         num = port & 0xff;
 847  0
         info.append(num);
 848  
 
 849  0
         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  0
         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(class="keyword">int fileType, class="keyword">int formatOrByteSize) throws IOException
 890  
     {
 891  0
         StringBuffer arg = new StringBuffer();
 892  
 
 893  0
         arg.append(__modes.charAt(fileType));
 894  0
         arg.append(' ');
 895  0
         if (fileType == LOCAL_FILE_TYPE)
 896  0
             arg.append(formatOrByteSize);
 897  
         else
 898  0
             arg.append(__modes.charAt(formatOrByteSize));
 899  
 
 900  0
         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(class="keyword">int fileType) throws IOException
 920  
     {
 921  0
         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(class="keyword">int structure) throws IOException
 941  
     {
 942  0
         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(class="keyword">int mode) throws IOException
 962  
     {
 963  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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(class="keyword">int bytes) throws IOException
 1094  
     {
 1095  0
         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(class="keyword">int bytes, class="keyword">int recordSize) throws IOException
 1114  
     {
 1115  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  
  */

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