| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.apache.commons.net.SocketClient
org.apache.commons.net.ftp.FTP
org.apache.commons.net.ftp.FTPClient
public class FTPClient
FTPClient encapsulates all the functionality necessary to store and
 retrieve files from an FTP server.  This class takes care of all
 low level details of interacting with an FTP server and provides
 a convenient higher level interface.  As with all classes derived
 from SocketClient,
 you must first connect to the server with
 connect 
 before doing anything, and finally
 disconnect 
 after you're completely finished interacting with the server.
 Then you need to check the FTP reply code to see if the connection
 was successful.  For example:
 
    boolean error = false;
    try {
      int reply;
      ftp.connect("ftp.foobar.com");
      System.out.println("Connected to " + server + ".");
      System.out.print(ftp.getReplyString());
      // After connection attempt, you should check the reply code to verify
      // success.
      reply = ftp.getReplyCode();
      if(!FTPReply.isPositiveCompletion(reply)) {
        ftp.disconnect();
        System.err.println("FTP server refused connection.");
        System.exit(1);
      }
      ... // transfer files
      ftp.logout();
    } catch(IOException e) {
      error = true;
      e.printStackTrace();
    } finally {
      if(ftp.isConnected()) {
        try {
          ftp.disconnect();
        } catch(IOException ioe) {
          // do nothing
        }
      }
      System.exit(error ? 1 : 0);
    }
 
 
 Immediately after connecting is the only real time you need to check the
 reply code (because connect is of type void).  The convention for all the
 FTP command methods in FTPClient is such that they either return a
 boolean value or some other value.
 The boolean methods return true on a successful completion reply from
 the FTP server and false on a reply resulting in an error condition or
 failure.  The methods returning a value other than boolean return a value
 containing the higher level data produced by the FTP command, or null if a
 reply resulted in an error condition or failure.  If you want to access
 the exact FTP reply code causing a success or failure, you must call
 getReplyCode  after
 a success or failure.
 
 The default settings for FTPClient are for it to use
  FTP.ASCII_FILE_TYPE ,
  FTP.NON_PRINT_TEXT_FORMAT ,
  FTP.STREAM_TRANSFER_MODE , and
  FTP.FILE_STRUCTURE .  The only file types directly supported
 are  FTP.ASCII_FILE_TYPE  and
  FTP.BINARY_FILE_TYPE .  Because there are at least 4
 different EBCDIC encodings, we have opted not to provide direct support
 for EBCDIC.  To transfer EBCDIC and other unsupported file types you
 must create your own filter InputStreams and OutputStreams and wrap
 them around the streams returned or required by the FTPClient methods.
 FTPClient uses the NetASCII  
 filter streams to provide transparent handling of ASCII files.  We will 
 consider incorporating EBCDIC support if there is enough demand.
 
  FTP.NON_PRINT_TEXT_FORMAT ,
  FTP.STREAM_TRANSFER_MODE , and
  FTP.FILE_STRUCTURE  are the only supported formats,
 transfer modes, and file structures.
 
Because the handling of sockets on different platforms can differ significantly, the FTPClient automatically issues a new PORT command prior to every transfer requiring that the server connect to the client's data port. This ensures identical problem-free behavior on Windows, Unix, and Macintosh platforms. Additionally, it relieves programmers from having to issue the PORT command themselves and dealing with platform dependent issues.
 Additionally, for security purposes, all data connections to the
 client are verified to ensure that they originated from the intended
 party (host and port).  If a data connection is initiated by an unexpected
 party, the command will close the socket and throw an IOException.  You
 may disable this behavior with
 setRemoteVerificationEnabled().
 
 You should keep in mind that the FTP server may choose to prematurely
 close a connection if the client has been idle for longer than a
 given time period (usually 900 seconds).  The FTPClient class will detect a
 premature FTP server connection closing when it receives a
 FTPReply.SERVICE_NOT_AVAILABLE 
  response to a command.
 When that occurs, the FTP class method encountering that reply will throw
 an FTPConnectionClosedException
 .
 FTPConnectionClosedException
 is a subclass of  IOException  and therefore need not be
 caught separately, but if you are going to catch it separately, its
 catch block must appear before the more general  IOException 
 catch block.  When you encounter an
 FTPConnectionClosedException
 , you must disconnect the connection with
 disconnect()  to properly clean up the
 system resources used by FTPClient.  Before disconnecting, you may check the
 last reply code and text with
 getReplyCode ,
 getReplyString ,
 and
 getReplyStrings.
 You may avoid server disconnections while the client is idle by
 periodicaly sending NOOP commands to the server.
 
 Rather than list it separately for each method, we mention here that
 every method communicating with the server and throwing an IOException
 can also throw a
 MalformedServerReplyException
 , which is a subclass
 of IOException.  A MalformedServerReplyException will be thrown when
 the reply received from the server deviates enough from the protocol
 specification that it cannot be interpreted in a useful manner despite
 attempts to be as lenient as possible.
 
Listing API Examples Both paged and unpaged examples of directory listings are available, as follows:
Unpaged (whole list) access, using a parser accessible by auto-detect:
    FTPClient f=FTPClient();
    f.connect(server);
    f.login(username, password);
    FTPFile[] files = listFiles(directory);
 
 Paged access, using a parser not accessible by auto-detect. The class defined in the first parameter of initateListParsing should be derived from org.apache.commons.net.FTPFileEntryParser:
    FTPClient f=FTPClient();
    f.connect(server);
    f.login(username, password);
    FTPListParseEngine engine =
       f.initiateListParsing("com.whatever.YourOwnParser", directory);
    while (engine.hasNext()) {
       FTPFile[] files = engine.getNext(25);  // "page size" you want
       //do whatever you want with these files, display them, etc.
       //expensive FTPFile objects not created until needed.
    }
 
 Paged access, using a parser accessible by auto-detect:
    FTPClient f=FTPClient();
    f.connect(server);
    f.login(username, password);
    FTPListParseEngine engine = f.initiateListParsing(directory);
    while (engine.hasNext()) {
       FTPFile[] files = engine.getNext(25);  // "page size" you want
       //do whatever you want with these files, display them, etc.
       //expensive FTPFile objects not created until needed.
    }
 
 For examples of using FTPClient on servers whose directory listings
MM d yyyyFTPClientConfig.
 
FTP, 
FTPConnectionClosedException, 
FTPFileEntryParser, 
FTPFileEntryParserFactory, 
DefaultFTPFileEntryParserFactory, 
FTPClientConfig, 
MalformedServerReplyException| Field Summary | |
|---|---|
| static int | ACTIVE_LOCAL_DATA_CONNECTION_MODEA constant indicating the FTP session is expecting all transfers to occur between the client (local) and server and that the server should connect to the client's data port to initiate a data transfer. | 
| static int | ACTIVE_REMOTE_DATA_CONNECTION_MODEA constant indicating the FTP session is expecting all transfers to occur between two remote servers and that the server the client is connected to should connect to the other server's data port to initiate a data transfer. | 
| static int | PASSIVE_LOCAL_DATA_CONNECTION_MODEA constant indicating the FTP session is expecting all transfers to occur between the client (local) and server and that the server is in passive mode, requiring the client to connect to the server's data port to initiate a transfer. | 
| static int | PASSIVE_REMOTE_DATA_CONNECTION_MODEA constant indicating the FTP session is expecting all transfers to occur between two remote servers and that the server the client is connected to is in passive mode, requiring the other server to connect to the first server's data port to initiate a data transfer. | 
| Fields inherited from class org.apache.commons.net.SocketClient | 
|---|
| _defaultPort_, _input_, _output_, _serverSocketFactory_, _socket_, _socketFactory_, _timeout_, connectTimeout, NETASCII_EOL | 
| Constructor Summary | |
|---|---|
| FTPClient()Default FTPClient constructor. | |
| Method Summary | |
|---|---|
| protected  void | _connectAction_()Initiates control connections and gets initial reply. | 
| protected  Socket | _openDataConnection_(int command,
                                         String arg)Establishes a data connection with the FTP server, returning a Socket for the connection if successful. | 
|  boolean | abort()Abort a transfer in progress. | 
|  boolean | allocate(int bytes)Reserve a number of bytes on the server for the next file transfer. | 
|  boolean | allocate(int bytes,
                 int recordSize)Reserve space on the server for the next file transfer. | 
|  boolean | appendFile(String remote,
                     InputStream local)Appends to a file on the server with the given name, taking input from the given InputStream. | 
|  OutputStream | appendFileStream(String remote)Returns an OutputStream through which data can be written to append to a file on the server with the given name. | 
|  boolean | changeToParentDirectory()Change to the parent directory of the current working directory. | 
|  boolean | changeWorkingDirectory(String pathname)Change the current working directory of the FTP session. | 
|  boolean | completePendingCommand()There are a few FTPClient methods that do not complete the entire sequence of FTP commands to complete a transaction. | 
|  void | configure(FTPClientConfig config)Implementation of the Configurableinterface. | 
|  boolean | deleteFile(String pathname)Deletes a file on the FTP server. | 
|  void | disconnect()Closes the connection to the FTP server and restores connection parameters to the default values. | 
|  void | enterLocalActiveMode()Set the current data connection mode to ACTIVE_LOCAL_DATA_CONNECTION_MODE. | 
|  void | enterLocalPassiveMode()Set the current data connection mode to  PASSIVE_LOCAL_DATA_CONNECTION_MODE . | 
|  boolean | enterRemoteActiveMode(InetAddress host,
                                           int port)Set the current data connection mode to  ACTIVE_REMOTE_DATA_CONNECTION . | 
|  boolean | enterRemotePassiveMode()Set the current data connection mode to  PASSIVE_REMOTE_DATA_CONNECTION_MODE . | 
|  int | getBufferSize()Retrieve the current internal buffer size. | 
|  int | getDataConnectionMode()Returns the current data connection mode (one of the  _DATA_CONNECTION_MODE constants. | 
| protected  String | getListArguments(String pathname) | 
|  boolean | getListHiddenFiles() | 
|  String | getModificationTime(String pathname)Issue the FTP MDTM command (not supported by all servers to retrieve the last modification time of a file. | 
|  String | getPassiveHost()Returns the hostname or IP address (in the form of a string) returned by the server when entering passive mode. | 
|  int | getPassivePort()If in passive mode, returns the data port of the passive host. | 
|  long | getRestartOffset()Fetches the restart offset. | 
|  String | getStatus()Issue the FTP STAT command to the server. | 
|  String | getStatus(String pathname)Issue the FTP STAT command to the server for a given pathname. | 
|  String | getSystemName()Fetches the system type name from the server and returns the string. | 
|  FTPListParseEngine | initiateListParsing()Using the default autodetect mechanism, initialize an FTPListParseEngine object containing a raw file information for the current working directory on the server This information is obtained through the LIST command. | 
|  FTPListParseEngine | initiateListParsing(String pathname)Using the default autodetect mechanism, initialize an FTPListParseEngine object containing a raw file information for the supplied directory. | 
|  FTPListParseEngine | initiateListParsing(String parserKey,
                                       String pathname)Using the supplied parser key, initialize an FTPListParseEngine object containing a raw file information for the supplied directory. | 
|  boolean | isRemoteVerificationEnabled()Return whether or not verification of the remote host participating in data connections is enabled. | 
|  FTPFile[] | listFiles()Using the default system autodetect mechanism, obtain a list of file information for the current working directory. | 
|  FTPFile[] | listFiles(String pathname)Using the default system autodetect mechanism, obtain a list of file information for the current working directory or for just a single file. | 
|  String | listHelp()Fetches the system help information from the server and returns the full string. | 
|  String | listHelp(String command)Fetches the help information for a given command from the server and returns the full string. | 
|  String[] | listNames()Obtain a list of filenames in the current working directory This information is obtained through the NLST command. | 
|  String[] | listNames(String pathname)Obtain a list of filenames in a directory (or just the name of a given file, which is not particularly useful). | 
|  boolean | login(String username,
           String password)Login to the FTP server using the provided username and password. | 
|  boolean | login(String username,
           String password,
           String account)Login to the FTP server using the provided username, password, and account. | 
|  boolean | logout()Logout of the FTP server by sending the QUIT command. | 
|  boolean | makeDirectory(String pathname)Creates a new subdirectory on the FTP server in the current directory (if a relative pathname is given) or where specified (if an absolute pathname is given). | 
|  String | printWorkingDirectory()Returns the pathname of the current working directory. | 
|  boolean | remoteAppend(String filename)Initiate a server to server file transfer. | 
|  boolean | remoteRetrieve(String filename)Initiate a server to server file transfer. | 
|  boolean | remoteStore(String filename)Initiate a server to server file transfer. | 
|  boolean | remoteStoreUnique()Initiate a server to server file transfer. | 
|  boolean | remoteStoreUnique(String filename)Initiate a server to server file transfer. | 
|  boolean | removeDirectory(String pathname)Removes a directory on the FTP server (if empty). | 
|  boolean | rename(String from,
             String to)Renames a remote file. | 
|  boolean | retrieveFile(String remote,
                         OutputStream local)Retrieves a named file from the server and writes it to the given OutputStream. | 
|  InputStream | retrieveFileStream(String remote)Returns an InputStream from which a named file from the server can be read. | 
|  boolean | sendNoOp()Sends a NOOP command to the FTP server. | 
|  boolean | sendSiteCommand(String arguments)Send a site specific command. | 
|  void | setBufferSize(int bufSize)Set the internal buffer size. | 
|  void | setDataTimeout(int timeout)Sets the timeout in milliseconds to use when reading from the data connection. | 
|  boolean | setFileStructure(int structure)Sets the file structure. | 
|  boolean | setFileTransferMode(int mode)Sets the transfer mode. | 
|  boolean | setFileType(int fileType)Sets the file type to be transferred. | 
|  boolean | setFileType(int fileType,
                       int formatOrByteSize)Sets the file type to be transferred and the format. | 
|  void | setListHiddenFiles(boolean listHiddenFiles)You can set this to true if you would like to get hidden files when listFiles(java.lang.String)too. | 
|  void | setParserFactory(FTPFileEntryParserFactory parserFactory)set the factory used for parser creation to the supplied factory object. | 
|  void | setRemoteVerificationEnabled(boolean enable)Enable or disable verification that the remote host taking part of a data connection is the same as the host to which the control connection is attached. | 
|  void | setRestartOffset(long offset)Sets the restart offset. | 
|  boolean | storeFile(String remote,
                   InputStream local)Stores a file on the server using the given name and taking input from the given InputStream. | 
|  OutputStream | storeFileStream(String remote)Returns an OutputStream through which data can be written to store a file on the server using the given name. | 
|  boolean | storeUniqueFile(InputStream local)Stores a file on the server using a unique name assigned by the server and taking input from the given InputStream. | 
|  boolean | storeUniqueFile(String remote,
                               InputStream local)Stores a file on the server using a unique name derived from the given name and taking input from the given InputStream. | 
|  OutputStream | storeUniqueFileStream()Returns an OutputStream through which data can be written to store a file on the server using a unique name assigned by the server. | 
|  OutputStream | storeUniqueFileStream(String remote)Returns an OutputStream through which data can be written to store a file on the server using a unique name derived from the given name. | 
|  boolean | structureMount(String pathname)Issue the FTP SMNT command. | 
| Methods inherited from class org.apache.commons.net.ftp.FTP | 
|---|
| abor, acct, addProtocolCommandListener, allo, allo, appe, cdup, cwd, dele, getControlEncoding, getReply, getReplyCode, getReplyString, getReplyStrings, help, help, isStrictMultilineParsing, list, list, mdtm, mkd, mode, nlst, nlst, noop, pass, pasv, port, pwd, quit, rein, removeProtocolCommandListener, rest, retr, rmd, rnfr, rnto, sendCommand, sendCommand, sendCommand, sendCommand, setControlEncoding, setStrictMultilineParsing, site, smnt, stat, stat, stor, stou, stou, stru, syst, type, type, user | 
| Methods inherited from class org.apache.commons.net.SocketClient | 
|---|
| connect, connect, connect, connect, connect, connect, getConnectTimeout, getDefaultPort, getDefaultTimeout, getLocalAddress, getLocalPort, getRemoteAddress, getRemotePort, getSoLinger, getSoTimeout, getTcpNoDelay, isConnected, setConnectTimeout, setDefaultPort, setDefaultTimeout, setReceiveBufferSize, setSendBufferSize, setServerSocketFactory, setSocketFactory, setSoLinger, setSoTimeout, setTcpNoDelay, verifyRemote | 
| Methods inherited from class java.lang.Object | 
|---|
| clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait | 
| Field Detail | 
|---|
public static final int ACTIVE_LOCAL_DATA_CONNECTION_MODE
public static final int ACTIVE_REMOTE_DATA_CONNECTION_MODE
public static final int PASSIVE_LOCAL_DATA_CONNECTION_MODE
public static final int PASSIVE_REMOTE_DATA_CONNECTION_MODE
| Constructor Detail | 
|---|
public FTPClient()
 ACTIVE_LOCAL_DATA_CONNECTION_MODE , the file type
 set to  FTP.ASCII_FILE_TYPE , the
 file format set to  FTP.NON_PRINT_TEXT_FORMAT ,
 the file structure set to  FTP.FILE_STRUCTURE , and
 the transfer mode set to  FTP.STREAM_TRANSFER_MODE .
| Method Detail | 
|---|
protected Socket _openDataConnection_(int command,
                                      String arg)
                               throws IOException
setRestartOffset(long),
 a REST command is issued to the server with the offset as
 an argument before establishing the data connection.  Active
 mode connections also cause a local PORT command to be issued.
 
command - The text representation of the FTP command to send.arg - The arguments to the FTP command.  If this parameter is
             set to null, then the command is sent with no argument.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
protected void _connectAction_()
                        throws IOException
FTPFTP._controlInput_ and FTP._controlOutput_.
_connectAction_ in class FTPIOExceptionpublic void setDataTimeout(int timeout)
timeout - The default timeout in milliseconds that is used when
        opening a data connection socket.public void setParserFactory(FTPFileEntryParserFactory parserFactory)
parserFactory - factory object used to create FTPFileEntryParsersFTPFileEntryParserFactory, 
DefaultFTPFileEntryParserFactory
public void disconnect()
                throws IOException
disconnect in class FTPIOException - If an error occurs while disconnecting.public void setRemoteVerificationEnabled(boolean enable)
enable - True to enable verification, false to disable verification.public boolean isRemoteVerificationEnabled()
public boolean login(String username,
                     String password)
              throws IOException
username - The username to login under.password - The password to use.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean login(String username,
                     String password,
                     String account)
              throws IOException
username - The username to login under.password - The password to use.account - The account to use.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean logout()
               throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean changeWorkingDirectory(String pathname)
                               throws IOException
pathname - The new current working directory.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean changeToParentDirectory()
                                throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean structureMount(String pathname)
                       throws IOException
pathname - The pathname to mount.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.public void enterLocalActiveMode()
ACTIVE_LOCAL_DATA_CONNECTION_MODE.  No communication
 with the FTP server is conducted, but this causes all future data
 transfers to require the FTP server to connect to the client's
 data port.  Additionally, to accommodate differences between socket
 implementations on different platforms, this method causes the
 client to issue a PORT command before every data transfer.
public void enterLocalPassiveMode()
 PASSIVE_LOCAL_DATA_CONNECTION_MODE .  Use this
 method only for data transfers between the client and server.
 This method causes a PASV command to be issued to the server
 before the opening of every data connection, telling the server to
 open a data port to which the client will connect to conduct
 data transfers.  The FTPClient will stay in
  PASSIVE_LOCAL_DATA_CONNECTION_MODE  until the
 mode is changed by calling some other method such as
 enterLocalActiveMode() 
public boolean enterRemoteActiveMode(InetAddress host,
                                     int port)
                              throws IOException
 ACTIVE_REMOTE_DATA_CONNECTION .  Use this method only
 for server to server data transfers.  This method issues a PORT
 command to the server, indicating the other server and port to which
 it should connect for data transfers.  You must call this method
 before EVERY server to server transfer attempt.  The FTPClient will
 NOT automatically continue to issue PORT commands.  You also
 must remember to call
 enterLocalActiveMode()  if you
 wish to return to the normal data connection mode.
 
host - The passive mode server accepting connections for data
             transfers.port - The passive mode server's data port.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean enterRemotePassiveMode()
                               throws IOException
 PASSIVE_REMOTE_DATA_CONNECTION_MODE .  Use this
 method only for server to server data transfers.
 This method issues a PASV command to the server, telling it to
 open a data port to which the active server will connect to conduct
 data transfers.  You must call this method
 before EVERY server to server transfer attempt.  The FTPClient will
 NOT automatically continue to issue PASV commands.  You also
 must remember to call
 enterLocalActiveMode()  if you
 wish to return to the normal data connection mode.
 
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.public String getPassiveHost()
enterLocalPassiveMode().
 This is because FTPClient sends a PASV command to the server only
 just before opening a data connection, and not when you call
 enterLocalPassiveMode().
 
public int getPassivePort()
enterLocalPassiveMode().
 This is because FTPClient sends a PASV command to the server only
 just before opening a data connection, and not when you call
 enterLocalPassiveMode().
 
public int getDataConnectionMode()
 _DATA_CONNECTION_MODE  constants.
 
 _DATA_CONNECTION_MODE  constants.
public boolean setFileType(int fileType)
                    throws IOException
 FTP.ASCII_FILE_TYPE ,  FTP.BINARY_FILE_TYPE,
 etc.  The file type only needs to be set when you want to change the
 type.  After changing it, the new type stays in effect until you change
 it again.  The default file type is  FTP.ASCII_FILE_TYPE 
 if this method is never called.
 
fileType - The  _FILE_TYPE  constant indcating the
                 type of file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean setFileType(int fileType,
                           int formatOrByteSize)
                    throws IOException
 FTP.ASCII_FILE_TYPE ,
  FTP.BINARY_FILE_TYPE , etc.  The file type only needs to
 be set when you want to change the type.  After changing it, the new
 type stays in effect until you change it again.  The default file type
 is  FTP.ASCII_FILE_TYPE  if this method is never called.
 The format should be one of the FTP class  TEXT_FORMAT 
 constants, or if the type is  FTP.LOCAL_FILE_TYPE , the
 format should be the byte size for that type.  The default format
 is  FTP.NON_PRINT_TEXT_FORMAT  if this method is never
 called.
 
fileType - The  _FILE_TYPE  constant indcating the
                 type of file.formatOrByteSize - The format of the file (one of the
              _FORMAT constants.  In the case of
              LOCAL_FILE_TYPE, the byte size.
 
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean setFileStructure(int structure)
                         throws IOException
 FTP.FILE_STRUCTURE  if this method is never called.
 
structure - The structure of the file (one of the FTP class
         _STRUCTURE constants).
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean setFileTransferMode(int mode)
                            throws IOException
 FTP.STREAM_TRANSFER_MODE  if this method is never called.
 
mode - The new transfer mode to use (one of the FTP class
         _TRANSFER_MODE constants).
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean remoteRetrieve(String filename)
                       throws IOException
filename - The name of the file to retrieve.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean remoteStore(String filename)
                    throws IOException
 remoteRetrieve  issued to it by another
 FTPClient.
 
filename - The name to call the file that is to be stored.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean remoteStoreUnique(String filename)
                          throws IOException
 remoteRetrieve  issued
 to it by another FTPClient.
 
filename - The name on which to base the filename of the file
                  that is to be stored.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean remoteStoreUnique()
                          throws IOException
 remoteRetrieve  issued
 to it by another FTPClient.  Many FTP servers require that a base
 filename be given from which the unique filename can be derived.  For
 those servers use the other version of  remoteStoreUnique
 
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean remoteAppend(String filename)
                     throws IOException
 remoteRetrieve  issued to it by another FTPClient.
 
filename - The name of the file to be appended to, or if the
        file does not exist, the name to call the file being stored.
 
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean completePendingCommand()
                               throws IOException
For example,
 InputStream input;
 OutputStream output;
 input  = new FileInputStream("foobaz.txt");
 output = ftp.storeFileStream("foobar.txt")
 if(!FTPReply.isPositiveIntermediate(ftp.getReplyCode())) {
     input.close();
     output.close();
     ftp.logout();
     ftp.disconnect();
     System.err.println("File transfer failed.");
     System.exit(1);
 }
 Util.copyStream(input, output);
 input.close();
 output.close();
 // Must call completePendingCommand() to finish command.
 if(!ftp.completePendingCommand()) {
     ftp.logout();
     ftp.disconnect();
     System.err.println("File transfer failed.");
     System.exit(1);
 }
 
 
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean retrieveFile(String remote,
                            OutputStream local)
                     throws IOException
remote - The name of the remote file.local - The local OutputStream to which to write the file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
CopyStreamException - If an I/O error occurs while actually
      transferring the file.  The CopyStreamException allows you to
      determine the number of bytes transferred and the IOException
      causing the error.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public InputStream retrieveFileStream(String remote)
                               throws IOException
completePendingCommand  and
 check its return value to verify success.
 
remote - The name of the remote file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean storeFile(String remote,
                         InputStream local)
                  throws IOException
remote - The name to give the remote file.local - The local InputStream from which to read the file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
CopyStreamException - If an I/O error occurs while actually
      transferring the file.  The CopyStreamException allows you to
      determine the number of bytes transferred and the IOException
      causing the error.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public OutputStream storeFileStream(String remote)
                             throws IOException
completePendingCommand  and
 check its return value to verify success.
 
remote - The name to give the remote file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean appendFile(String remote,
                          InputStream local)
                   throws IOException
remote - The name of the remote file.local - The local InputStream from which to read the data to
                be appended to the remote file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
CopyStreamException - If an I/O error occurs while actually
      transferring the file.  The CopyStreamException allows you to
      determine the number of bytes transferred and the IOException
      causing the error.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public OutputStream appendFileStream(String remote)
                              throws IOException
completePendingCommand  and
 check its return value to verify success.
 
remote - The name of the remote file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean storeUniqueFile(String remote,
                               InputStream local)
                        throws IOException
remote - The name on which to base the unique name given to
                the remote file.local - The local InputStream from which to read the file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
CopyStreamException - If an I/O error occurs while actually
      transferring the file.  The CopyStreamException allows you to
      determine the number of bytes transferred and the IOException
      causing the error.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public OutputStream storeUniqueFileStream(String remote)
                                   throws IOException
completePendingCommand  and
 check its return value to verify success.
 
remote - The name on which to base the unique name given to
                the remote file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean storeUniqueFile(InputStream local)
                        throws IOException
local - The local InputStream from which to read the file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
CopyStreamException - If an I/O error occurs while actually
      transferring the file.  The CopyStreamException allows you to
      determine the number of bytes transferred and the IOException
      causing the error.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public OutputStream storeUniqueFileStream()
                                   throws IOException
completePendingCommand  and
 check its return value to verify success.
 
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean allocate(int bytes)
                 throws IOException
bytes - The number of bytes which the server should allocate.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean allocate(int bytes,
                        int recordSize)
                 throws IOException
bytes - The number of bytes which the server should allocate.recordSize - The size of a file record.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.public void setRestartOffset(long offset)
offset - The offset into the remote file at which to start the
           next file transfer.  This must be a value greater than or
           equal to zero.public long getRestartOffset()
public boolean rename(String from,
                      String to)
               throws IOException
from - The name of the remote file to rename.to - The new name of the remote file.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean abort()
              throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean deleteFile(String pathname)
                   throws IOException
pathname - The pathname of the file to be deleted.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean removeDirectory(String pathname)
                        throws IOException
pathname - The pathname of the directory to remove.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean makeDirectory(String pathname)
                      throws IOException
pathname - The pathname of the directory to create.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public String printWorkingDirectory()
                             throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public boolean sendSiteCommand(String arguments)
                        throws IOException
arguments - The site specific command and arguments.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public String getSystemName()
                     throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
  command to the server or receiving a reply from the server.
public String listHelp()
                throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
  command to the server or receiving a reply from the server.
public String listHelp(String command)
                throws IOException
command - The command on which to ask for help.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
  command to the server or receiving a reply from the server.
public boolean sendNoOp()
                 throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public String[] listNames(String pathname)
                   throws IOException
pathname - The file or directory to list.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public String[] listNames()
                   throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public FTPFile[] listFiles(String pathname)
                    throws IOException
 This information is obtained through the LIST command.  The contents of
 the returned array is determined by the FTPFileEntryParser 
 used.
 
pathname - The file or directory to list.  Since the server may
                  or may not expand glob expressions, using them here
                  is not recommended and may well cause this method to
                  fail.
FTPConnectionClosedException - If the FTP server prematurely closes the connection
                   as a result of the client being idle or some other
                   reason causing the server to send FTP reply code 421.
                   This exception may be caught either as an IOException
                   or independently as itself.
IOException - If an I/O error occurs while either sending a
                   command to the server or receiving a reply
                   from the server.
ParserInitializationException - Thrown if the parserKey parameter cannot be
                   resolved by the selected parser factory.
                   In the DefaultFTPEntryParserFactory, this will
                   happen when parserKey is neither
                   the fully qualified class name of a class
                   implementing the interface
                   org.apache.commons.net.ftp.FTPFileEntryParser
                   nor a string containing one of the recognized keys
                   mapping to such a parser or if class loader
                   security issues prevent its being loaded.DefaultFTPFileEntryParserFactory, 
FTPFileEntryParserFactory, 
FTPFileEntryParser
public FTPFile[] listFiles()
                    throws IOException
 This information is obtained through the LIST command.  The contents of
 the returned array is determined by the FTPFileEntryParser 
 used.
 
NOTE: This array may contain null members if any of the individual file listings failed to parse. The caller should check each entry for null before referencing it.
FTPConnectionClosedException - If the FTP server prematurely closes the connection
                   as a result of the client being idle or some other
                   reason causing the server to send FTP reply code 421.
                   This exception may be caught either as an IOException
                   or independently as itself.
IOException - If an I/O error occurs while either sending a
                   command to the server or receiving a reply
                   from the server.
ParserInitializationException - Thrown if the parserKey parameter cannot be
                   resolved by the selected parser factory.
                   In the DefaultFTPEntryParserFactory, this will
                   happen when parserKey is neither
                   the fully qualified class name of a class
                   implementing the interface
                   org.apache.commons.net.ftp.FTPFileEntryParser
                   nor a string containing one of the recognized keys
                   mapping to such a parser or if class loader
                   security issues prevent its being loaded.DefaultFTPFileEntryParserFactory, 
FTPFileEntryParserFactory, 
FTPFileEntryParser
public FTPListParseEngine initiateListParsing()
                                       throws IOException
 FTPFileEntryParser  used.
 This method differs from using the listFiles() methods in that expensive FTPFile objects are not created until needed which may be an advantage on large lists.
 parser  parameter.   Null will be
 returned if a data connection cannot be opened.  If the current working
 directory contains no files, an empty array will be the return.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
                   of the client being idle or some other reason causing the server
                   to send FTP reply code 421.  This exception may be caught either
                   as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
                   command to the server or receiving a reply from the server.
ParserInitializationException - Thrown if the autodetect mechanism cannot
                   resolve the type of system we are connected with.FTPListParseEngine
public FTPListParseEngine initiateListParsing(String pathname)
                                       throws IOException
 FTPFileEntryParser  used.
 The server may or may not expand glob expressions. You should avoid using glob expressions because the return format for glob listings differs from server to server and will likely cause this method to fail.
This method differs from using the listFiles() methods in that expensive FTPFile objects are not created until needed which may be an advantage on large lists.
    FTPClient f=FTPClient();
    f.connect(server);
    f.login(username, password);
    FTPListParseEngine engine = f.initiateListParsing(directory);
    while (engine.hasNext()) {
       FTPFile[] files = engine.getNext(25);  // "page size" you want
       //do whatever you want with these files, display them, etc.
       //expensive FTPFile objects not created until needed.
    }
 
 parser  parameter.   Null will be
 returned if a data connection cannot be opened.  If the current working
 directory contains no files, an empty array will be the return.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
                   of the client being idle or some other reason causing the server
                   to send FTP reply code 421.  This exception may be caught either
                   as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
                   command to the server or receiving a reply from the server.
ParserInitializationException - Thrown if the autodetect mechanism cannot
                   resolve the type of system we are connected with.FTPListParseEngine
public FTPListParseEngine initiateListParsing(String parserKey,
                                              String pathname)
                                       throws IOException
 FTPFileEntryParser  used.
 The server may or may not expand glob expressions. You should avoid using glob expressions because the return format for glob listings differs from server to server and will likely cause this method to fail.
This method differs from using the listFiles() methods in that expensive FTPFile objects are not created until needed which may be an advantage on large lists.
parserKey - A string representing a designated code or fully-qualified
 class name of an   FTPFileEntryParser  that should be
               used to parse each server file listing.
 parser  parameter.   Null will be
 returned if a data connection cannot be opened.  If the current working
 directory contains no files, an empty array will be the return.
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
                   of the client being idle or some other reason causing the server
                   to send FTP reply code 421.  This exception may be caught either
                   as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
                   command to the server or receiving a reply from the server.
ParserInitializationException - Thrown if the parserKey parameter cannot be
                   resolved by the selected parser factory.
                   In the DefaultFTPEntryParserFactory, this will
                   happen when parserKey is neither
                   the fully qualified class name of a class
                   implementing the interface
                   org.apache.commons.net.ftp.FTPFileEntryParser
                   nor a string containing one of the recognized keys
                   mapping to such a parser or if class loader
                   security issues prevent its being loaded.FTPListParseEngineprotected String getListArguments(String pathname)
public String getStatus()
                 throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public String getStatus(String pathname)
                 throws IOException
FTPConnectionClosedException - If the FTP server prematurely closes the connection as a result
      of the client being idle or some other reason causing the server
      to send FTP reply code 421.  This exception may be caught either
      as an IOException or independently as itself.
IOException - If an I/O error occurs while either sending a
      command to the server or receiving a reply from the server.
public String getModificationTime(String pathname)
                           throws IOException
pathname - The file path to query.
YYYYMMDDhhmmss format.
IOException - if an I/O error occurs.public void setBufferSize(int bufSize)
bufSize - The size of the bufferpublic int getBufferSize()
public void configure(FTPClientConfig config)
Configurable interface. 
 In the case of this class, configuring merely makes the config object available for the
 factory methods that construct parsers.
configure in interface Configurableconfig - FTPClientConfig object used to 
 provide non-standard configurations to the parser.public void setListHiddenFiles(boolean listHiddenFiles)
listFiles(java.lang.String) too.
 A LIST -a will be issued to the ftp server.
 It depends on your ftp server if you need to call this method, also dont expect to get rid
 of hidden files if you call this method with "false".
listHiddenFiles - true if hidden files should be listedpublic boolean getListHiddenFiles()
setListHiddenFiles(boolean)| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||