Coverage report

  %line %branch
org.apache.commons.net.ftp.FTPClient
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.BufferedInputStream;
 18  
 import java.io.BufferedOutputStream;
 19  
 import java.io.BufferedReader;
 20  
 import java.io.IOException;
 21  
 import java.io.InputStream;
 22  
 import java.io.InputStreamReader;
 23  
 import java.io.OutputStream;
 24  
 import java.net.InetAddress;
 25  
 import java.net.ServerSocket;
 26  
 import java.net.Socket;
 27  
 import java.util.Vector;
 28  
 
 29  
 import org.apache.commons.net.MalformedServerReplyException;
 30  
 import org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory;
 31  
 import org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory;
 32  
 import org.apache.commons.net.ftp.parser.ParserInitializationException;
 33  
 import org.apache.commons.net.io.CopyStreamEvent;
 34  
 import org.apache.commons.net.io.CopyStreamException;
 35  
 import org.apache.commons.net.io.FromNetASCIIInputStream;
 36  
 import org.apache.commons.net.io.ToNetASCIIOutputStream;
 37  
 import org.apache.commons.net.io.Util;
 38  
 
 39  
 /***
 40  
  * FTPClient encapsulates all the functionality necessary to store and
 41  
  * retrieve files from an FTP server.  This class takes care of all
 42  
  * low level details of interacting with an FTP server and provides
 43  
  * a convenient higher level interface.  As with all classes derived
 44  
  * from {@link org.apache.commons.net.SocketClient},
 45  
  * you must first connect to the server with
 46  
  * {@link org.apache.commons.net.SocketClient#connect  connect }
 47  
  * before doing anything, and finally
 48  
  * {@link org.apache.commons.net.SocketClient#disconnect  disconnect }
 49  
  * after you're completely finished interacting with the server.
 50  
  * Then you need to check the FTP reply code to see if the connection
 51  
  * was successful.  For example:
 52  
  * <pre>
 53  
  *    boolean error = false;
 54  
  *    try {
 55  
  *      int reply;
 56  
  *      ftp.connect("ftp.foobar.com");
 57  
  *      System.out.println("Connected to " + server + ".");
 58  
  *      System.out.print(ftp.getReplyString());
 59  
  *
 60  
  *      // After connection attempt, you should check the reply code to verify
 61  
  *      // success.
 62  
  *      reply = ftp.getReplyCode();
 63  
  *
 64  
  *      if(!FTPReply.isPositiveCompletion(reply)) {
 65  
  *        ftp.disconnect();
 66  
  *        System.err.println("FTP server refused connection.");
 67  
  *        System.exit(1);
 68  
  *      }
 69  
  *      ... // transfer files
 70  
  *      ftp.logout();
 71  
  *    } catch(IOException e) {
 72  
  *      error = true;
 73  
  *      e.printStackTrace();
 74  
  *    } finally {
 75  
  *      if(ftp.isConnected()) {
 76  
  *        try {
 77  
  *          ftp.disconnect();
 78  
  *        } catch(IOException ioe) {
 79  
  *          // do nothing
 80  
  *        }
 81  
  *      }
 82  
  *      System.exit(error ? 1 : 0);
 83  
  *    }
 84  
  * </pre>
 85  
  * <p>
 86  
  * Immediately after connecting is the only real time you need to check the
 87  
  * reply code (because connect is of type void).  The convention for all the
 88  
  * FTP command methods in FTPClient is such that they either return a
 89  
  * boolean value or some other value.
 90  
  * The boolean methods return true on a successful completion reply from
 91  
  * the FTP server and false on a reply resulting in an error condition or
 92  
  * failure.  The methods returning a value other than boolean return a value
 93  
  * containing the higher level data produced by the FTP command, or null if a
 94  
  * reply resulted in an error condition or failure.  If you want to access
 95  
  * the exact FTP reply code causing a success or failure, you must call
 96  
  * {@link org.apache.commons.net.ftp.FTP#getReplyCode  getReplyCode } after
 97  
  * a success or failure.
 98  
  * <p>
 99  
  * The default settings for FTPClient are for it to use
 100  
  * <code> FTP.ASCII_FILE_TYPE </code>,
 101  
  * <code> FTP.NON_PRINT_TEXT_FORMAT </code>,
 102  
  * <code> FTP.STREAM_TRANSFER_MODE </code>, and
 103  
  * <code> FTP.FILE_STRUCTURE </code>.  The only file types directly supported
 104  
  * are <code> FTP.ASCII_FILE_TYPE </code> and
 105  
  * <code> FTP.IMAGE_FILE_TYPE </code> (which is the same as
 106  
  * <code> FTP.BINARY_FILE_TYPE </code>).  Because there are at lest 4
 107  
  * different EBCDIC encodings, we have opted not to provide direct support
 108  
  * for EBCDIC.  To transfer EBCDIC and other unsupported file types you
 109  
  * must create your own filter InputStreams and OutputStreams and wrap
 110  
  * them around the streams returned or required by the FTPClient methods.
 111  
  * FTPClient uses the {@link ToNetASCIIOutputStream NetASCII}  
 112  
  * filter streams to provide transparent handling of ASCII files.  We will 
 113  
  * consider incorporating EBCDIC support if there is enough demand.
 114  
  * <p>
 115  
  * <code> FTP.NON_PRINT_TEXT_FORMAT </code>,
 116  
  * <code> FTP.STREAM_TRANSFER_MODE </code>, and
 117  
  * <code> FTP.FILE_STRUCTURE </code> are the only supported formats,
 118  
  * transfer modes, and file structures.
 119  
  * <p>
 120  
  * Because the handling of sockets on different platforms can differ
 121  
  * significantly, the FTPClient automatically issues a new PORT command
 122  
  * prior to every transfer requiring that the server connect to the client's
 123  
  * data port.  This ensures identical problem-free behavior on Windows, Unix,
 124  
  * and Macintosh platforms.  Additionally, it relieves programmers from
 125  
  * having to issue the PORT command themselves and dealing with platform
 126  
  * dependent issues.
 127  
  * <p>
 128  
  * Additionally, for security purposes, all data connections to the
 129  
  * client are verified to ensure that they originated from the intended
 130  
  * party (host and port).  If a data connection is initiated by an unexpected
 131  
  * party, the command will close the socket and throw an IOException.  You
 132  
  * may disable this behavior with
 133  
  * {@link #setRemoteVerificationEnabled setRemoteVerificationEnabled()}.
 134  
  * <p>
 135  
  * You should keep in mind that the FTP server may choose to prematurely
 136  
  * close a connection if the client has been idle for longer than a
 137  
  * given time period (usually 900 seconds).  The FTPClient class will detect a
 138  
  * premature FTP server connection closing when it receives a
 139  
  * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
 140  
  *  response to a command.
 141  
  * When that occurs, the FTP class method encountering that reply will throw
 142  
  * an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
 143  
  * .
 144  
  * <code>FTPConnectionClosedException</code>
 145  
  * is a subclass of <code> IOException </code> and therefore need not be
 146  
  * caught separately, but if you are going to catch it separately, its
 147  
  * catch block must appear before the more general <code> IOException </code>
 148  
  * catch block.  When you encounter an
 149  
  * {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
 150  
  * , you must disconnect the connection with
 151  
  * {@link #disconnect  disconnect() } to properly clean up the
 152  
  * system resources used by FTPClient.  Before disconnecting, you may check the
 153  
  * last reply code and text with
 154  
  * {@link org.apache.commons.net.ftp.FTP#getReplyCode  getReplyCode },
 155  
  * {@link org.apache.commons.net.ftp.FTP#getReplyString  getReplyString },
 156  
  * and
 157  
  * {@link org.apache.commons.net.ftp.FTP#getReplyStrings  getReplyStrings}.
 158  
  * You may avoid server disconnections while the client is idle by
 159  
  * periodicaly sending NOOP commands to the server.
 160  
  * <p>
 161  
  * Rather than list it separately for each method, we mention here that
 162  
  * every method communicating with the server and throwing an IOException
 163  
  * can also throw a
 164  
  * {@link org.apache.commons.net.MalformedServerReplyException}
 165  
  * , which is a subclass
 166  
  * of IOException.  A MalformedServerReplyException will be thrown when
 167  
  * the reply received from the server deviates enough from the protocol
 168  
  * specification that it cannot be interpreted in a useful manner despite
 169  
  * attempts to be as lenient as possible.
 170  
  * <p>
 171  
  * Listing API Examples
 172  
  * Both paged and unpaged examples of directory listings are available,
 173  
  * as follows:
 174  
  * <p>
 175  
  * Unpaged (whole list) access, using a parser accessible by auto-detect:
 176  
  * <pre>
 177  
  *    FTPClient f=FTPClient();
 178  
  *    f.connect(server);
 179  
  *    f.login(username, password);
 180  
  *    FTPFile[] files = listFiles(directory);
 181  
  * </pre>
 182  
  * <p>
 183  
  * Paged access, using a parser not accessible by auto-detect.  The class
 184  
  * defined in the first parameter of initateListParsing should be derived
 185  
  * from org.apache.commons.net.FTPFileEntryParser:
 186  
  * <pre>
 187  
  *    FTPClient f=FTPClient();
 188  
  *    f.connect(server);
 189  
  *    f.login(username, password);
 190  
  *    FTPListParseEngine engine =
 191  
  *       f.initiateListParsing("com.whatever.YourOwnParser", directory);
 192  
  *
 193  
  *    while (engine.hasNext()) {
 194  
  *       FTPFile[] files = engine.getNext(25);  // "page size" you want
 195  
  *       //do whatever you want with these files, display them, etc.
 196  
  *       //expensive FTPFile objects not created until needed.
 197  
  *    }
 198  
  * </pre>
 199  
  * <p>
 200  
  * Paged access, using a parser accessible by auto-detect:
 201  
  * <pre>
 202  
  *    FTPClient f=FTPClient();
 203  
  *    f.connect(server);
 204  
  *    f.login(username, password);
 205  
  *    FTPListParseEngine engine = f.initiateListParsing(directory);
 206  
  *
 207  
  *    while (engine.hasNext()) {
 208  
  *       FTPFile[] files = engine.getNext(25);  // "page size" you want
 209  
  *       //do whatever you want with these files, display them, etc.
 210  
  *       //expensive FTPFile objects not created until needed.
 211  
  *    }
 212  
  * </pre>
 213  
  * <p>
 214  
  * For examples of using FTPClient on servers whose directory listings 
 215  
  * <ul> 
 216  
  * <li>use languages other than English</li>
 217  
  * <li>use date formats other than the American English "standard" <code>MM d yyyy</code></li>
 218  
  * <li>are in different timezones and you need accurate timestamps for dependency checking 
 219  
  *     as in Ant</li>
 220  
  * </ul>see {@link  FTPClientConfig  FTPClientConfig}.
 221  
  * <p>
 222  
  * NOTE: If you experience problems with unwanted firing of <pre>setSoTimeout()</pre> 
 223  
  * during periods of client inactivity, this can be alleviated by calling <pre>setReaderThread(false)</pre>.
 224  
  * For more details, see <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=31122">this thread</a>. 
 225  
  * </p>
 226  
  * <p> 
 227  
  * @author Daniel F. Savarese
 228  
  * @see FTP
 229  
  * @see FTPConnectionClosedException
 230  
  * @see FTPFileEntryParser
 231  
  * @see FTPFileEntryParserFactory
 232  
  * @see DefaultFTPFileEntryParserFactory
 233  
  * @see FTPClientConfig
 234  
  * @see org.apache.commons.net.MalformedServerReplyException
 235  
  **/
 236  
 public class FTPClient extends FTP
 237  
 implements Configurable
 238  
 {
 239  
     /***
 240  
      * A constant indicating the FTP session is expecting all transfers
 241  
      * to occur between the client (local) and server and that the server
 242  
      * should connect to the client's data port to initiate a data transfer.
 243  
      * This is the default data connection mode when and FTPClient instance
 244  
      * is created.
 245  
      ***/
 246  
     public static final int ACTIVE_LOCAL_DATA_CONNECTION_MODE = 0;
 247  
     /***
 248  
      * A constant indicating the FTP session is expecting all transfers
 249  
      * to occur between two remote servers and that the server
 250  
      * the client is connected to should connect to the other server's
 251  
      * data port to initiate a data transfer.
 252  
      ***/
 253  
     public static final int ACTIVE_REMOTE_DATA_CONNECTION_MODE = 1;
 254  
     /***
 255  
      * A constant indicating the FTP session is expecting all transfers
 256  
      * to occur between the client (local) and server and that the server
 257  
      * is in passive mode, requiring the client to connect to the
 258  
      * server's data port to initiate a transfer.
 259  
      ***/
 260  
     public static final int PASSIVE_LOCAL_DATA_CONNECTION_MODE = 2;
 261  
     /***
 262  
      * A constant indicating the FTP session is expecting all transfers
 263  
      * to occur between two remote servers and that the server
 264  
      * the client is connected to is in passive mode, requiring the other
 265  
      * server to connect to the first server's data port to initiate a data
 266  
      * transfer.
 267  
      ***/
 268  
     public static final int PASSIVE_REMOTE_DATA_CONNECTION_MODE = 3;
 269  
 
 270  
     private int __dataConnectionMode, __dataTimeout;
 271  
     private int __passivePort;
 272  
     private String __passiveHost;
 273  
     private int __fileType, __fileFormat, __fileStructure, __fileTransferMode;
 274  
     private boolean __remoteVerificationEnabled;
 275  
     private long __restartOffset;
 276  
     private FTPFileEntryParserFactory __parserFactory;
 277  
     private int __bufferSize;
 278  
 
 279  
     // __systemName is a cached value that should not be referenced directly
 280  
     // except when assigned in getSystemName and __initDefaults.
 281  
     private String __systemName;
 282  
 
 283  
     // __entryParser is a cached value that should not be referenced directly
 284  
     // except when assigned in listFiles(String, String) and __initDefaults.
 285  
     private FTPFileEntryParser __entryParser;
 286  
     
 287  
     private FTPClientConfig __configuration;
 288  
 
 289  
     /***
 290  
      * Default FTPClient constructor.  Creates a new FTPClient instance
 291  
      * with the data connection mode set to
 292  
      * <code> ACTIVE_LOCAL_DATA_CONNECTION_MODE </code>, the file type
 293  
      * set to <code> FTP.ASCII_FILE_TYPE </code>, the
 294  
      * file format set to <code> FTP.NON_PRINT_TEXT_FORMAT </code>,
 295  
      * the file structure set to <code> FTP.FILE_STRUCTURE </code>, and
 296  
      * the transfer mode set to <code> FTP.STREAM_TRANSFER_MODE </code>.
 297  
      ***/
 298  
     public FTPClient()
 299  0
     {
 300  0
         __initDefaults();
 301  0
         __dataTimeout = -1;
 302  0
         __remoteVerificationEnabled = true;
 303  0
         __parserFactory = new DefaultFTPFileEntryParserFactory();
 304  0
         __configuration      = null;
 305  0
     }
 306  
 
 307  
 
 308  
     private void __initDefaults()
 309  
     {
 310  0
         __dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE;
 311  0
         __passiveHost        = null;
 312  0
         __passivePort        = -1;
 313  0
         __fileType           = FTP.ASCII_FILE_TYPE;
 314  0
         __fileStructure      = FTP.FILE_STRUCTURE;
 315  0
         __fileFormat         = FTP.NON_PRINT_TEXT_FORMAT;
 316  0
         __fileTransferMode   = FTP.STREAM_TRANSFER_MODE;
 317  0
         __restartOffset      = 0;
 318  0
         __systemName         = null;
 319  0
         __entryParser        = null;
 320  0
         __bufferSize 		 = Util.DEFAULT_COPY_BUFFER_SIZE;
 321  0
     }
 322  
     
 323  
     private String __parsePathname(String reply)
 324  
     {
 325  
         int begin, end;
 326  
 
 327  0
         begin = reply.indexOf('"') + 1;
 328  0
         end = reply.indexOf('"', begin);
 329  
 
 330  0
         return reply.substring(begin, end);
 331  
     }
 332  
 
 333  
 
 334  
     private void __parsePassiveModeReply(String reply)
 335  
     throws MalformedServerReplyException
 336  
     {
 337  
         int i, index, lastIndex;
 338  
         String octet1, octet2;
 339  
         StringBuffer host;
 340  
 
 341  0
         reply = reply.substring(reply.indexOf('(') + 1,
 342  
                                 reply.indexOf(')')).trim();
 343  
 
 344  0
         host = new StringBuffer(24);
 345  0
         lastIndex = 0;
 346  0
         index = reply.indexOf(',');
 347  0
         host.append(reply.substring(lastIndex, index));
 348  
 
 349  0
         for (i = 0; i < 3; i++)
 350  
         {
 351  0
             host.append('.');
 352  0
             lastIndex = index + 1;
 353  0
             index = reply.indexOf(',', lastIndex);
 354  0
             host.append(reply.substring(lastIndex, index));
 355  
         }
 356  
 
 357  0
         lastIndex = index + 1;
 358  0
         index = reply.indexOf(',', lastIndex);
 359  
 
 360  0
         octet1 = reply.substring(lastIndex, index);
 361  0
         octet2 = reply.substring(index + 1);
 362  
 
 363  
         // index and lastIndex now used as temporaries
 364  
         try
 365  
         {
 366  0
             index = Integer.parseInt(octet1);
 367  0
             lastIndex = Integer.parseInt(octet2);
 368  
         }
 369  0
         catch (NumberFormatException e)
 370  
         {
 371  0
             throw new MalformedServerReplyException(
 372  
                 "Could not parse passive host information.\nServer Reply: " + reply);
 373  0
         }
 374  
 
 375  0
         index <<= 8;
 376  0
         index |= lastIndex;
 377  
 
 378  0
         __passiveHost = host.toString();
 379  0
         __passivePort = index;
 380  0
     }
 381  
 
 382  
     private boolean __storeFile(int command, String remote, InputStream local)
 383  
     throws IOException
 384  
     {
 385  
         OutputStream output;
 386  
         Socket socket;
 387  
 
 388  0
         if ((socket = _openDataConnection_(command, remote)) == null)
 389  0
             return false;
 390  
 
 391  0
         output = new BufferedOutputStream(socket.getOutputStream(),
 392  
                                           getBufferSize()
 393  
                                           );
 394  0
         if (__fileType == ASCII_FILE_TYPE)
 395  0
             output = new ToNetASCIIOutputStream(output);
 396  
         // Treat everything else as binary for now
 397  
         try
 398  
         {
 399  0
             Util.copyStream(local, output, getBufferSize(),
 400  
                             CopyStreamEvent.UNKNOWN_STREAM_SIZE, null,
 401  
                             false);
 402  
         }
 403  0
         catch (IOException e)
 404  
         {
 405  
             try
 406  
             {
 407  0
                 socket.close();
 408  
             }
 409  0
             catch (IOException f)
 410  0
             {}
 411  0
             throw e;
 412  0
         }
 413  0
         output.close();
 414  0
         socket.close();
 415  0
         return completePendingCommand();
 416  
     }
 417  
 
 418  
     private OutputStream __storeFileStream(int command, String remote)
 419  
     throws IOException
 420  
     {
 421  
         OutputStream output;
 422  
         Socket socket;
 423  
 
 424  0
         if ((socket = _openDataConnection_(command, remote)) == null)
 425  0
             return null;
 426  
 
 427  0
         output = socket.getOutputStream();
 428  0
         if (__fileType == ASCII_FILE_TYPE) {
 429  
           // We buffer ascii transfers because the buffering has to
 430  
           // be interposed between ToNetASCIIOutputSream and the underlying
 431  
           // socket output stream.  We don't buffer binary transfers
 432  
           // because we don't want to impose a buffering policy on the
 433  
           // programmer if possible.  Programmers can decide on their
 434  
           // own if they want to wrap the SocketOutputStream we return
 435  
           // for file types other than ASCII.
 436  0
           output = new BufferedOutputStream(output,
 437  
                                             getBufferSize());
 438  0
           output = new ToNetASCIIOutputStream(output);
 439  
 
 440  
         }
 441  0
         return new org.apache.commons.net.io.SocketOutputStream(socket, output);
 442  
     }
 443  
 
 444  
 
 445  
     /**
 446  
      * Establishes a data connection with the FTP server, returning
 447  
      * a Socket for the connection if successful.  If a restart
 448  
      * offset has been set with {@link #setRestartOffset(long)},
 449  
      * a REST command is issued to the server with the offset as
 450  
      * an argument before establishing the data connection.  Active
 451  
      * mode connections also cause a local PORT command to be issued.
 452  
      * <p>
 453  
      * @param command  The text representation of the FTP command to send.
 454  
      * @param arg The arguments to the FTP command.  If this parameter is
 455  
      *             set to null, then the command is sent with no argument.
 456  
      * @return A Socket corresponding to the established data connection.
 457  
      *         Null is returned if an FTP protocol error is reported at
 458  
      *         any point during the establishment and initialization of
 459  
      *         the connection.
 460  
      * @exception IOException  If an I/O error occurs while either sending a
 461  
      *      command to the server or receiving a reply from the server.
 462  
      */
 463  
     protected Socket _openDataConnection_(int command, String arg)
 464  
       throws IOException
 465  
     {
 466  
         Socket socket;
 467  
 
 468  0
         if (__dataConnectionMode != ACTIVE_LOCAL_DATA_CONNECTION_MODE &&
 469  
                 __dataConnectionMode != PASSIVE_LOCAL_DATA_CONNECTION_MODE)
 470  0
             return null;
 471  
 
 472  0
         if (__dataConnectionMode == ACTIVE_LOCAL_DATA_CONNECTION_MODE)
 473  
         {
 474  
             ServerSocket server;
 475  0
             server = _socketFactory_.createServerSocket(0, 1, getLocalAddress());
 476  
 
 477  0
             if (!FTPReply.isPositiveCompletion(port(getLocalAddress(),
 478  
                                                     server.getLocalPort())))
 479  
             {
 480  0
                 server.close();
 481  0
                 return null;
 482  
             }
 483  
 
 484  0
             if ((__restartOffset > 0) && !restart(__restartOffset))
 485  
             {
 486  0
                 server.close();
 487  0
                 return null;
 488  
             }
 489  
 
 490  0
             if (!FTPReply.isPositivePreliminary(sendCommand(command, arg)))
 491  
             {
 492  0
                 server.close();
 493  0
                 return null;
 494  
             }
 495  
 
 496  
             // For now, let's just use the data timeout value for waiting for
 497  
             // the data connection.  It may be desirable to let this be a
 498  
             // separately configurable value.  In any case, we really want
 499  
             // to allow preventing the accept from blocking indefinitely.
 500  0
             if (__dataTimeout >= 0)
 501  0
                 server.setSoTimeout(__dataTimeout);
 502  0
             socket = server.accept();
 503  0
             server.close();
 504  
         }
 505  
         else
 506  
         { // We must be in PASSIVE_LOCAL_DATA_CONNECTION_MODE
 507  
 
 508  0
             if (pasv() != FTPReply.ENTERING_PASSIVE_MODE)
 509  0
                 return null;
 510  
 
 511  0
             __parsePassiveModeReply((String)_replyLines.elementAt(0));
 512  
 
 513  0
             socket = _socketFactory_.createSocket(__passiveHost, __passivePort);
 514  0
             if ((__restartOffset > 0) && !restart(__restartOffset))
 515  
             {
 516  0
                 socket.close();
 517  0
                 return null;
 518  
             }
 519  
 
 520  0
             if (!FTPReply.isPositivePreliminary(sendCommand(command, arg)))
 521  
             {
 522  0
                 socket.close();
 523  0
                 return null;
 524  
             }
 525  
         }
 526  
 
 527  0
         if (__remoteVerclass="keyword">ificationEnabled && !verclass="keyword">ifyRemote(socket))
 528  
         {
 529  
             InetAddress host1, host2;
 530  
 
 531  0
             host1 = socket.getInetAddress();
 532  0
             host2 = getRemoteAddress();
 533  
 
 534  0
             socket.close();
 535  
 
 536  0
             throw new IOException(
 537  
                 "Host attempting data connection " + host1.getHostAddress() +
 538  
                 " is not same as server " + host2.getHostAddress());
 539  
         }
 540  
 
 541  0
         if (__dataTimeout >= 0)
 542  0
             socket.setSoTimeout(__dataTimeout);
 543  
 
 544  0
         return socket;
 545  
     }
 546  
 
 547  
 
 548  
     protected void _connectAction_() throws IOException
 549  
     {
 550  0
         super._connectAction_();
 551  0
         __initDefaults();
 552  0
     }
 553  
 
 554  
 
 555  
     /***
 556  
      * Sets the timeout in milliseconds to use when reading from the
 557  
      * data connection.  This timeout will be set immediately after
 558  
      * opening the data connection.
 559  
      * <p>
 560  
      * @param  timeout The default timeout in milliseconds that is used when
 561  
      *        opening a data connection socket.
 562  
      ***/
 563  
     public void setDataTimeout(int timeout)
 564  
     {
 565  0
         __dataTimeout = timeout;
 566  0
     }
 567  
 
 568  
     /**
 569  
      * set the factory used for parser creation to the supplied factory object.
 570  
      *
 571  
      * @param parserFactory
 572  
      *               factory object used to create FTPFileEntryParsers
 573  
      *
 574  
      * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
 575  
      * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
 576  
      */
 577  
     public void setParserFactory(FTPFileEntryParserFactory parserFactory) {
 578  0
         __parserFactory = parserFactory;
 579  0
     }
 580  
 
 581  
 
 582  
     /***
 583  
      * Closes the connection to the FTP server and restores
 584  
      * connection parameters to the default values.
 585  
      * <p>
 586  
      * @exception IOException If an error occurs while disconnecting.
 587  
      ***/
 588  
     public void disconnect() throws IOException
 589  
     {
 590  0
         super.disconnect();
 591  0
         __initDefaults();
 592  0
     }
 593  
 
 594  
 
 595  
     /***
 596  
      * Enable or disable verification that the remote host taking part
 597  
      * of a data connection is the same as the host to which the control
 598  
      * connection is attached.  The default is for verification to be
 599  
      * enabled.  You may set this value at any time, whether the
 600  
      * FTPClient is currently connected or not.
 601  
      * <p>
 602  
      * @param enable True to enable verification, false to disable verification.
 603  
      ***/
 604  
     public void setRemoteVerificationEnabled(boolean enable)
 605  
     {
 606  0
         __remoteVerificationEnabled = enable;
 607  0
     }
 608  
 
 609  
     /***
 610  
      * Return whether or not verification of the remote host participating
 611  
      * in data connections is enabled.  The default behavior is for
 612  
      * verification to be enabled.
 613  
      * <p>
 614  
      * @return True if verification is enabled, false if not.
 615  
      ***/
 616  
     public boolean isRemoteVerificationEnabled()
 617  
     {
 618  0
         return __remoteVerificationEnabled;
 619  
     }
 620  
 
 621  
     /***
 622  
      * Login to the FTP server using the provided username and password.
 623  
      * <p>
 624  
      * @param username The username to login under.
 625  
      * @param password The password to use.
 626  
      * @return True if successfully completed, false if not.
 627  
      * @exception FTPConnectionClosedException
 628  
      *      If the FTP server prematurely closes the connection as a result
 629  
      *      of the client being idle or some other reason causing the server
 630  
      *      to send FTP reply code 421.  This exception may be caught either
 631  
      *      as an IOException or independently as itself.
 632  
      * @exception IOException  If an I/O error occurs while either sending a
 633  
      *      command to the server or receiving a reply from the server.
 634  
      ***/
 635  
     public boolean login(String username, String password) throws IOException
 636  
     {
 637  0
         user(username);
 638  
 
 639  0
         if (FTPReply.isPositiveCompletion(_replyCode))
 640  0
             return true;
 641  
 
 642  
         // If we get here, we either have an error code, or an intermmediate
 643  
         // reply requesting password.
 644  0
         if (!FTPReply.isPositiveIntermediate(_replyCode))
 645  0
             return false;
 646  
 
 647  0
         return FTPReply.isPositiveCompletion(pass(password));
 648  
     }
 649  
 
 650  
 
 651  
     /***
 652  
      * Login to the FTP server using the provided username, password,
 653  
      * and account.  If no account is required by the server, only
 654  
      * the username and password, the account information is not used.
 655  
      * <p>
 656  
      * @param username The username to login under.
 657  
      * @param password The password to use.
 658  
      * @param account  The account to use.
 659  
      * @return True if successfully completed, false if not.
 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 a
 666  
      *      command to the server or receiving a reply from the server.
 667  
      ***/
 668  
     public boolean login(String username, String password, String account)
 669  
     throws IOException
 670  
     {
 671  0
         user(username);
 672  
 
 673  0
         if (FTPReply.isPositiveCompletion(_replyCode))
 674  0
             return true;
 675  
 
 676  
         // If we get here, we either have an error code, or an intermmediate
 677  
         // reply requesting password.
 678  0
         if (!FTPReply.isPositiveIntermediate(_replyCode))
 679  0
             return false;
 680  
 
 681  0
         pass(password);
 682  
 
 683  0
         if (FTPReply.isPositiveCompletion(_replyCode))
 684  0
             return true;
 685  
 
 686  0
         if (!FTPReply.isPositiveIntermediate(_replyCode))
 687  0
             return false;
 688  
 
 689  0
         return FTPReply.isPositiveCompletion(acct(account));
 690  
     }
 691  
 
 692  
     /***
 693  
      * Logout of the FTP server by sending the QUIT command.
 694  
      * <p>
 695  
      * @return True if successfully completed, false if not.
 696  
      * @exception FTPConnectionClosedException
 697  
      *      If the FTP server prematurely closes the connection as a result
 698  
      *      of the client being idle or some other reason causing the server
 699  
      *      to send FTP reply code 421.  This exception may be caught either
 700  
      *      as an IOException or independently as itself.
 701  
      * @exception IOException  If an I/O error occurs while either sending a
 702  
      *      command to the server or receiving a reply from the server.
 703  
      ***/
 704  
     public boolean logout() throws IOException
 705  
     {
 706  0
         return FTPReply.isPositiveCompletion(quit());
 707  
     }
 708  
 
 709  
 
 710  
     /***
 711  
      * Change the current working directory of the FTP session.
 712  
      * <p>
 713  
      * @param pathname  The new current working directory.
 714  
      * @return True if successfully completed, false if not.
 715  
      * @exception FTPConnectionClosedException
 716  
      *      If the FTP server prematurely closes the connection as a result
 717  
      *      of the client being idle or some other reason causing the server
 718  
      *      to send FTP reply code 421.  This exception may be caught either
 719  
      *      as an IOException or independently as itself.
 720  
      * @exception IOException  If an I/O error occurs while either sending a
 721  
      *      command to the server or receiving a reply from the server.
 722  
      ***/
 723  
     public boolean changeWorkingDirectory(String pathname) throws IOException
 724  
     {
 725  0
         return FTPReply.isPositiveCompletion(cwd(pathname));
 726  
     }
 727  
 
 728  
 
 729  
     /***
 730  
      * Change to the parent directory of the current working directory.
 731  
      * <p>
 732  
      * @return True if successfully completed, false if not.
 733  
      * @exception FTPConnectionClosedException
 734  
      *      If the FTP server prematurely closes the connection as a result
 735  
      *      of the client being idle or some other reason causing the server
 736  
      *      to send FTP reply code 421.  This exception may be caught either
 737  
      *      as an IOException or independently as itself.
 738  
      * @exception IOException  If an I/O error occurs while either sending a
 739  
      *      command to the server or receiving a reply from the server.
 740  
      ***/
 741  
     public boolean changeToParentDirectory() throws IOException
 742  
     {
 743  0
         return FTPReply.isPositiveCompletion(cdup());
 744  
     }
 745  
 
 746  
 
 747  
     /***
 748  
      * Issue the FTP SMNT command.
 749  
      * <p>
 750  
      * @param pathname The pathname to mount.
 751  
      * @return True if successfully completed, false if not.
 752  
      * @exception FTPConnectionClosedException
 753  
      *      If the FTP server prematurely closes the connection as a result
 754  
      *      of the client being idle or some other reason causing the server
 755  
      *      to send FTP reply code 421.  This exception may be caught either
 756  
      *      as an IOException or independently as itself.
 757  
      * @exception IOException  If an I/O error occurs while either sending a
 758  
      *      command to the server or receiving a reply from the server.
 759  
      ***/
 760  
     public boolean structureMount(String pathname) throws IOException
 761  
     {
 762  0
         return FTPReply.isPositiveCompletion(smnt(pathname));
 763  
     }
 764  
 
 765  
     /***
 766  
      * Reinitialize the FTP session.  Not all FTP servers support this
 767  
      * command, which issues the FTP REIN command.
 768  
      * <p>
 769  
      * @return True if successfully completed, false if not.
 770  
      * @exception FTPConnectionClosedException
 771  
      *      If the FTP server prematurely closes the connection as a result
 772  
      *      of the client being idle or some other reason causing the server
 773  
      *      to send FTP reply code 421.  This exception may be caught either
 774  
      *      as an IOException or independently as itself.
 775  
      * @exception IOException  If an I/O error occurs while either sending a
 776  
      *      command to the server or receiving a reply from the server.
 777  
      ***/
 778  
     boolean reinitialize() throws IOException
 779  
     {
 780  0
         rein();
 781  
 
 782  0
         if (FTPReply.isPositiveCompletion(_replyCode) ||
 783  
                 (FTPReply.isPositivePreliminary(_replyCode) &&
 784  
                  FTPReply.isPositiveCompletion(getReply())))
 785  
         {
 786  
 
 787  0
             __initDefaults();
 788  
 
 789  0
             return true;
 790  
         }
 791  
 
 792  0
         return false;
 793  
     }
 794  
 
 795  
 
 796  
     /***
 797  
      * Set the current data connection mode to
 798  
      * <code>ACTIVE_LOCAL_DATA_CONNECTION_MODE</code>.  No communication
 799  
      * with the FTP server is conducted, but this causes all future data
 800  
      * transfers to require the FTP server to connect to the client's
 801  
      * data port.  Additionally, to accommodate differences between socket
 802  
      * implementations on different platforms, this method causes the
 803  
      * client to issue a PORT command before every data transfer.
 804  
      ***/
 805  
     public void enterLocalActiveMode()
 806  
     {
 807  0
         __dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE;
 808  0
         __passiveHost = null;
 809  0
         __passivePort = -1;
 810  0
     }
 811  
 
 812  
 
 813  
     /***
 814  
      * Set the current data connection mode to
 815  
      * <code> PASSIVE_LOCAL_DATA_CONNECTION_MODE </code>.  Use this
 816  
      * method only for data transfers between the client and server.
 817  
      * This method causes a PASV command to be issued to the server
 818  
      * before the opening of every data connection, telling the server to
 819  
      * open a data port to which the client will connect to conduct
 820  
      * data transfers.  The FTPClient will stay in
 821  
      * <code> PASSIVE_LOCAL_DATA_CONNECTION_MODE </code> until the
 822  
      * mode is changed by calling some other method such as
 823  
      * {@link #enterLocalActiveMode  enterLocalActiveMode() }
 824  
      ***/
 825  
     public void enterLocalPassiveMode()
 826  
     {
 827  0
         __dataConnectionMode = PASSIVE_LOCAL_DATA_CONNECTION_MODE;
 828  
         // These will be set when just before a data connection is opened
 829  
         // in _openDataConnection_()
 830  0
         __passiveHost = null;
 831  0
         __passivePort = -1;
 832  0
     }
 833  
 
 834  
 
 835  
     /***
 836  
      * Set the current data connection mode to
 837  
      * <code> ACTIVE_REMOTE_DATA_CONNECTION </code>.  Use this method only
 838  
      * for server to server data transfers.  This method issues a PORT
 839  
      * command to the server, indicating the other server and port to which
 840  
      * it should connect for data transfers.  You must call this method
 841  
      * before EVERY server to server transfer attempt.  The FTPClient will
 842  
      * NOT automatically continue to issue PORT commands.  You also
 843  
      * must remember to call
 844  
      * {@link #enterLocalActiveMode  enterLocalActiveMode() } if you
 845  
      * wish to return to the normal data connection mode.
 846  
      * <p>
 847  
      * @param host The passive mode server accepting connections for data
 848  
      *             transfers.
 849  
      * @param port The passive mode server's data port.
 850  
      * @return True if successfully completed, false if not.
 851  
      * @exception FTPConnectionClosedException
 852  
      *      If the FTP server prematurely closes the connection as a result
 853  
      *      of the client being idle or some other reason causing the server
 854  
      *      to send FTP reply code 421.  This exception may be caught either
 855  
      *      as an IOException or independently as itself.
 856  
      * @exception IOException  If an I/O error occurs while either sending a
 857  
      *      command to the server or receiving a reply from the server.
 858  
      ***/
 859  
     public boolean enterRemoteActiveMode(InetAddress host, int port)
 860  
     throws IOException
 861  
     {
 862  0
         if (FTPReply.isPositiveCompletion(port(host, port)))
 863  
         {
 864  0
             __dataConnectionMode = ACTIVE_REMOTE_DATA_CONNECTION_MODE;
 865  0
             __passiveHost = null;
 866  0
             __passivePort = -1;
 867  0
             return true;
 868  
         }
 869  0
         return false;
 870  
     }
 871  
 
 872  
     /***
 873  
      * Set the current data connection mode to
 874  
      * <code> PASSIVE_REMOTE_DATA_CONNECTION_MODE </code>.  Use this
 875  
      * method only for server to server data transfers.
 876  
      * This method issues a PASV command to the server, telling it to
 877  
      * open a data port to which the active server will connect to conduct
 878  
      * data transfers.  You must call this method
 879  
      * before EVERY server to server transfer attempt.  The FTPClient will
 880  
      * NOT automatically continue to issue PASV commands.  You also
 881  
      * must remember to call
 882  
      * {@link #enterLocalActiveMode  enterLocalActiveMode() } if you
 883  
      * wish to return to the normal data connection mode.
 884  
      * <p>
 885  
      * @return True if successfully completed, false if not.
 886  
      * @exception FTPConnectionClosedException
 887  
      *      If the FTP server prematurely closes the connection as a result
 888  
      *      of the client being idle or some other reason causing the server
 889  
      *      to send FTP reply code 421.  This exception may be caught either
 890  
      *      as an IOException or independently as itself.
 891  
      * @exception IOException  If an I/O error occurs while either sending a
 892  
      *      command to the server or receiving a reply from the server.
 893  
      ***/
 894  
     public boolean enterRemotePassiveMode() throws IOException
 895  
     {
 896  0
         if (pasv() != FTPReply.ENTERING_PASSIVE_MODE)
 897  0
             return false;
 898  
 
 899  0
         __dataConnectionMode = PASSIVE_REMOTE_DATA_CONNECTION_MODE;
 900  0
         __parsePassiveModeReply((String)_replyLines.elementAt(0));
 901  
 
 902  0
         return true;
 903  
     }
 904  
 
 905  
     /***
 906  
      * Returns the hostname or IP address (in the form of a string) returned
 907  
      * by the server when entering passive mode.  If not in passive mode,
 908  
      * returns null.  This method only returns a valid value AFTER a
 909  
      * data connection has been opened after a call to
 910  
      * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
 911  
      * This is because FTPClient sends a PASV command to the server only
 912  
      * just before opening a data connection, and not when you call
 913  
      * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
 914  
      * <p>
 915  
      * @return The passive host name if in passive mode, otherwise null.
 916  
      ***/
 917  
     public String getPassiveHost()
 918  
     {
 919  0
         return __passiveHost;
 920  
     }
 921  
 
 922  
     /***
 923  
      * If in passive mode, returns the data port of the passive host.
 924  
      * This method only returns a valid value AFTER a
 925  
      * data connection has been opened after a call to
 926  
      * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
 927  
      * This is because FTPClient sends a PASV command to the server only
 928  
      * just before opening a data connection, and not when you call
 929  
      * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
 930  
      * <p>
 931  
      * @return The data port of the passive server.  If not in passive
 932  
      *         mode, undefined.
 933  
      ***/
 934  
     public int getPassivePort()
 935  
     {
 936  0
         return __passivePort;
 937  
     }
 938  
 
 939  
 
 940  
     /***
 941  
      * Returns the current data connection mode (one of the
 942  
      * <code> _DATA_CONNECTION_MODE </code> constants.
 943  
      * <p>
 944  
      * @return The current data connection mode (one of the
 945  
      * <code> _DATA_CONNECTION_MODE </code> constants.
 946  
      ***/
 947  
     public int getDataConnectionMode()
 948  
     {
 949  0
         return __dataConnectionMode;
 950  
     }
 951  
 
 952  
 
 953  
     /***
 954  
      * Sets the file type to be transferred.  This should be one of
 955  
      * <code> FTP.ASCII_FILE_TYPE </code>, <code> FTP.IMAGE_FILE_TYPE </code>,
 956  
      * etc.  The file type only needs to be set when you want to change the
 957  
      * type.  After changing it, the new type stays in effect until you change
 958  
      * it again.  The default file type is <code> FTP.ASCII_FILE_TYPE </code>
 959  
      * if this method is never called.
 960  
      * <p>
 961  
      * @param fileType The <code> _FILE_TYPE </code> constant indcating the
 962  
      *                 type of file.
 963  
      * @return True if successfully completed, false if not.
 964  
      * @exception FTPConnectionClosedException
 965  
      *      If the FTP server prematurely closes the connection as a result
 966  
      *      of the client being idle or some other reason causing the server
 967  
      *      to send FTP reply code 421.  This exception may be caught either
 968  
      *      as an IOException or independently as itself.
 969  
      * @exception IOException  If an I/O error occurs while either sending a
 970  
      *      command to the server or receiving a reply from the server.
 971  
      ***/
 972  
     public boolean setFileType(int fileType) throws IOException
 973  
     {
 974  0
         if (FTPReply.isPositiveCompletion(type(fileType)))
 975  
         {
 976  0
             __fileType = fileType;
 977  0
             __fileFormat = FTP.NON_PRINT_TEXT_FORMAT;
 978  0
             return true;
 979  
         }
 980  0
         return false;
 981  
     }
 982  
 
 983  
 
 984  
     /***
 985  
      * Sets the file type to be transferred and the format.  The type should be
 986  
      * one of  <code> FTP.ASCII_FILE_TYPE </code>,
 987  
      * <code> FTP.IMAGE_FILE_TYPE </code>, etc.  The file type only needs to
 988  
      * be set when you want to change the type.  After changing it, the new
 989  
      * type stays in effect until you change it again.  The default file type
 990  
      * is <code> FTP.ASCII_FILE_TYPE </code> if this method is never called.
 991  
      * The format should be one of the FTP class <code> TEXT_FORMAT </code>
 992  
      * constants, or if the type is <code> FTP.LOCAL_FILE_TYPE </code>, the
 993  
      * format should be the byte size for that type.  The default format
 994  
      * is <code> FTP.NON_PRINT_TEXT_FORMAT </code> if this method is never
 995  
      * called.
 996  
      * <p>
 997  
      * @param fileType The <code> _FILE_TYPE </code> constant indcating the
 998  
      *                 type of file.
 999  
      * @param formatOrByteSize  The format of the file (one of the
 1000  
      *              <code>_FORMAT</code> constants.  In the case of
 1001  
      *              <code>LOCAL_FILE_TYPE</code>, the byte size.
 1002  
      * <p>
 1003  
      * @return True if successfully completed, false if not.
 1004  
      * @exception FTPConnectionClosedException
 1005  
      *      If the FTP server prematurely closes the connection as a result
 1006  
      *      of the client being idle or some other reason causing the server
 1007  
      *      to send FTP reply code 421.  This exception may be caught either
 1008  
      *      as an IOException or independently as itself.
 1009  
      * @exception IOException  If an I/O error occurs while either sending a
 1010  
      *      command to the server or receiving a reply from the server.
 1011  
      ***/
 1012  
     public boolean setFileType(int fileType, class="keyword">int formatOrByteSize)
 1013  
     throws IOException
 1014  
     {
 1015  0
         if (FTPReply.isPositiveCompletion(type(fileType, formatOrByteSize)))
 1016  
         {
 1017  0
             __fileType = fileType;
 1018  0
             __fileFormat = formatOrByteSize;
 1019  0
             return true;
 1020  
         }
 1021  0
         return false;
 1022  
     }
 1023  
 
 1024  
 
 1025  
     /***
 1026  
      * Sets the file structure.  The default structure is
 1027  
      * <code> FTP.FILE_STRUCTURE </code> if this method is never called.
 1028  
      * <p>
 1029  
      * @param structure  The structure of the file (one of the FTP class
 1030  
      *         <code>_STRUCTURE</code> constants).
 1031  
      * @return True if successfully completed, false if not.
 1032  
      * @exception FTPConnectionClosedException
 1033  
      *      If the FTP server prematurely closes the connection as a result
 1034  
      *      of the client being idle or some other reason causing the server
 1035  
      *      to send FTP reply code 421.  This exception may be caught either
 1036  
      *      as an IOException or independently as itself.
 1037  
      * @exception IOException  If an I/O error occurs while either sending a
 1038  
      *      command to the server or receiving a reply from the server.
 1039  
      ***/
 1040  
     public boolean setFileStructure(int structure) throws IOException
 1041  
     {
 1042  0
         if (FTPReply.isPositiveCompletion(stru(structure)))
 1043  
         {
 1044  0
             __fileStructure = structure;
 1045  0
             return true;
 1046  
         }
 1047  0
         return false;
 1048  
     }
 1049  
 
 1050  
 
 1051  
     /***
 1052  
      * Sets the transfer mode.  The default transfer mode
 1053  
      * <code> FTP.STREAM_TRANSFER_MODE </code> if this method is never called.
 1054  
      * <p>
 1055  
      * @param mode  The new transfer mode to use (one of the FTP class
 1056  
      *         <code>_TRANSFER_MODE</code> constants).
 1057  
      * @return True if successfully completed, false if not.
 1058  
      * @exception FTPConnectionClosedException
 1059  
      *      If the FTP server prematurely closes the connection as a result
 1060  
      *      of the client being idle or some other reason causing the server
 1061  
      *      to send FTP reply code 421.  This exception may be caught either
 1062  
      *      as an IOException or independently as itself.
 1063  
      * @exception IOException  If an I/O error occurs while either sending a
 1064  
      *      command to the server or receiving a reply from the server.
 1065  
      ***/
 1066  
     public boolean setFileTransferMode(int mode) throws IOException
 1067  
     {
 1068  0
         if (FTPReply.isPositiveCompletion(mode(mode)))
 1069  
         {
 1070  0
             __fileTransferMode = mode;
 1071  0
             return true;
 1072  
         }
 1073  0
         return false;
 1074  
     }
 1075  
 
 1076  
 
 1077  
     /***
 1078  
      * Initiate a server to server file transfer.  This method tells the
 1079  
      * server to which the client is connected to retrieve a given file from
 1080  
      * the other server.
 1081  
      * <p>
 1082  
      * @param filename  The name of the file to retrieve.
 1083  
      * @return True if successfully completed, false if not.
 1084  
      * @exception FTPConnectionClosedException
 1085  
      *      If the FTP server prematurely closes the connection as a result
 1086  
      *      of the client being idle or some other reason causing the server
 1087  
      *      to send FTP reply code 421.  This exception may be caught either
 1088  
      *      as an IOException or independently as itself.
 1089  
      * @exception IOException  If an I/O error occurs while either sending a
 1090  
      *      command to the server or receiving a reply from the server.
 1091  
      ***/
 1092  
     public boolean remoteRetrieve(String filename) throws IOException
 1093  
     {
 1094  0
         if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
 1095  
                 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
 1096  0
             return FTPReply.isPositivePreliminary(retr(filename));
 1097  0
         return false;
 1098  
     }
 1099  
 
 1100  
 
 1101  
     /***
 1102  
      * Initiate a server to server file transfer.  This method tells the
 1103  
      * server to which the client is connected to store a file on
 1104  
      * the other server using the given filename.  The other server must
 1105  
      * have had a <code> remoteRetrieve </code> issued to it by another
 1106  
      * FTPClient.
 1107  
      * <p>
 1108  
      * @param filename  The name to call the file that is to be stored.
 1109  
      * @return True if successfully completed, false if not.
 1110  
      * @exception FTPConnectionClosedException
 1111  
      *      If the FTP server prematurely closes the connection as a result
 1112  
      *      of the client being idle or some other reason causing the server
 1113  
      *      to send FTP reply code 421.  This exception may be caught either
 1114  
      *      as an IOException or independently as itself.
 1115  
      * @exception IOException  If an I/O error occurs while either sending a
 1116  
      *      command to the server or receiving a reply from the server.
 1117  
      ***/
 1118  
     public boolean remoteStore(String filename) throws IOException
 1119  
     {
 1120  0
         if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
 1121  
                 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
 1122  0
             return FTPReply.isPositivePreliminary(stor(filename));
 1123  0
         return false;
 1124  
     }
 1125  
 
 1126  
 
 1127  
     /***
 1128  
      * Initiate a server to server file transfer.  This method tells the
 1129  
      * server to which the client is connected to store a file on
 1130  
      * the other server using a unique filename based on the given filename.
 1131  
      * The other server must have had a <code> remoteRetrieve </code> issued
 1132  
      * to it by another FTPClient.
 1133  
      * <p>
 1134  
      * @param filename  The name on which to base the filename of the file
 1135  
      *                  that is to be stored.
 1136  
      * @return True if successfully completed, false if not.
 1137  
      * @exception FTPConnectionClosedException
 1138  
      *      If the FTP server prematurely closes the connection as a result
 1139  
      *      of the client being idle or some other reason causing the server
 1140  
      *      to send FTP reply code 421.  This exception may be caught either
 1141  
      *      as an IOException or independently as itself.
 1142  
      * @exception IOException  If an I/O error occurs while either sending a
 1143  
      *      command to the server or receiving a reply from the server.
 1144  
      ***/
 1145  
     public boolean remoteStoreUnique(String filename) throws IOException
 1146  
     {
 1147  0
         if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
 1148  
                 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
 1149  0
             return FTPReply.isPositivePreliminary(stou(filename));
 1150  0
         return false;
 1151  
     }
 1152  
 
 1153  
 
 1154  
     /***
 1155  
      * Initiate a server to server file transfer.  This method tells the
 1156  
      * server to which the client is connected to store a file on
 1157  
      * the other server using a unique filename.
 1158  
      * The other server must have had a <code> remoteRetrieve </code> issued
 1159  
      * to it by another FTPClient.  Many FTP servers require that a base
 1160  
      * filename be given from which the unique filename can be derived.  For
 1161  
      * those servers use the other version of <code> remoteStoreUnique</code>
 1162  
      * <p>
 1163  
      * @return True if successfully completed, false if not.
 1164  
      * @exception FTPConnectionClosedException
 1165  
      *      If the FTP server prematurely closes the connection as a result
 1166  
      *      of the client being idle or some other reason causing the server
 1167  
      *      to send FTP reply code 421.  This exception may be caught either
 1168  
      *      as an IOException or independently as itself.
 1169  
      * @exception IOException  If an I/O error occurs while either sending a
 1170  
      *      command to the server or receiving a reply from the server.
 1171  
      ***/
 1172  
     public boolean remoteStoreUnique() throws IOException
 1173  
     {
 1174  0
         if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
 1175  
                 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
 1176  0
             return FTPReply.isPositivePreliminary(stou());
 1177  0
         return false;
 1178  
     }
 1179  
 
 1180  
     // For server to server transfers
 1181  
     /***
 1182  
      * Initiate a server to server file transfer.  This method tells the
 1183  
      * server to which the client is connected to append to a given file on
 1184  
      * the other server.  The other server must have had a
 1185  
      * <code> remoteRetrieve </code> issued to it by another FTPClient.
 1186  
      * <p>
 1187  
      * @param filename  The name of the file to be appended to, or if the
 1188  
      *        file does not exist, the name to call the file being stored.
 1189  
      * <p>
 1190  
      * @return True if successfully completed, false if not.
 1191  
      * @exception FTPConnectionClosedException
 1192  
      *      If the FTP server prematurely closes the connection as a result
 1193  
      *      of the client being idle or some other reason causing the server
 1194  
      *      to send FTP reply code 421.  This exception may be caught either
 1195  
      *      as an IOException or independently as itself.
 1196  
      * @exception IOException  If an I/O error occurs while either sending a
 1197  
      *      command to the server or receiving a reply from the server.
 1198  
      ***/
 1199  
     public boolean remoteAppend(String filename) throws IOException
 1200  
     {
 1201  0
         if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
 1202  
                 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
 1203  0
             return FTPReply.isPositivePreliminary(stor(filename));
 1204  0
         return false;
 1205  
     }
 1206  
 
 1207  
     /***
 1208  
      * There are a few FTPClient methods that do not complete the
 1209  
      * entire sequence of FTP commands to complete a transaction.  These
 1210  
      * commands require some action by the programmer after the reception
 1211  
      * of a positive intermediate command.  After the programmer's code
 1212  
      * completes its actions, it must call this method to receive
 1213  
      * the completion reply from the server and verify the success of the
 1214  
      * entire transaction.
 1215  
      * <p>
 1216  
      * For example,
 1217  
      * <pre>
 1218  
      * InputStream input;
 1219  
      * OutputStream output;
 1220  
      * input  = new FileInputStream("foobaz.txt");
 1221  
      * output = ftp.storeFileStream("foobar.txt")
 1222  
      * if(!FTPReply.isPositiveIntermediate(ftp.getReplyCode())) {
 1223  
      *     input.close();
 1224  
      *     output.close();
 1225  
      *     ftp.logout();
 1226  
      *     ftp.disconnect();
 1227  
      *     System.err.println("File transfer failed.");
 1228  
      *     System.exit(1);
 1229  
      * }
 1230  
      * Util.copyStream(input, output);
 1231  
      * input.close();
 1232  
      * output.close();
 1233  
      * // Must call completePendingCommand() to finish command.
 1234  
      * if(!ftp.completePendingCommand()) {
 1235  
      *     ftp.logout();
 1236  
      *     ftp.disconnect();
 1237  
      *     System.err.println("File transfer failed.");
 1238  
      *     System.exit(1);
 1239  
      * }
 1240  
      * </pre>
 1241  
      * <p>
 1242  
      * @return True if successfully completed, false if not.
 1243  
      * @exception FTPConnectionClosedException
 1244  
      *      If the FTP server prematurely closes the connection as a result
 1245  
      *      of the client being idle or some other reason causing the server
 1246  
      *      to send FTP reply code 421.  This exception may be caught either
 1247  
      *      as an IOException or independently as itself.
 1248  
      * @exception IOException  If an I/O error occurs while either sending a
 1249  
      *      command to the server or receiving a reply from the server.
 1250  
      ***/
 1251  
     public boolean completePendingCommand() throws IOException
 1252  
     {
 1253  0
         return FTPReply.isPositiveCompletion(getReply());
 1254  
     }
 1255  
 
 1256  
 
 1257  
     /***
 1258  
      * Retrieves a named file from the server and writes it to the given
 1259  
      * OutputStream.  This method does NOT close the given OutputStream.
 1260  
      * If the current file type is ASCII, line separators in the file are
 1261  
      * converted to the local representation.
 1262  
      * <p>
 1263  
      * @param remote  The name of the remote file.
 1264  
      * @param local   The local OutputStream to which to write the file.
 1265  
      * @return True if successfully completed, false if not.
 1266  
      * @exception FTPConnectionClosedException
 1267  
      *      If the FTP server prematurely closes the connection as a result
 1268  
      *      of the client being idle or some other reason causing the server
 1269  
      *      to send FTP reply code 421.  This exception may be caught either
 1270  
      *      as an IOException or independently as itself.
 1271  
      * @exception CopyStreamException  If an I/O error occurs while actually
 1272  
      *      transferring the file.  The CopyStreamException allows you to
 1273  
      *      determine the number of bytes transferred and the IOException
 1274  
      *      causing the error.  This exception may be caught either
 1275  
      *      as an IOException or independently as itself.
 1276  
      * @exception IOException  If an I/O error occurs while either sending a
 1277  
      *      command to the server or receiving a reply from the server.
 1278  
      ***/
 1279  
     public boolean retrieveFile(String remote, OutputStream local)
 1280  
     throws IOException
 1281  
     {
 1282  
         InputStream input;
 1283  
         Socket socket;
 1284  
 
 1285  0
         if ((socket = _openDataConnection_(FTPCommand.RETR, remote)) == null)
 1286  0
             return false;
 1287  
 
 1288  0
         input = new BufferedInputStream(socket.getInputStream(),
 1289  
                                         getBufferSize());
 1290  0
         if (__fileType == ASCII_FILE_TYPE)
 1291  0
           input = new FromNetASCIIInputStream(input);
 1292  
         // Treat everything else as binary for now
 1293  
         try
 1294  
         {
 1295  0
             Util.copyStream(input, local, getBufferSize(),
 1296  
                             CopyStreamEvent.UNKNOWN_STREAM_SIZE, null,
 1297  
                             false);
 1298  
         }
 1299  0
         catch (IOException e)
 1300  
         {
 1301  
             try
 1302  
             {
 1303  0
                 socket.close();
 1304  
             }
 1305  0
             catch (IOException f)
 1306  0
             {}
 1307  0
             throw e;
 1308  0
         }
 1309  0
         socket.close();
 1310  0
         return completePendingCommand();
 1311  
     }
 1312  
 
 1313  
     /***
 1314  
      * Returns an InputStream from which a named file from the server
 1315  
      * can be read.  If the current file type is ASCII, the returned
 1316  
      * InputStream will convert line separators in the file to
 1317  
      * the local representation.  You must close the InputStream when you
 1318  
      * finish reading from it.  The InputStream itself will take care of
 1319  
      * closing the parent data connection socket upon being closed.  To
 1320  
      * finalize the file transfer you must call
 1321  
      * {@link #completePendingCommand  completePendingCommand } and
 1322  
      * check its return value to verify success.
 1323  
      * <p>
 1324  
      * @param remote  The name of the remote file.
 1325  
      * @return An InputStream from which the remote file can be read.  If
 1326  
      *      the data connection cannot be opened (e.g., the file does not
 1327  
      *      exist), null is returned (in which case you may check the reply
 1328  
      *      code to determine the exact reason for failure).
 1329  
      * @exception FTPConnectionClosedException
 1330  
      *      If the FTP server prematurely closes the connection as a result
 1331  
      *      of the client being idle or some other reason causing the server
 1332  
      *      to send FTP reply code 421.  This exception may be caught either
 1333  
      *      as an IOException or independently as itself.
 1334  
      * @exception IOException  If an I/O error occurs while either sending a
 1335  
      *      command to the server or receiving a reply from the server.
 1336  
      ***/
 1337  
     public InputStream retrieveFileStream(String remote) throws IOException
 1338  
     {
 1339  
         InputStream input;
 1340  
         Socket socket;
 1341  
 
 1342  0
         if ((socket = _openDataConnection_(FTPCommand.RETR, remote)) == null)
 1343  0
             return null;
 1344  
 
 1345  0
         input = socket.getInputStream();
 1346  0
         if (__fileType == ASCII_FILE_TYPE) {
 1347  
           // We buffer ascii transfers because the buffering has to
 1348  
           // be interposed between FromNetASCIIOutputSream and the underlying
 1349  
           // socket input stream.  We don't buffer binary transfers
 1350  
           // because we don't want to impose a buffering policy on the
 1351  
           // programmer if possible.  Programmers can decide on their
 1352  
           // own if they want to wrap the SocketInputStream we return
 1353  
           // for file types other than ASCII.
 1354  0
           input = new BufferedInputStream(input,
 1355  
                                           getBufferSize());
 1356  0
           input = new FromNetASCIIInputStream(input);
 1357  
         }
 1358  0
         return new org.apache.commons.net.io.SocketInputStream(socket, input);
 1359  
     }
 1360  
 
 1361  
 
 1362  
     /***
 1363  
      * Stores a file on the server using the given name and taking input
 1364  
      * from the given InputStream.  This method does NOT close the given
 1365  
      * InputStream.  If the current file type is ASCII, line separators in
 1366  
      * the file are transparently converted to the NETASCII format (i.e.,
 1367  
      * you should not attempt to create a special InputStream to do this).
 1368  
      * <p>
 1369  
      * @param remote  The name to give the remote file.
 1370  
      * @param local   The local InputStream from which to read the file.
 1371  
      * @return True if successfully completed, false if not.
 1372  
      * @exception FTPConnectionClosedException
 1373  
      *      If the FTP server prematurely closes the connection as a result
 1374  
      *      of the client being idle or some other reason causing the server
 1375  
      *      to send FTP reply code 421.  This exception may be caught either
 1376  
      *      as an IOException or independently as itself.
 1377  
      * @exception CopyStreamException  If an I/O error occurs while actually
 1378  
      *      transferring the file.  The CopyStreamException allows you to
 1379  
      *      determine the number of bytes transferred and the IOException
 1380  
      *      causing the error.  This exception may be caught either
 1381  
      *      as an IOException or independently as itself.
 1382  
      * @exception IOException  If an I/O error occurs while either sending a
 1383  
      *      command to the server or receiving a reply from the server.
 1384  
      ***/
 1385  
     public boolean storeFile(String remote, InputStream local)
 1386  
     throws IOException
 1387  
     {
 1388  0
         return __storeFile(FTPCommand.STOR, remote, local);
 1389  
     }
 1390  
 
 1391  
 
 1392  
     /***
 1393  
      * Returns an OutputStream through which data can be written to store
 1394  
      * a file on the server using the given name.  If the current file type
 1395  
      * is ASCII, the returned OutputStream will convert line separators in
 1396  
      * the file to the NETASCII format  (i.e., you should not attempt to
 1397  
      * create a special OutputStream to do this).  You must close the
 1398  
      * OutputStream when you finish writing to it.  The OutputStream itself
 1399  
      * will take care of closing the parent data connection socket upon being
 1400  
      * closed.  To finalize the file transfer you must call
 1401  
      * {@link #completePendingCommand  completePendingCommand } and
 1402  
      * check its return value to verify success.
 1403  
      * <p>
 1404  
      * @param remote  The name to give the remote file.
 1405  
      * @return An OutputStream through which the remote file can be written.  If
 1406  
      *      the data connection cannot be opened (e.g., the file does not
 1407  
      *      exist), null is returned (in which case you may check the reply
 1408  
      *      code to determine the exact reason for failure).
 1409  
      * @exception FTPConnectionClosedException
 1410  
      *      If the FTP server prematurely closes the connection as a result
 1411  
      *      of the client being idle or some other reason causing the server
 1412  
      *      to send FTP reply code 421.  This exception may be caught either
 1413  
      *      as an IOException or independently as itself.
 1414  
      * @exception IOException  If an I/O error occurs while either sending a
 1415  
      *      command to the server or receiving a reply from the server.
 1416  
      ***/
 1417  
     public OutputStream storeFileStream(String remote) throws IOException
 1418  
     {
 1419  0
         return __storeFileStream(FTPCommand.STOR, remote);
 1420  
     }
 1421  
 
 1422  
     /***
 1423  
      * Appends to a file on the server with the given name, taking input
 1424  
      * from the given InputStream.  This method does NOT close the given
 1425  
      * InputStream.  If the current file type is ASCII, line separators in
 1426  
      * the file are transparently converted to the NETASCII format (i.e.,
 1427  
      * you should not attempt to create a special InputStream to do this).
 1428  
      * <p>
 1429  
      * @param remote  The name of the remote file.
 1430  
      * @param local   The local InputStream from which to read the data to
 1431  
      *                be appended to the remote file.
 1432  
      * @return True if successfully completed, false if not.
 1433  
      * @exception FTPConnectionClosedException
 1434  
      *      If the FTP server prematurely closes the connection as a result
 1435  
      *      of the client being idle or some other reason causing the server
 1436  
      *      to send FTP reply code 421.  This exception may be caught either
 1437  
      *      as an IOException or independently as itself.
 1438  
      * @exception CopyStreamException  If an I/O error occurs while actually
 1439  
      *      transferring the file.  The CopyStreamException allows you to
 1440  
      *      determine the number of bytes transferred and the IOException
 1441  
      *      causing the error.  This exception may be caught either
 1442  
      *      as an IOException or independently as itself.
 1443  
      * @exception IOException  If an I/O error occurs while either sending a
 1444  
      *      command to the server or receiving a reply from the server.
 1445  
      ***/
 1446  
     public boolean appendFile(String remote, InputStream local)
 1447  
     throws IOException
 1448  
     {
 1449  0
         return __storeFile(FTPCommand.APPE, remote, local);
 1450  
     }
 1451  
 
 1452  
     /***
 1453  
      * Returns an OutputStream through which data can be written to append
 1454  
      * to a file on the server with the given name.  If the current file type
 1455  
      * is ASCII, the returned OutputStream will convert line separators in
 1456  
      * the file to the NETASCII format  (i.e., you should not attempt to
 1457  
      * create a special OutputStream to do this).  You must close the
 1458  
      * OutputStream when you finish writing to it.  The OutputStream itself
 1459  
      * will take care of closing the parent data connection socket upon being
 1460  
      * closed.  To finalize the file transfer you must call
 1461  
      * {@link #completePendingCommand  completePendingCommand } and
 1462  
      * check its return value to verify success.
 1463  
      * <p>
 1464  
      * @param remote  The name of the remote file.
 1465  
      * @return An OutputStream through which the remote file can be appended.
 1466  
      *      If the data connection cannot be opened (e.g., the file does not
 1467  
      *      exist), null is returned (in which case you may check the reply
 1468  
      *      code to determine the exact reason for failure).
 1469  
      * @exception FTPConnectionClosedException
 1470  
      *      If the FTP server prematurely closes the connection as a result
 1471  
      *      of the client being idle or some other reason causing the server
 1472  
      *      to send FTP reply code 421.  This exception may be caught either
 1473  
      *      as an IOException or independently as itself.
 1474  
      * @exception IOException  If an I/O error occurs while either sending a
 1475  
      *      command to the server or receiving a reply from the server.
 1476  
      ***/
 1477  
     public OutputStream appendFileStream(String remote) throws IOException
 1478  
     {
 1479  0
         return __storeFileStream(FTPCommand.APPE, remote);
 1480  
     }
 1481  
 
 1482  
     /***
 1483  
      * Stores a file on the server using a unique name derived from the
 1484  
      * given name and taking input
 1485  
      * from the given InputStream.  This method does NOT close the given
 1486  
      * InputStream.  If the current file type is ASCII, line separators in
 1487  
      * the file are transparently converted to the NETASCII format (i.e.,
 1488  
      * you should not attempt to create a special InputStream to do this).
 1489  
      * <p>
 1490  
      * @param remote  The name on which to base the unique name given to
 1491  
      *                the remote file.
 1492  
      * @param local   The local InputStream from which to read the file.
 1493  
      * @return True if successfully completed, false if not.
 1494  
      * @exception FTPConnectionClosedException
 1495  
      *      If the FTP server prematurely closes the connection as a result
 1496  
      *      of the client being idle or some other reason causing the server
 1497  
      *      to send FTP reply code 421.  This exception may be caught either
 1498  
      *      as an IOException or independently as itself.
 1499  
      * @exception CopyStreamException  If an I/O error occurs while actually
 1500  
      *      transferring the file.  The CopyStreamException allows you to
 1501  
      *      determine the number of bytes transferred and the IOException
 1502  
      *      causing the error.  This exception may be caught either
 1503  
      *      as an IOException or independently as itself.
 1504  
      * @exception IOException  If an I/O error occurs while either sending a
 1505  
      *      command to the server or receiving a reply from the server.
 1506  
      ***/
 1507  
     public boolean storeUniqueFile(String remote, InputStream local)
 1508  
     throws IOException
 1509  
     {
 1510  0
         return __storeFile(FTPCommand.STOU, remote, local);
 1511  
     }
 1512  
 
 1513  
 
 1514  
     /***
 1515  
      * Returns an OutputStream through which data can be written to store
 1516  
      * a file on the server using a unique name derived from the given name.
 1517  
      * If the current file type
 1518  
      * is ASCII, the returned OutputStream will convert line separators in
 1519  
      * the file to the NETASCII format  (i.e., you should not attempt to
 1520  
      * create a special OutputStream to do this).  You must close the
 1521  
      * OutputStream when you finish writing to it.  The OutputStream itself
 1522  
      * will take care of closing the parent data connection socket upon being
 1523  
      * closed.  To finalize the file transfer you must call
 1524  
      * {@link #completePendingCommand  completePendingCommand } and
 1525  
      * check its return value to verify success.
 1526  
      * <p>
 1527  
      * @param remote  The name on which to base the unique name given to
 1528  
      *                the remote file.
 1529  
      * @return An OutputStream through which the remote file can be written.  If
 1530  
      *      the data connection cannot be opened (e.g., the file does not
 1531  
      *      exist), null is returned (in which case you may check the reply
 1532  
      *      code to determine the exact reason for failure).
 1533  
      * @exception FTPConnectionClosedException
 1534  
      *      If the FTP server prematurely closes the connection as a result
 1535  
      *      of the client being idle or some other reason causing the server
 1536  
      *      to send FTP reply code 421.  This exception may be caught either
 1537  
      *      as an IOException or independently as itself.
 1538  
      * @exception IOException  If an I/O error occurs while either sending a
 1539  
      *      command to the server or receiving a reply from the server.
 1540  
      ***/
 1541  
     public OutputStream storeUniqueFileStream(String remote) throws IOException
 1542  
     {
 1543  0
         return __storeFileStream(FTPCommand.STOU, remote);
 1544  
     }
 1545  
 
 1546  
     /**
 1547  
      * Stores a file on the server using a unique name assigned by the
 1548  
      * server and taking input from the given InputStream.  This method does
 1549  
      * NOT close the given
 1550  
      * InputStream.  If the current file type is ASCII, line separators in
 1551  
      * the file are transparently converted to the NETASCII format (i.e.,
 1552  
      * you should not attempt to create a special InputStream to do this).
 1553  
      * <p>
 1554  
      * @param local   The local InputStream from which to read the file.
 1555  
      * @return True if successfully completed, false if not.
 1556  
      * @exception FTPConnectionClosedException
 1557  
      *      If the FTP server prematurely closes the connection as a result
 1558  
      *      of the client being idle or some other reason causing the server
 1559  
      *      to send FTP reply code 421.  This exception may be caught either
 1560  
      *      as an IOException or independently as itself.
 1561  
      * @exception CopyStreamException  If an I/O error occurs while actually
 1562  
      *      transferring the file.  The CopyStreamException allows you to
 1563  
      *      determine the number of bytes transferred and the IOException
 1564  
      *      causing the error.  This exception may be caught either
 1565  
      *      as an IOException or independently as itself.
 1566  
      * @exception IOException  If an I/O error occurs while either sending a
 1567  
      *      command to the server or receiving a reply from the server.
 1568  
      */
 1569  
     public boolean storeUniqueFile(InputStream local) throws IOException
 1570  
     {
 1571  0
         return __storeFile(FTPCommand.STOU, null, local);
 1572  
     }
 1573  
 
 1574  
     /**
 1575  
      * Returns an OutputStream through which data can be written to store
 1576  
      * a file on the server using a unique name assigned by the server.
 1577  
      * If the current file type
 1578  
      * is ASCII, the returned OutputStream will convert line separators in
 1579  
      * the file to the NETASCII format  (i.e., you should not attempt to
 1580  
      * create a special OutputStream to do this).  You must close the
 1581  
      * OutputStream when you finish writing to it.  The OutputStream itself
 1582  
      * will take care of closing the parent data connection socket upon being
 1583  
      * closed.  To finalize the file transfer you must call
 1584  
      * {@link #completePendingCommand  completePendingCommand } and
 1585  
      * check its return value to verify success.
 1586  
      * <p>
 1587  
      * @return An OutputStream through which the remote file can be written.  If
 1588  
      *      the data connection cannot be opened (e.g., the file does not
 1589  
      *      exist), null is returned (in which case you may check the reply
 1590  
      *      code to determine the exact reason for failure).
 1591  
      * @exception FTPConnectionClosedException
 1592  
      *      If the FTP server prematurely closes the connection as a result
 1593  
      *      of the client being idle or some other reason causing the server
 1594  
      *      to send FTP reply code 421.  This exception may be caught either
 1595  
      *      as an IOException or independently as itself.
 1596  
      * @exception IOException  If an I/O error occurs while either sending a
 1597  
      *      command to the server or receiving a reply from the server.
 1598  
      */
 1599  
     public OutputStream storeUniqueFileStream() throws IOException
 1600  
     {
 1601  0
         return __storeFileStream(FTPCommand.STOU, null);
 1602  
     }
 1603  
 
 1604  
     /***
 1605  
      * Reserve a number of bytes on the server for the next file transfer.
 1606  
      * <p>
 1607  
      * @param bytes  The number of bytes which the server should allocate.
 1608  
      * @return True if successfully completed, false if not.
 1609  
      * @exception FTPConnectionClosedException
 1610  
      *      If the FTP server prematurely closes the connection as a result
 1611  
      *      of the client being idle or some other reason causing the server
 1612  
      *      to send FTP reply code 421.  This exception may be caught either
 1613  
      *      as an IOException or independently as itself.
 1614  
      * @exception IOException  If an I/O error occurs while either sending a
 1615  
      *      command to the server or receiving a reply from the server.
 1616  
      ***/
 1617  
     public boolean allocate(int bytes) throws IOException
 1618  
     {
 1619  0
         return FTPReply.isPositiveCompletion(allo(bytes));
 1620  
     }
 1621  
 
 1622  
 
 1623  
     /**
 1624  
      * Reserve space on the server for the next file transfer.
 1625  
      * <p>
 1626  
      * @param bytes  The number of bytes which the server should allocate.
 1627  
      * @param recordSize  The size of a file record.
 1628  
      * @return True if successfully completed, false if not.
 1629  
      * @exception FTPConnectionClosedException
 1630  
      *      If the FTP server prematurely closes the connection as a result
 1631  
      *      of the client being idle or some other reason causing the server
 1632  
      *      to send FTP reply code 421.  This exception may be caught either
 1633  
      *      as an IOException or independently as itself.
 1634  
      * @exception IOException  If an I/O error occurs while either sending a
 1635  
      *      command to the server or receiving a reply from the server.
 1636  
      */
 1637  
     public boolean allocate(int bytes, class="keyword">int recordSize) throws IOException
 1638  
     {
 1639  0
         return FTPReply.isPositiveCompletion(allo(bytes, recordSize));
 1640  
     }
 1641  
 
 1642  
 
 1643  
     /***
 1644  
      * Restart a <code>STREAM_TRANSFER_MODE</code> file transfer starting
 1645  
      * from the given offset.  This will only work on FTP servers supporting
 1646  
      * the REST comand for the stream transfer mode.  However, most FTP
 1647  
      * servers support this.  Any subsequent file transfer will start
 1648  
      * reading or writing the remote file from the indicated offset.
 1649  
      * <p>
 1650  
      * @param offset  The offset into the remote file at which to start the
 1651  
      *           next file transfer.
 1652  
      * @return True if successfully completed, false if not.
 1653  
      * @exception FTPConnectionClosedException
 1654  
      *      If the FTP server prematurely closes the connection as a result
 1655  
      *      of the client being idle or some other reason causing the server
 1656  
      *      to send FTP reply code 421.  This exception may be caught either
 1657  
      *      as an IOException or independently as itself.
 1658  
      * @exception IOException  If an I/O error occurs while either sending a
 1659  
      *      command to the server or receiving a reply from the server.
 1660  
      ***/
 1661  
     private boolean restart(long offset) throws IOException
 1662  
     {
 1663  0
         __restartOffset = 0;
 1664  0
         return FTPReply.isPositiveIntermediate(rest(Long.toString(offset)));
 1665  
     }
 1666  
 
 1667  
     /***
 1668  
      * Sets the restart offset.  The restart command is sent to the server
 1669  
      * only before sending the file transfer command.  When this is done,
 1670  
      * the restart marker is reset to zero.
 1671  
      * <p>
 1672  
      * @param offset  The offset into the remote file at which to start the
 1673  
      *           next file transfer.  This must be a value greater than or
 1674  
      *           equal to zero.
 1675  
      ***/
 1676  
     public void setRestartOffset(long offset)
 1677  
     {
 1678  0
         if (offset >= 0)
 1679  0
             __restartOffset = offset;
 1680  0
     }
 1681  
 
 1682  
     /***
 1683  
      * Fetches the restart offset.
 1684  
      * <p>
 1685  
      * @return offset  The offset into the remote file at which to start the
 1686  
      *           next file transfer.
 1687  
      ***/
 1688  
     public long getRestartOffset()
 1689  
     {
 1690  0
         return __restartOffset;
 1691  
     }
 1692  
 
 1693  
 
 1694  
 
 1695  
     /***
 1696  
      * Renames a remote file.
 1697  
      * <p>
 1698  
      * @param from  The name of the remote file to rename.
 1699  
      * @param to    The new name of the remote file.
 1700  
      * @return True if successfully completed, false if not.
 1701  
      * @exception FTPConnectionClosedException
 1702  
      *      If the FTP server prematurely closes the connection as a result
 1703  
      *      of the client being idle or some other reason causing the server
 1704  
      *      to send FTP reply code 421.  This exception may be caught either
 1705  
      *      as an IOException or independently as itself.
 1706  
      * @exception IOException  If an I/O error occurs while either sending a
 1707  
      *      command to the server or receiving a reply from the server.
 1708  
      ***/
 1709  
     public boolean rename(String from, String to) throws IOException
 1710  
     {
 1711  0
         if (!FTPReply.isPositiveIntermediate(rnfr(from)))
 1712  0
             return false;
 1713  
 
 1714  0
         return FTPReply.isPositiveCompletion(rnto(to));
 1715  
     }
 1716  
 
 1717  
 
 1718  
     /***
 1719  
      * Abort a transfer in progress.
 1720  
      * <p>
 1721  
      * @return True if successfully completed, false if not.
 1722  
      * @exception FTPConnectionClosedException
 1723  
      *      If the FTP server prematurely closes the connection as a result
 1724  
      *      of the client being idle or some other reason causing the server
 1725  
      *      to send FTP reply code 421.  This exception may be caught either
 1726  
      *      as an IOException or independently as itself.
 1727  
      * @exception IOException  If an I/O error occurs while either sending a
 1728  
      *      command to the server or receiving a reply from the server.
 1729  
      ***/
 1730  
     public boolean abort() throws IOException
 1731  
     {
 1732  0
         return FTPReply.isPositiveCompletion(abor());
 1733  
     }
 1734  
 
 1735  
     /***
 1736  
      * Deletes a file on the FTP server.
 1737  
      * <p>
 1738  
      * @param pathname   The pathname of the file to be deleted.
 1739  
      * @return True if successfully completed, false if not.
 1740  
      * @exception FTPConnectionClosedException
 1741  
      *      If the FTP server prematurely closes the connection as a result
 1742  
      *      of the client being idle or some other reason causing the server
 1743  
      *      to send FTP reply code 421.  This exception may be caught either
 1744  
      *      as an IOException or independently as itself.
 1745  
      * @exception IOException  If an I/O error occurs while either sending a
 1746  
      *      command to the server or receiving a reply from the server.
 1747  
      ***/
 1748  
     public boolean deleteFile(String pathname) throws IOException
 1749  
     {
 1750  0
         return FTPReply.isPositiveCompletion(dele(pathname));
 1751  
     }
 1752  
 
 1753  
 
 1754  
     /***
 1755  
      * Removes a directory on the FTP server (if empty).
 1756  
      * <p>
 1757  
      * @param pathname  The pathname of the directory to remove.
 1758  
      * @return True if successfully completed, false if not.
 1759  
      * @exception FTPConnectionClosedException
 1760  
      *      If the FTP server prematurely closes the connection as a result
 1761  
      *      of the client being idle or some other reason causing the server
 1762  
      *      to send FTP reply code 421.  This exception may be caught either
 1763  
      *      as an IOException or independently as itself.
 1764  
      * @exception IOException  If an I/O error occurs while either sending a
 1765  
      *      command to the server or receiving a reply from the server.
 1766  
      ***/
 1767  
     public boolean removeDirectory(String pathname) throws IOException
 1768  
     {
 1769  0
         return FTPReply.isPositiveCompletion(rmd(pathname));
 1770  
     }
 1771  
 
 1772  
 
 1773  
     /***
 1774  
      * Creates a new subdirectory on the FTP server in the current directory
 1775  
      * (if a relative pathname is given) or where specified (if an absolute
 1776  
      * pathname is given).
 1777  
      * <p>
 1778  
      * @param pathname The pathname of the directory to create.
 1779  
      * @return True if successfully completed, false if not.
 1780  
      * @exception FTPConnectionClosedException
 1781  
      *      If the FTP server prematurely closes the connection as a result
 1782  
      *      of the client being idle or some other reason causing the server
 1783  
      *      to send FTP reply code 421.  This exception may be caught either
 1784  
      *      as an IOException or independently as itself.
 1785  
      * @exception IOException  If an I/O error occurs while either sending a
 1786  
      *      command to the server or receiving a reply from the server.
 1787  
      ***/
 1788  
     public boolean makeDirectory(String pathname) throws IOException
 1789  
     {
 1790  0
         return FTPReply.isPositiveCompletion(mkd(pathname));
 1791  
     }
 1792  
 
 1793  
 
 1794  
     /***
 1795  
      * Returns the pathname of the current working directory.
 1796  
      * <p>
 1797  
      * @return The pathname of the current working directory.  If it cannot
 1798  
      *         be obtained, returns null.
 1799  
      * @exception FTPConnectionClosedException
 1800  
      *      If the FTP server prematurely closes the connection as a result
 1801  
      *      of the client being idle or some other reason causing the server
 1802  
      *      to send FTP reply code 421.  This exception may be caught either
 1803  
      *      as an IOException or independently as itself.
 1804  
      * @exception IOException  If an I/O error occurs while either sending a
 1805  
      *      command to the server or receiving a reply from the server.
 1806  
      ***/
 1807  
     public String printWorkingDirectory() throws IOException
 1808  
     {
 1809  0
         if (pwd() != FTPReply.PATHNAME_CREATED)
 1810  0
             return null;
 1811  
 
 1812  0
         return __parsePathname((String)_replyLines.elementAt(0));
 1813  
     }
 1814  
 
 1815  
 
 1816  
     /**
 1817  
      * Send a site specific command.
 1818  
      * @param arguments The site specific command and arguments.
 1819  
      * @return True if successfully completed, false if not.
 1820  
      * @exception FTPConnectionClosedException
 1821  
      *      If the FTP server prematurely closes the connection as a result
 1822  
      *      of the client being idle or some other reason causing the server
 1823  
      *      to send FTP reply code 421.  This exception may be caught either
 1824  
      *      as an IOException or independently as itself.
 1825  
      * @exception IOException  If an I/O error occurs while either sending a
 1826  
      *      command to the server or receiving a reply from the server.
 1827  
      */
 1828  
     public boolean sendSiteCommand(String arguments) throws IOException
 1829  
     {
 1830  0
         return FTPReply.isPositiveCompletion(site(arguments));
 1831  
     }
 1832  
 
 1833  
 
 1834  
     /***
 1835  
      * Fetches the system type name from the server and returns the string.
 1836  
      * This value is cached for the duration of the connection after the
 1837  
      * first call to this method.  In other words, only the first time
 1838  
      * that you invoke this method will it issue a SYST command to the
 1839  
      * FTP server.  FTPClient will remember the value and return the
 1840  
      * cached value until a call to disconnect.
 1841  
      * <p>
 1842  
      * @return The system type name obtained from the server.  null if the
 1843  
      *       information could not be obtained.
 1844  
      * @exception FTPConnectionClosedException
 1845  
      *      If the FTP server prematurely closes the connection as a result
 1846  
      *      of the client being idle or some other reason causing the server
 1847  
      *      to send FTP reply code 421.  This exception may be caught either
 1848  
      *      as an IOException or independently as itself.
 1849  
      * @exception IOException  If an I/O error occurs while either sending a
 1850  
      *  command to the server or receiving a reply from the server.
 1851  
      ***/
 1852  
     public String getSystemName() throws IOException
 1853  
     {
 1854  
       //if (syst() == FTPReply.NAME_SYSTEM_TYPE)
 1855  
       // Technically, we should expect a NAME_SYSTEM_TYPE response, but
 1856  
       // in practice FTP servers deviate, so we soften the condition to
 1857  
       // a positive completion.
 1858  0
         if (__systemName == null && FTPReply.isPositiveCompletion(syst()))
 1859  0
             __systemName = ((String)_replyLines.elementAt(0)).substring(4);
 1860  
 
 1861  0
         return __systemName;
 1862  
     }
 1863  
 
 1864  
 
 1865  
     /***
 1866  
      * Fetches the system help information from the server and returns the
 1867  
      * full string.
 1868  
      * <p>
 1869  
      * @return The system help string obtained from the server.  null if the
 1870  
      *       information could not be obtained.
 1871  
      * @exception FTPConnectionClosedException
 1872  
      *      If the FTP server prematurely closes the connection as a result
 1873  
      *      of the client being idle or some other reason causing the server
 1874  
      *      to send FTP reply code 421.  This exception may be caught either
 1875  
      *      as an IOException or independently as itself.
 1876  
      * @exception IOException  If an I/O error occurs while either sending a
 1877  
      *  command to the server or receiving a reply from the server.
 1878  
      ***/
 1879  
     public String listHelp() throws IOException
 1880  
     {
 1881  0
         if (FTPReply.isPositiveCompletion(help()))
 1882  0
             return getReplyString();
 1883  0
         return null;
 1884  
     }
 1885  
 
 1886  
 
 1887  
     /**
 1888  
      * Fetches the help information for a given command from the server and
 1889  
      * returns the full string.
 1890  
      * @param command The command on which to ask for help.
 1891  
      * @return The command help string obtained from the server.  null if the
 1892  
      *       information could not be obtained.
 1893  
      * @exception FTPConnectionClosedException
 1894  
      *      If the FTP server prematurely closes the connection as a result
 1895  
      *      of the client being idle or some other reason causing the server
 1896  
      *      to send FTP reply code 421.  This exception may be caught either
 1897  
      *      as an IOException or independently as itself.
 1898  
      * @exception IOException  If an I/O error occurs while either sending a
 1899  
      *  command to the server or receiving a reply from the server.
 1900  
      */
 1901  
     public String listHelp(String command) throws IOException
 1902  
     {
 1903  0
         if (FTPReply.isPositiveCompletion(help(command)))
 1904  0
             return getReplyString();
 1905  0
         return null;
 1906  
     }
 1907  
 
 1908  
 
 1909  
     /***
 1910  
      * Sends a NOOP command to the FTP server.  This is useful for preventing
 1911  
      * server timeouts.
 1912  
      * <p>
 1913  
      * @return True if successfully completed, false if not.
 1914  
      * @exception FTPConnectionClosedException
 1915  
      *      If the FTP server prematurely closes the connection as a result
 1916  
      *      of the client being idle or some other reason causing the server
 1917  
      *      to send FTP reply code 421.  This exception may be caught either
 1918  
      *      as an IOException or independently as itself.
 1919  
      * @exception IOException  If an I/O error occurs while either sending a
 1920  
      *      command to the server or receiving a reply from the server.
 1921  
      ***/
 1922  
     public boolean sendNoOp() throws IOException
 1923  
     {
 1924  0
         return FTPReply.isPositiveCompletion(noop());
 1925  
     }
 1926  
 
 1927  
 
 1928  
     /***
 1929  
      * Obtain a list of filenames in a directory (or just the name of a given
 1930  
      * file, which is not particularly useful).  This information is obtained
 1931  
      * through the NLST command.  If the given pathname is a directory and
 1932  
      * contains no files,  a zero length array is returned only
 1933  
      * if the FTP server returned a positive completion code, otherwise
 1934  
      * null is returned (the FTP server returned a 550 error No files found.).
 1935  
      * If the directory is not empty, an array of filenames in the directory is
 1936  
      * returned. If the pathname corresponds
 1937  
      * to a file, only that file will be listed.  The server may or may not
 1938  
      * expand glob expressions.
 1939  
      * <p>
 1940  
      * @param pathname  The file or directory to list.
 1941  
      * @return The list of filenames contained in the given path.  null if
 1942  
      *     the list could not be obtained.  If there are no filenames in
 1943  
      *     the directory, a zero-length array is returned.
 1944  
      * @exception FTPConnectionClosedException
 1945  
      *      If the FTP server prematurely closes the connection as a result
 1946  
      *      of the client being idle or some other reason causing the server
 1947  
      *      to send FTP reply code 421.  This exception may be caught either
 1948  
      *      as an IOException or independently as itself.
 1949  
      * @exception IOException  If an I/O error occurs while either sending a
 1950  
      *      command to the server or receiving a reply from the server.
 1951  
      ***/
 1952  
     public String[] listNames(String pathname) throws IOException
 1953  
     {
 1954  
         String line;
 1955  
         Socket socket;
 1956  
         BufferedReader reader;
 1957  
         Vector results;
 1958  
 
 1959  0
         if ((socket = _openDataConnection_(FTPCommand.NLST, pathname)) == null)
 1960  0
             return null;
 1961  
 
 1962  0
         reader =
 1963  
             new BufferedReader(class="keyword">new InputStreamReader(socket.getInputStream(), getControlEncoding()));
 1964  
 
 1965  0
         results = new Vector();
 1966  0
         while ((line = reader.readLine()) != null)
 1967  0
             results.addElement(line);
 1968  0
         reader.close();
 1969  0
         socket.close();
 1970  
 
 1971  0
         if (completePendingCommand())
 1972  
         {
 1973  
             String[] result;
 1974  0
             result = new String[results.size()];
 1975  0
             results.copyInto(result);
 1976  0
             return result;
 1977  
         }
 1978  
 
 1979  0
         return null;
 1980  
     }
 1981  
 
 1982  
 
 1983  
     /***
 1984  
      * Obtain a list of filenames in the current working directory
 1985  
      * This information is obtained through the NLST command.  If the current
 1986  
      * directory contains no files, a zero length array is returned only
 1987  
      * if the FTP server returned a positive completion code, otherwise,
 1988  
      * null is returned (the FTP server returned a 550 error No files found.).
 1989  
      * If the directory is not empty, an array of filenames in the directory is
 1990  
      * returned.
 1991  
      * <p>
 1992  
      * @return The list of filenames contained in the current working
 1993  
      *     directory.  null if the list could not be obtained.
 1994  
      *     If there are no filenames in the directory, a zero-length array
 1995  
      *     is returned.
 1996  
      * @exception FTPConnectionClosedException
 1997  
      *      If the FTP server prematurely closes the connection as a result
 1998  
      *      of the client being idle or some other reason causing the server
 1999  
      *      to send FTP reply code 421.  This exception may be caught either
 2000  
      *      as an IOException or independently as itself.
 2001  
      * @exception IOException  If an I/O error occurs while either sending a
 2002  
      *      command to the server or receiving a reply from the server.
 2003  
      ***/
 2004  
     public String[] listNames() throws IOException
 2005  
     {
 2006  0
         return listNames(null);
 2007  
     }
 2008  
 
 2009  
 
 2010  
     /**
 2011  
      * Using the supplied <code>parserKey</code>, obtain a list
 2012  
      * of file information for the current working directory or for just a
 2013  
      * single file.
 2014  
      * <p>
 2015  
      * If <code>key</code> is null, this object will try to autodetect
 2016  
      * the system-type/parser-type by calling the SYST command.
 2017  
      * <p>
 2018  
      * Under the DefaultFTPFileEntryParserFactory, which is used unless a
 2019  
      * different factory has been specified, the key
 2020  
      * can be either a recognized System type for which a parser has been
 2021  
      * defined, or the fully qualified class name of a class that implements
 2022  
      * org.apache.commons.net.ftp.FTPFileEntryParser.
 2023  
      * <p>
 2024  
      * This information is obtained through the LIST command.  The contents of
 2025  
      * the returned array is determined by the<code> FTPFileEntryParser </code>
 2026  
      * used.
 2027  
      * <p>
 2028  
      * @param parserKey This is a "handle" which the parser factory used
 2029  
      *                  must be able to resolve into a class implementing
 2030  
      *                  FTPFileEntryParser.
 2031  
      *                  <p>
 2032  
      *                  In the DefaultFTPFileEntryParserFactory, this
 2033  
      *                  may either be a specific key identifying a server type,
 2034  
      *                  which is used to identify a parser type,
 2035  
      *                  or the fully qualified class name of the parser.  See
 2036  
      *                  DefaultFTPFileEntryParserFactory.createFileEntryParser
 2037  
      *                  for full details.
 2038  
      *                  <p>
 2039  
      *                  If this parameter is null, will attempt to generate a key
 2040  
      *                  by running the SYST command.  This should cause no problem
 2041  
      *                  with the functionality implemented in the
 2042  
      *                  DefaultFTPFileEntryParserFactory, but may not map so well
 2043  
      *                  to an alternative user-created factory.  If that is the
 2044  
      *                  case, calling this routine with a null parameter and a
 2045  
      *                  custom parser factory may not be advisable.
 2046  
      *                  <p>
 2047  
      * @param pathname  The file or directory to list.  Since the server may
 2048  
      *                  or may not expand glob expressions, using them here
 2049  
      *                  is not recommended and may well cause this method to
 2050  
      *                  fail.
 2051  
      *
 2052  
      * @return The list of file information contained in the given path in
 2053  
      *         the format determined by the parser represented by the
 2054  
      *         <code> parserKey </code> parameter.
 2055  
      *         <p><b> 
 2056  
      * 		   NOTE:</b> This array may contain null members if any of the 
 2057  
      *         individual file listings failed to parse.  The caller should 
 2058  
      *         check each entry for null before referencing it.
 2059  
      * @exception FTPConnectionClosedException
 2060  
      *                   If the FTP server prematurely closes the connection
 2061  
      *                   as a result of the client being idle or some other
 2062  
      *                   reason causing the server to send FTP reply code 421.
 2063  
      *                   This exception may be caught either as an IOException
 2064  
      *                   or independently as itself.
 2065  
      * @exception IOException
 2066  
      *                   If an I/O error occurs while either sending a
 2067  
      *                   command to the server or receiving a reply
 2068  
      *                   from the server.
 2069  
      * @exception ParserInitializationException
 2070  
      *                   Thrown if the parserKey parameter cannot be
 2071  
      *                   resolved by the selected parser factory.
 2072  
      *                   In the DefaultFTPEntryParserFactory, this will
 2073  
      *                   happen when parserKey is neither
 2074  
      *                   the fully qualified class name of a class
 2075  
      *                   implementing the interface
 2076  
      *                   org.apache.commons.net.ftp.FTPFileEntryParser
 2077  
      *                   nor a string containing one of the recognized keys
 2078  
      *                   mapping to such a parser or if class loader
 2079  
      *                   security issues prevent its being loaded.
 2080  
      * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
 2081  
      * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
 2082  
      * @see org.apache.commons.net.ftp.FTPFileEntryParser
 2083  
      * @deprecated use {@link  #listFiles()  listFiles()} or 
 2084  
      * {@link  #listFiles(String)  listFiles(String)} instead and specify the
 2085  
      * parser Key in an {@link  #FTPClientConfig  FTPClientConfig} object instead.
 2086  
      */
 2087  
     public FTPFile[] listFiles(String parserKey, String pathname)
 2088  
     throws IOException
 2089  
     {
 2090  0
         FTPListParseEngine engine =
 2091  
             initiateListParsing(parserKey, pathname);
 2092  0
         return engine.getFiles();
 2093  
     }
 2094  
 
 2095  
 
 2096  
     /**
 2097  
      * Using the default system autodetect mechanism, obtain a
 2098  
      * list of file information for the current working directory
 2099  
      * or for just a single file.
 2100  
      * <p>
 2101  
      * This information is obtained through the LIST command.  The contents of
 2102  
      * the returned array is determined by the<code> FTPFileEntryParser </code>
 2103  
      * used.
 2104  
      * <p>
 2105  
      * @param pathname  The file or directory to list.  Since the server may
 2106  
      *                  or may not expand glob expressions, using them here
 2107  
      *                  is not recommended and may well cause this method to
 2108  
      *                  fail.
 2109  
      *
 2110  
      * @return The list of file information contained in the given path in
 2111  
      *         the format determined by the autodetection mechanism
 2112  
      * @exception FTPConnectionClosedException
 2113  
      *                   If the FTP server prematurely closes the connection
 2114  
      *                   as a result of the client being idle or some other
 2115  
      *                   reason causing the server to send FTP reply code 421.
 2116  
      *                   This exception may be caught either as an IOException
 2117  
      *                   or independently as itself.
 2118  
      * @exception IOException
 2119  
      *                   If an I/O error occurs while either sending a
 2120  
      *                   command to the server or receiving a reply
 2121  
      *                   from the server.
 2122  
      * @exception ParserInitializationException
 2123  
      *                   Thrown if the parserKey parameter cannot be
 2124  
      *                   resolved by the selected parser factory.
 2125  
      *                   In the DefaultFTPEntryParserFactory, this will
 2126  
      *                   happen when parserKey is neither
 2127  
      *                   the fully qualified class name of a class
 2128  
      *                   implementing the interface
 2129  
      *                   org.apache.commons.net.ftp.FTPFileEntryParser
 2130  
      *                   nor a string containing one of the recognized keys
 2131  
      *                   mapping to such a parser or if class loader
 2132  
      *                   security issues prevent its being loaded.
 2133  
      * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
 2134  
      * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
 2135  
      * @see org.apache.commons.net.ftp.FTPFileEntryParser
 2136  
      */
 2137  
     public FTPFile[] listFiles(String pathname)
 2138  
     throws IOException
 2139  
     {
 2140  0
         String key = null;
 2141  0
         FTPListParseEngine engine =
 2142  
             initiateListParsing(key, pathname);
 2143  0
         return engine.getFiles();
 2144  
 
 2145  
     }
 2146  
     /**
 2147  
      * Using the default system autodetect mechanism, obtain a
 2148  
      * list of file information for the current working directory.
 2149  
      * <p>
 2150  
      * This information is obtained through the LIST command.  The contents of
 2151  
      * the returned array is determined by the<code> FTPFileEntryParser </code>
 2152  
      * used.
 2153  
      * <p>
 2154  
      * @return The list of file information contained in the current directory
 2155  
      *         in the format determined by the autodetection mechanism.  
 2156  
      *         <p><b> 
 2157  
      * 		   NOTE:</b> This array may contain null members if any of the 
 2158  
      *         individual file listings failed to parse.  The caller should 
 2159  
      *         check each entry for null before referencing it.
 2160  
      * @exception FTPConnectionClosedException
 2161  
      *                   If the FTP server prematurely closes the connection
 2162  
      *                   as a result of the client being idle or some other
 2163  
      *                   reason causing the server to send FTP reply code 421.
 2164  
      *                   This exception may be caught either as an IOException
 2165  
      *                   or independently as itself.
 2166  
      * @exception IOException
 2167  
      *                   If an I/O error occurs while either sending a
 2168  
      *                   command to the server or receiving a reply
 2169  
      *                   from the server.
 2170  
      * @exception ParserInitializationException
 2171  
      *                   Thrown if the parserKey parameter cannot be
 2172  
      *                   resolved by the selected parser factory.
 2173  
      *                   In the DefaultFTPEntryParserFactory, this will
 2174  
      *                   happen when parserKey is neither
 2175  
      *                   the fully qualified class name of a class
 2176  
      *                   implementing the interface
 2177  
      *                   org.apache.commons.net.ftp.FTPFileEntryParser
 2178  
      *                   nor a string containing one of the recognized keys
 2179  
      *                   mapping to such a parser or if class loader
 2180  
      *                   security issues prevent its being loaded.
 2181  
      * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
 2182  
      * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
 2183  
      * @see org.apache.commons.net.ftp.FTPFileEntryParser
 2184  
      */
 2185  
     public FTPFile[] listFiles()
 2186  
     throws IOException
 2187  
     {
 2188  0
         return listFiles((String) null);
 2189  
     }
 2190  
 
 2191  
     /**
 2192  
      * Using the default autodetect mechanism, initialize an FTPListParseEngine
 2193  
      * object containing a raw file information for the current working
 2194  
      * directory on the server
 2195  
      * This information is obtained through the LIST command.  This object
 2196  
      * is then capable of being iterated to return a sequence of FTPFile
 2197  
      * objects with information filled in by the
 2198  
      * <code> FTPFileEntryParser </code> used.
 2199  
      * <p>
 2200  
      * This method differs from using the listFiles() methods in that
 2201  
      * expensive FTPFile objects are not created until needed which may be
 2202  
      * an advantage on large lists.
 2203  
      *
 2204  
      * @return A FTPListParseEngine object that holds the raw information and
 2205  
      * is capable of providing parsed FTPFile objects, one for each file
 2206  
      * containing information contained in the given path in the format
 2207  
      * determined by the <code> parser </code> parameter.   Null will be
 2208  
      * returned if a data connection cannot be opened.  If the current working
 2209  
      * directory contains no files, an empty array will be the return.
 2210  
      *
 2211  
      * @exception FTPConnectionClosedException
 2212  
      *                   If the FTP server prematurely closes the connection as a result
 2213  
      *                   of the client being idle or some other reason causing the server
 2214  
      *                   to send FTP reply code 421.  This exception may be caught either
 2215  
      *                   as an IOException or independently as itself.
 2216  
      * @exception IOException
 2217  
      *                   If an I/O error occurs while either sending a
 2218  
      *                   command to the server or receiving a reply from the server.
 2219  
      * @exception ParserInitializationException
 2220  
      *                   Thrown if the autodetect mechanism cannot
 2221  
      *                   resolve the type of system we are connected with.
 2222  
      * @see FTPListParseEngine
 2223  
      */
 2224  
     public FTPListParseEngine initiateListParsing()
 2225  
     throws IOException
 2226  
     {
 2227  0
         return initiateListParsing((String) null);
 2228  
     }
 2229  
 
 2230  
     /**
 2231  
      * Using the default autodetect mechanism, initialize an FTPListParseEngine
 2232  
      * object containing a raw file information for the supplied directory.
 2233  
      * This information is obtained through the LIST command.  This object
 2234  
      * is then capable of being iterated to return a sequence of FTPFile
 2235  
      * objects with information filled in by the
 2236  
      * <code> FTPFileEntryParser </code> used.
 2237  
      * <p>
 2238  
      * The server may or may not expand glob expressions.  You should avoid
 2239  
      * using glob expressions because the return format for glob listings
 2240  
      * differs from server to server and will likely cause this method to fail.
 2241  
      * <p>
 2242  
      * This method differs from using the listFiles() methods in that
 2243  
      * expensive FTPFile objects are not created until needed which may be
 2244  
      * an advantage on large lists.
 2245  
      * <p>
 2246  
      * <pre>
 2247  
      *    FTPClient f=FTPClient();
 2248  
      *    f.connect(server);
 2249  
      *    f.login(username, password);
 2250  
      *    FTPListParseEngine engine = f.initiateListParsing(directory);
 2251  
      *
 2252  
      *    while (engine.hasNext()) {
 2253  
      *       FTPFile[] files = engine.getNext(25);  // "page size" you want
 2254  
      *       //do whatever you want with these files, display them, etc.
 2255  
      *       //expensive FTPFile objects not created until needed.
 2256  
      *    }
 2257  
      * </pre>
 2258  
      *
 2259  
      * @return A FTPListParseEngine object that holds the raw information and
 2260  
      * is capable of providing parsed FTPFile objects, one for each file
 2261  
      * containing information contained in the given path in the format
 2262  
      * determined by the <code> parser </code> parameter.   Null will be
 2263  
      * returned if a data connection cannot be opened.  If the current working
 2264  
      * directory contains no files, an empty array will be the return.
 2265  
      *
 2266  
      * @exception FTPConnectionClosedException
 2267  
      *                   If the FTP server prematurely closes the connection as a result
 2268  
      *                   of the client being idle or some other reason causing the server
 2269  
      *                   to send FTP reply code 421.  This exception may be caught either
 2270  
      *                   as an IOException or independently as itself.
 2271  
      * @exception IOException
 2272  
      *                   If an I/O error occurs while either sending a
 2273  
      *                   command to the server or receiving a reply from the server.
 2274  
      * @exception ParserInitializationException
 2275  
      *                   Thrown if the autodetect mechanism cannot
 2276  
      *                   resolve the type of system we are connected with.
 2277  
      * @see FTPListParseEngine
 2278  
      */
 2279  
     public FTPListParseEngine initiateListParsing(
 2280  
             String pathname)
 2281  
     throws IOException
 2282  
     {
 2283  0
         String key = null;
 2284  0
         return initiateListParsing(key, pathname);
 2285  
     }
 2286  
 
 2287  
     /**
 2288  
      * Using the supplied parser key, initialize an FTPListParseEngine
 2289  
      * object containing a raw file information for the supplied directory.
 2290  
      * This information is obtained through the LIST command.  This object
 2291  
      * is then capable of being iterated to return a sequence of FTPFile
 2292  
      * objects with information filled in by the
 2293  
      * <code> FTPFileEntryParser </code> used.
 2294  
      * <p>
 2295  
      * The server may or may not expand glob expressions.  You should avoid
 2296  
      * using glob expressions because the return format for glob listings
 2297  
      * differs from server to server and will likely cause this method to fail.
 2298  
      * <p>
 2299  
      * This method differs from using the listFiles() methods in that
 2300  
      * expensive FTPFile objects are not created until needed which may be
 2301  
      * an advantage on large lists.
 2302  
      *
 2303  
      * @param parserKey A string representing a designated code or fully-qualified
 2304  
      * class name of an  <code> FTPFileEntryParser </code> that should be
 2305  
      *               used to parse each server file listing.
 2306  
      *
 2307  
      * @return A FTPListParseEngine object that holds the raw information and
 2308  
      * is capable of providing parsed FTPFile objects, one for each file
 2309  
      * containing information contained in the given path in the format
 2310  
      * determined by the <code> parser </code> parameter.   Null will be
 2311  
      * returned if a data connection cannot be opened.  If the current working
 2312  
      * directory contains no files, an empty array will be the return.
 2313  
      *
 2314  
      * @exception FTPConnectionClosedException
 2315  
      *                   If the FTP server prematurely closes the connection as a result
 2316  
      *                   of the client being idle or some other reason causing the server
 2317  
      *                   to send FTP reply code 421.  This exception may be caught either
 2318  
      *                   as an IOException or independently as itself.
 2319  
      * @exception IOException
 2320  
      *                   If an I/O error occurs while either sending a
 2321  
      *                   command to the server or receiving a reply from the server.
 2322  
      * @exception ParserInitializationException
 2323  
      *                   Thrown if the parserKey parameter cannot be
 2324  
      *                   resolved by the selected parser factory.
 2325  
      *                   In the DefaultFTPEntryParserFactory, this will
 2326  
      *                   happen when parserKey is neither
 2327  
      *                   the fully qualified class name of a class
 2328  
      *                   implementing the interface
 2329  
      *                   org.apache.commons.net.ftp.FTPFileEntryParser
 2330  
      *                   nor a string containing one of the recognized keys
 2331  
      *                   mapping to such a parser or if class loader
 2332  
      *                   security issues prevent its being loaded.
 2333  
      * @see FTPListParseEngine
 2334  
      */
 2335  
     public FTPListParseEngine initiateListParsing(
 2336  
             String parserKey, String pathname)
 2337  
     throws IOException
 2338  
     {
 2339  
         // We cache the value to avoid creation of a new object every
 2340  
         // time a file listing is generated.
 2341  0
         if(__entryParser == null) {
 2342  0
             if (null != parserKey) {
 2343  
                 // if a parser key was supplied in the parameters, 
 2344  
                 // use that to create the paraser
 2345  0
         	    __entryParser = 
 2346  
         	        __parserFactory.createFileEntryParser(parserKey);
 2347  
                 
 2348  
             } else {
 2349  
 	            // if no parserKey was supplied, check for a configuration
 2350  
 	        	// in the params, and if non-null, use that.
 2351  0
             	if (null != __configuration) {
 2352  0
             	    __entryParser = 
 2353  
             	        __parserFactory.createFileEntryParser(__configuration);
 2354  
             	} else {
 2355  
                     // if a parserKey hasn't been supplied, and a configuration
 2356  
             	    // hasn't been supplied, then autodetect by calling
 2357  
                     // the SYST command and use that to choose the parser.
 2358  0
             	    __entryParser = 
 2359  
             	        __parserFactory.createFileEntryParser(getSystemName());
 2360  
              	}
 2361  
             }
 2362  
         }
 2363  
 
 2364  0
         return initiateListParsing(__entryParser, pathname);
 2365  
 
 2366  
     }
 2367  
 
 2368  
 
 2369  
     /**
 2370  
      * private method through which all listFiles() and
 2371  
      * initiateListParsing methods pass once a parser is determined.
 2372  
      *
 2373  
      * @exception FTPConnectionClosedException
 2374  
      *                   If the FTP server prematurely closes the connection as a result
 2375  
      *                   of the client being idle or some other reason causing the server
 2376  
      *                   to send FTP reply code 421.  This exception may be caught either
 2377  
      *                   as an IOException or independently as itself.
 2378  
      * @exception IOException
 2379  
      *                   If an I/O error occurs while either sending a
 2380  
      *                   command to the server or receiving a reply from the server.
 2381  
      * @see FTPListParseEngine
 2382  
      */
 2383  
     private FTPListParseEngine initiateListParsing(
 2384  
             FTPFileEntryParser parser, String pathname)
 2385  
     throws IOException
 2386  
     {
 2387  
         Socket socket;
 2388  
 
 2389  0
         FTPListParseEngine engine = new FTPListParseEngine(parser);
 2390  0
         if ((socket = _openDataConnection_(FTPCommand.LIST, pathname)) == null)
 2391  
         {
 2392  0
             return engine;
 2393  
         }
 2394  
 
 2395  
 
 2396  0
         engine.readServerList(socket.getInputStream(), getControlEncoding());
 2397  
 
 2398  0
         socket.close();
 2399  
 
 2400  0
         completePendingCommand();
 2401  0
         return engine;
 2402  
     }
 2403  
 
 2404  
     /***
 2405  
      * Issue the FTP STAT command to the server.
 2406  
      * <p>
 2407  
      * @return The status information returned by the server.
 2408  
      * @exception FTPConnectionClosedException
 2409  
      *      If the FTP server prematurely closes the connection as a result
 2410  
      *      of the client being idle or some other reason causing the server
 2411  
      *      to send FTP reply code 421.  This exception may be caught either
 2412  
      *      as an IOException or independently as itself.
 2413  
      * @exception IOException  If an I/O error occurs while either sending a
 2414  
      *      command to the server or receiving a reply from the server.
 2415  
      ***/
 2416  
     public String getStatus() throws IOException
 2417  
     {
 2418  0
         if (FTPReply.isPositiveCompletion(stat()))
 2419  0
             return getReplyString();
 2420  0
         return null;
 2421  
     }
 2422  
 
 2423  
 
 2424  
     /***
 2425  
      * Issue the FTP STAT command to the server for a given pathname.  This
 2426  
      * should produce a listing of the file or directory.
 2427  
      * <p>
 2428  
      * @return The status information returned by the server.
 2429  
      * @exception FTPConnectionClosedException
 2430  
      *      If the FTP server prematurely closes the connection as a result
 2431  
      *      of the client being idle or some other reason causing the server
 2432  
      *      to send FTP reply code 421.  This exception may be caught either
 2433  
      *      as an IOException or independently as itself.
 2434  
      * @exception IOException  If an I/O error occurs while either sending a
 2435  
      *      command to the server or receiving a reply from the server.
 2436  
      ***/
 2437  
     public String getStatus(String pathname) throws IOException
 2438  
     {
 2439  0
         if (FTPReply.isPositiveCompletion(stat(pathname)))
 2440  0
             return getReplyString();
 2441  0
         return null;
 2442  
     }
 2443  
 
 2444  
     /**
 2445  
      * Using a programmer specified <code> FTPFileListParser </code>, obtain a
 2446  
      * list of file information for a directory or information for
 2447  
      * just a single file.  This information is obtained through the LIST
 2448  
      * command.  The contents of the returned array is determined by the
 2449  
      * <code> FTPFileListParser </code> used.
 2450  
      * The server may or may not expand glob expressions.  You should avoid
 2451  
      * using glob expressions because the return format for glob listings
 2452  
      * differs from server to server and will likely cause this method to fail.
 2453  
      * <p>
 2454  
      * @param parser The <code> FTPFileListParser </code> that should be
 2455  
      *         used to parse the server file listing.
 2456  
      * @param pathname  The file or directory to list.
 2457  
      * @return The list of file information contained in the given path in
 2458  
      *         the format determined by the <code> parser </code> parameter.
 2459  
      *         <p><b> 
 2460  
      * 		   NOTE:</b> This array may contain null members if any of the 
 2461  
      *         individual file listings failed to parse.  The caller should 
 2462  
      *         check each entry for null before referencing it.
 2463  
      * @exception FTPConnectionClosedException
 2464  
      *      If the FTP server prematurely closes the connection as a result
 2465  
      *      of the client being idle or some other reason causing the server
 2466  
      *      to send FTP reply code 421.  This exception may be caught either
 2467  
      *      as an IOException or independently as itself.
 2468  
      * @exception IOException  If an I/O error occurs while either sending a
 2469  
      *      command to the server or receiving a reply from the server.
 2470  
      *
 2471  
      * @return The list of file information contained in the given path in
 2472  
      *         the format determined by<code> parserKey </code>parameter.
 2473  
      *         <p><b> 
 2474  
      * 		   NOTE:</b> This array may contain null members if any of the 
 2475  
      *         individual file listings failed to parse.  The caller should 
 2476  
      *         check each entry for null before referencing it.
 2477  
      *
 2478  
      * @exception IOException
 2479  
      * @since 5 Jan 2004
 2480  
      * @deprecated use listFiles(String parserKey, String pathname) instead
 2481  
      */
 2482  
     public FTPFile[] listFiles(FTPFileListParser parser, String pathname)
 2483  
     throws IOException
 2484  
     {
 2485  
         Socket socket;
 2486  
         FTPFile[] results;
 2487  
 
 2488  0
         if ((socket = _openDataConnection_(FTPCommand.LIST, pathname)) == null)
 2489  0
             return new FTPFile[0];
 2490  
 
 2491  0
         results = parser.parseFileList(socket.getInputStream(), getControlEncoding());
 2492  
 
 2493  0
         socket.close();
 2494  
 
 2495  0
         completePendingCommand();
 2496  
 
 2497  0
         return results;
 2498  
     }
 2499  
 
 2500  
 
 2501  
     /**
 2502  
      * Using a programmer specified <code> FTPFileListParser </code>,
 2503  
      * obtain a list of file information for the current working directory.
 2504  
      * This information is obtained through the LIST command.
 2505  
      * The contents of the array returned is determined by the
 2506  
      * <code> FTPFileListParser </code> used.
 2507  
      * <p>
 2508  
      *
 2509  
      * @param parser The <code> FTPFileListParser </code> that should be
 2510  
      *               used to parse the server file listing.
 2511  
      *
 2512  
      * @return The list of file information contained in the given path in
 2513  
      *         the format determined by the <code> parser </code> parameter.
 2514  
      *         <p><b> 
 2515  
      * 		   NOTE:</b> This array may contain null members if any of the 
 2516  
      *         individual file listings failed to parse.  The caller should 
 2517  
      *         check each entry for null before referencing it.
 2518  
      * @exception FTPConnectionClosedException
 2519  
      *                   If the FTP server prematurely closes the connection as a result
 2520  
      *                   of the client being idle or some other reason causing the server
 2521  
      *                   to send FTP reply code 421.  This exception may be caught either
 2522  
      *                   as an IOException or independently as itself.
 2523  
      * @exception IOException
 2524  
      *                   If an I/O error occurs while either sending a
 2525  
      *                   command to the server or receiving a reply from the server.
 2526  
      * @exception IOException
 2527  
      * @since 5 Jan 2004
 2528  
      * @deprecated use listFiles(String parserKey) instead.
 2529  
      */
 2530  
     public FTPFile[] listFiles(FTPFileListParser parser) throws IOException
 2531  
     {
 2532  0
         return listFiles(parser, null);
 2533  
     }
 2534  
 
 2535  
 
 2536  
     /**
 2537  
      * Using a programmer specified <code> FTPFileEntryParser </code>,
 2538  
      * initialize an object containing a raw file information for the
 2539  
      * current working directory.  This information is obtained through
 2540  
      * the LIST command.  This object is then capable of being iterated to
 2541  
      * return a sequence of FTPFile objects with information filled in by the
 2542  
      * <code> FTPFileEntryParser </code> used.
 2543  
      * <p>
 2544  
      * The server may or may not expand glob expressions.  You should avoid
 2545  
      * using glob expressions because the return format for glob listings
 2546  
      * differs from server to server and will likely cause this method to fail.
 2547  
      * <p>
 2548  
      * This method differs from using the listFiles() methods in that
 2549  
      * expensive FTPFile objects are not created until needed which may be
 2550  
      * an advantage on large lists.
 2551  
      *
 2552  
      * @param parser The <code> FTPFileEntryParser </code> that should be
 2553  
      *               used to parse each server file listing.
 2554  
      *
 2555  
      * @return An iteratable object that holds the raw information and is
 2556  
      *         capable of providing parsed FTPFile objects, one for each file containing
 2557  
      *         information contained in the given path in the format determined by the
 2558  
      *         <code> parser </code> parameter.   Null will be returned if a
 2559  
      *         data connection cannot be opened.  If the current working directory
 2560  
      *         contains no files, an empty array will be the return.
 2561  
      * <pre>
 2562  
      *    FTPClient f=FTPClient();
 2563  
      *    f.connect(server);
 2564  
      *    f.login(username, password);
 2565  
      *    FTPFileList list = f.createFileList(directory, parser);
 2566  
      *    FTPFileIterator iter = list.iterator();
 2567  
      *
 2568  
      *    while (iter.hasNext()) {
 2569  
      *       FTPFile[] files = iter.getNext(25);  // "page size" you want
 2570  
      *       //do whatever you want with these files, display them, etc.
 2571  
      *       //expensive FTPFile objects not created until needed.
 2572  
      *    }
 2573  
      * </pre>
 2574  
      *
 2575  
      * @exception FTPConnectionClosedException
 2576  
      *                   If the FTP server prematurely closes the connection as a result
 2577  
      *                   of the client being idle or some other reason causing the server
 2578  
      *                   to send FTP reply code 421.  This exception may be caught either
 2579  
      *                   as an IOException or independently as itself.
 2580  
      * @exception IOException
 2581  
      *                   If an I/O error occurs while either sending a
 2582  
      *                   command to the server or receiving a reply from the server.
 2583  
      * @deprecated - use initiateListParsing(FTPFileEntryParser) method instead.
 2584  
      * @see FTPFileList
 2585  
      */
 2586  
     public FTPFileList createFileList(FTPFileEntryParser parser) throws IOException
 2587  
     {
 2588  0
         return createFileList(null, parser);
 2589  
     }
 2590  
 
 2591  
     /**
 2592  
      * Using a programmer specified <code> FTPFileEntryParser </code>,
 2593  
      * initialize an object containing a raw file information for a directory
 2594  
      * or information for a single file.  This information is obtained through
 2595  
      * the LIST command.  This object is then capable of being iterated to
 2596  
      * return a sequence of FTPFile objects with information filled in by the
 2597  
      * <code> FTPFileEntryParser </code> used.
 2598  
      * The server may or may not expand glob expressions.  You should avoid
 2599  
      * using glob expressions because the return format for glob listings
 2600  
      * differs from server to server and will likely cause this method to fail.
 2601  
      * <p>
 2602  
      * @param parser The <code> FTPFileEntryParser </code> that should be
 2603  
      *         used to parse each server file listing.
 2604  
      * @param pathname  The file or directory to list.
 2605  
      * @return An iteratable object that holds the raw information and is
 2606  
      * capable of providing parsed FTPFile objects, one for each file containing
 2607  
      * information contained in the given path in the format determined by the
 2608  
      * <code> parser </code> parameter.  Null will be returned if a
 2609  
      * data connection cannot be opened.  If the supplied path contains
 2610  
      * no files, an empty array will be the return.
 2611  
      * @exception FTPConnectionClosedException
 2612  
      *      If the FTP server prematurely closes the connection as a result
 2613  
      *      of the client being idle or some other reason causing the server
 2614  
      *      to send FTP reply code 421.  This exception may be caught either
 2615  
      *      as an IOException or independently as itself.
 2616  
      * @exception IOException  If an I/O error occurs while either sending a
 2617  
      *      command to the server or receiving a reply from the server.
 2618  
      * @deprecated - use initiateListParsing(String, FTPFileEntryParser)
 2619  
      * method instead.
 2620  
      * @see FTPFileList
 2621  
      */
 2622  
     public FTPFileList createFileList(String pathname,
 2623  
             FTPFileEntryParser parser)
 2624  
     throws IOException
 2625  
     {
 2626  
         Socket socket;
 2627  
 
 2628  0
         if ((socket = _openDataConnection_(FTPCommand.LIST, pathname)) == null)
 2629  
         {
 2630  0
             return null;
 2631  
         }
 2632  
 
 2633  0
         FTPFileList list = FTPFileList.create(socket.getInputStream(), parser);
 2634  
 
 2635  0
         socket.close();
 2636  
 
 2637  0
         completePendingCommand();
 2638  0
         return list;
 2639  
     }
 2640  
     
 2641  
     /**
 2642  
      * Set the internal buffer size.
 2643  
      *  
 2644  
      * @param bufSize The size of the buffer
 2645  
      */
 2646  
     public void setBufferSize(int bufSize) {
 2647  0
     	__bufferSize = bufSize;
 2648  0
     }
 2649  
     
 2650  
     /**
 2651  
      * Retrieve the current internal buffer size.
 2652  
      * @return The current buffer size.
 2653  
      */
 2654  
     public int getBufferSize() {
 2655  0
     	return __bufferSize;
 2656  
     }
 2657  
 
 2658  
 
 2659  
     /** 
 2660  
      * Implementation of the {@link Configurable Configurable} interface. 
 2661  
      * In the case of this class, configuring merely makes the config object available for the
 2662  
      * factory methods that construct parsers.
 2663  
      * @param config {@link FTPClientConfig FTPClientConfig} object used to 
 2664  
      * provide non-standard configurations to the parser.
 2665  
      * @since 1.4
 2666  
      */
 2667  
     public void configure(FTPClientConfig config) {
 2668  0
     	this.__configuration = config;
 2669  0
     }
 2670  
     
 2671  
 }
 2672  
 
 2673  
 /* Emacs configuration
 2674  
  * Local variables:        **
 2675  
  * mode:             java  **
 2676  
  * c-basic-offset:   4     **
 2677  
  * indent-tabs-mode: nil   **
 2678  
  * End:                    **
 2679  
  */

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