public FTPClient() 
{
        __initDefaults();
        __dataTimeout = -1;
        __remoteVerificationEnabled = true;
        __parserFactory = new DefaultFTPFileEntryParserFactory();
        __configuration      = null;
        __listHiddenFiles = false;
}

Default FTPClient constructor. Creates a new FTPClient instance with the data connection mode set to 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 .

 protected  void _connectAction_() throws IOException 
{
        super._connectAction_();
        __initDefaults();
}

 protected Socket _openDataConnection_(int command,
    String arg) throws IOException 
{
        Socket socket;
        if (__dataConnectionMode != ACTIVE_LOCAL_DATA_CONNECTION_MODE &&
                __dataConnectionMode != PASSIVE_LOCAL_DATA_CONNECTION_MODE)
            return null;
        if (__dataConnectionMode == ACTIVE_LOCAL_DATA_CONNECTION_MODE)
        {
            ServerSocket server;
            server = _serverSocketFactory_.createServerSocket(0, 1, getLocalAddress());
            if (!FTPReply.isPositiveCompletion(port(getLocalAddress(),
                                                    server.getLocalPort())))
            {
                server.close();
                return null;
            }
            if ((__restartOffset  > 0) && !restart(__restartOffset))
            {
                server.close();
                return null;
            }
            if (!FTPReply.isPositivePreliminary(sendCommand(command, arg)))
            {
                server.close();
                return null;
            }
            // For now, let's just use the data timeout value for waiting for
            // the data connection.  It may be desirable to let this be a
            // separately configurable value.  In any case, we really want
            // to allow preventing the accept from blocking indefinitely.
            if (__dataTimeout  >= 0)
                server.setSoTimeout(__dataTimeout);
            try {
                socket = server.accept();
            } finally {
                server.close();
            }
        }
        else
        { // We must be in PASSIVE_LOCAL_DATA_CONNECTION_MODE
            if (pasv() != FTPReply.ENTERING_PASSIVE_MODE)
                return null;
            __parsePassiveModeReply(_replyLines.get(_replyLines.size() - 1));
            socket = _socketFactory_.createSocket(__passiveHost, __passivePort);
            if ((__restartOffset  > 0) && !restart(__restartOffset))
            {
                socket.close();
                return null;
            }
            if (!FTPReply.isPositivePreliminary(sendCommand(command, arg)))
            {
                socket.close();
                return null;
            }
        }
        if (__remoteVerificationEnabled && !verifyRemote(socket))
        {
            InetAddress host1, host2;
            host1 = socket.getInetAddress();
            host2 = getRemoteAddress();
            socket.close();
            throw new IOException(
                "Host attempting data connection " + host1.getHostAddress() +
                " is not same as server " + host2.getHostAddress());
        }
        if (__dataTimeout  >= 0)
            socket.setSoTimeout(__dataTimeout);
        return socket;
}

Establishes a data connection with the FTP server, returning a Socket for the connection if successful. If a restart offset has been set with #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.

 public boolean abort() throws IOException 
{
        return FTPReply.isPositiveCompletion(abor());
}

Abort a transfer in progress.

 public boolean allocate(int bytes) throws IOException 
{
        return FTPReply.isPositiveCompletion(allo(bytes));
}

Reserve a number of bytes on the server for the next file transfer.

 public boolean allocate(int bytes,
    int recordSize) throws IOException 
{
        return FTPReply.isPositiveCompletion(allo(bytes, recordSize));
}

Reserve space on the server for the next file transfer.

 public boolean appendFile(String remote,
    InputStream local) throws IOException 
{
        return __storeFile(FTPCommand.APPE, remote, local);
}

Appends to a file on the server with the given name, taking input from the given InputStream. This method does NOT close the given InputStream. If the current file type is ASCII, line separators in the file are transparently converted to the NETASCII format (i.e., you should not attempt to create a special InputStream to do this).

 public OutputStream appendFileStream(String remote) throws IOException 
{
        return __storeFileStream(FTPCommand.APPE, remote);
}

Returns an OutputStream through which data can be written to append to a file on the server with the given name. If the current file type is ASCII, the returned OutputStream will convert line separators in the file to the NETASCII format (i.e., you should not attempt to create a special OutputStream to do this). You must close the OutputStream when you finish writing to it. The OutputStream itself will take care of closing the parent data connection socket upon being closed. To finalize the file transfer you must call completePendingCommand and check its return value to verify success.

 public boolean changeToParentDirectory() throws IOException 
{
        return FTPReply.isPositiveCompletion(cdup());
}

Change to the parent directory of the current working directory.

 public boolean changeWorkingDirectory(String pathname) throws IOException 
{
        return FTPReply.isPositiveCompletion(cwd(pathname));
}

Change the current working directory of the FTP session.

 public boolean completePendingCommand() throws IOException 
{
        return FTPReply.isPositiveCompletion(getReply());
}

There are a few FTPClient methods that do not complete the entire sequence of FTP commands to complete a transaction. These commands require some action by the programmer after the reception of a positive intermediate command. After the programmer's code completes its actions, it must call this method to receive the completion reply from the server and verify the success of the entire transaction.

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);
}

 public  void configure(FTPClientConfig config) 
{
        this.__configuration = config;
}

Implementation of the Configurable interface. In the case of this class, configuring merely makes the config object available for the factory methods that construct parsers.

 public boolean deleteFile(String pathname) throws IOException 
{
        return FTPReply.isPositiveCompletion(dele(pathname));
}

Deletes a file on the FTP server.

 public  void disconnect() throws IOException 
{
        super.disconnect();
        __initDefaults();
}

Closes the connection to the FTP server and restores connection parameters to the default values.

 public  void enterLocalActiveMode() 
{
        __dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE;
        __passiveHost = null;
        __passivePort = -1;
}

Set the current data connection mode to 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() 
{
        __dataConnectionMode = PASSIVE_LOCAL_DATA_CONNECTION_MODE;
        // These will be set when just before a data connection is opened
        // in _openDataConnection_()
        __passiveHost = null;
        __passivePort = -1;
}

Set the current data connection mode to 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 
{
        if (FTPReply.isPositiveCompletion(port(host, port)))
        {
            __dataConnectionMode = ACTIVE_REMOTE_DATA_CONNECTION_MODE;
            __passiveHost = null;
            __passivePort = -1;
            return true;
        }
        return false;
}

Set the current data connection mode to 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.

 public boolean enterRemotePassiveMode() throws IOException 
{
        if (pasv() != FTPReply.ENTERING_PASSIVE_MODE)
            return false;
        __dataConnectionMode = PASSIVE_REMOTE_DATA_CONNECTION_MODE;
        __parsePassiveModeReply(_replyLines.get(0));
        return true;
}

Set the current data connection mode to 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.

 public int getBufferSize() 
{
        return __bufferSize;
}

Retrieve the current internal buffer size.

 public int getDataConnectionMode() 
{
        return __dataConnectionMode;
}

Returns the current data connection mode (one of the _DATA_CONNECTION_MODE constants.

 protected String getListArguments(String pathname) 
{
        if (getListHiddenFiles())
        {
            StringBuffer sb = new StringBuffer(pathname.length() + 3);
            sb.append("-a ");
            sb.append(pathname);
            return sb.toString();
        }
        return pathname;
}

 public boolean getListHiddenFiles() 
{
        return this.__listHiddenFiles;
}

 public String getModificationTime(String pathname) throws IOException 
{
        if (FTPReply.isPositiveCompletion(mdtm(pathname)))
            return getReplyString();
        return null;
}

Issue the FTP MDTM command (not supported by all servers to retrieve the last modification time of a file. The modification string should be in the ISO 3077 form "YYYYMMDDhhmmss(.xxx)?". The timestamp represented should also be in GMT, but not all FTP servers honour this.

 public String getPassiveHost() 
{
        return __passiveHost;
}

Returns the hostname or IP address (in the form of a string) returned by the server when entering passive mode. If not in passive mode, returns null. This method only returns a valid value AFTER a data connection has been opened after a call to 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() 
{
        return __passivePort;
}

If in passive mode, returns the data port of the passive host. This method only returns a valid value AFTER a data connection has been opened after a call to 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 long getRestartOffset() 
{
        return __restartOffset;
}

Fetches the restart offset.

 public String getStatus() throws IOException 
{
        if (FTPReply.isPositiveCompletion(stat()))
            return getReplyString();
        return null;
}

Issue the FTP STAT command to the server.

 public String getStatus(String pathname) throws IOException 
{
        if (FTPReply.isPositiveCompletion(stat(pathname)))
            return getReplyString();
        return null;
}

Issue the FTP STAT command to the server for a given pathname. This should produce a listing of the file or directory.

 public String getSystemName() throws IOException 
{
      //if (syst() == FTPReply.NAME_SYSTEM_TYPE)
      // Technically, we should expect a NAME_SYSTEM_TYPE response, but
      // in practice FTP servers deviate, so we soften the condition to
      // a positive completion.
        if (__systemName == null && FTPReply.isPositiveCompletion(syst()))
            __systemName = _replyLines.get(_replyLines.size() - 1).substring(4);
        return __systemName;
}

Fetches the system type name from the server and returns the string. This value is cached for the duration of the connection after the first call to this method. In other words, only the first time that you invoke this method will it issue a SYST command to the FTP server. FTPClient will remember the value and return the cached value until a call to disconnect.

 public FTPListParseEngine initiateListParsing() throws IOException 
{
        return initiateListParsing((String) null);
}

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. This object is then capable of being iterated to return a sequence of FTPFile objects with information filled in by the 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.

 public FTPListParseEngine initiateListParsing(String pathname) throws IOException 
{
        String key = null;
        return initiateListParsing(key, pathname);
}

Using the default autodetect mechanism, initialize an FTPListParseEngine object containing a raw file information for the supplied directory. This information is obtained through the LIST command. This object is then capable of being iterated to return a sequence of FTPFile objects with information filled in by the 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.
   }

 public FTPListParseEngine initiateListParsing(String parserKey,
    String pathname) throws IOException 
{
        // We cache the value to avoid creation of a new object every
        // time a file listing is generated.
        if(__entryParser == null) {
            if (null != parserKey) {
                // if a parser key was supplied in the parameters, 
                // use that to create the paraser
                __entryParser = 
                    __parserFactory.createFileEntryParser(parserKey);
            } else {
                // if no parserKey was supplied, check for a configuration
                // in the params, and if non-null, use that.
                if (null != __configuration) {
                    __entryParser = 
                        __parserFactory.createFileEntryParser(__configuration);
                } else {
                    // if a parserKey hasn't been supplied, and a configuration
                    // hasn't been supplied, then autodetect by calling
                    // the SYST command and use that to choose the parser.
                    __entryParser = 
                        __parserFactory.createFileEntryParser(getSystemName());
                }
            }
        }
        return initiateListParsing(__entryParser, pathname);
}

Using the supplied parser key, initialize an FTPListParseEngine object containing a raw file information for the supplied directory. This information is obtained through the LIST command. This object is then capable of being iterated to return a sequence of FTPFile objects with information filled in by the 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.

 public boolean isRemoteVerificationEnabled() 
{
        return __remoteVerificationEnabled;
}

Return whether or not verification of the remote host participating in data connections is enabled. The default behavior is for verification to be enabled.

 public FTPFile[] listFiles() throws IOException 
{
        return listFiles((String) null);
}

Using the default system autodetect mechanism, obtain a list of file information for the current working directory.

This information is obtained through the LIST command. The contents of the returned array is determined by the FTPFileEntryParser used.

 public FTPFile[] listFiles(String pathname) throws IOException 
{
        String key = null;
        FTPListParseEngine engine =
            initiateListParsing(key, pathname);
        return engine.getFiles();
}

Using the default system autodetect mechanism, obtain a list of file information for the current working directory or for just a single file.

This information is obtained through the LIST command. The contents of the returned array is determined by the FTPFileEntryParser used.

 public String listHelp() throws IOException 
{
        if (FTPReply.isPositiveCompletion(help()))
            return getReplyString();
        return null;
}

Fetches the system help information from the server and returns the full string.

 public String listHelp(String command) throws IOException 
{
        if (FTPReply.isPositiveCompletion(help(command)))
            return getReplyString();
        return null;
}

Fetches the help information for a given command from the server and returns the full string.

 public String[] listNames() throws IOException 
{
        return listNames(null);
}

Obtain a list of filenames in the current working directory This information is obtained through the NLST command. If the current directory contains no files, a zero length array is returned only if the FTP server returned a positive completion code, otherwise, null is returned (the FTP server returned a 550 error No files found.). If the directory is not empty, an array of filenames in the directory is returned.

 public String[] listNames(String pathname) throws IOException 
{
        String line;
        Socket socket;
        BufferedReader reader;
        ArrayList< String > results;
        if ((socket = _openDataConnection_(FTPCommand.NLST, pathname)) == null)
            return null;
        reader =
            new BufferedReader(new InputStreamReader(socket.getInputStream(), getControlEncoding()));
        results = new ArrayList< String >();
        while ((line = reader.readLine()) != null)
            results.add(line);
        reader.close();
        socket.close();
        if (completePendingCommand())
        {
            String[] names = new String[ results.size() ];
            return results.toArray(names);
        }
        return null;
}

Obtain a list of filenames in a directory (or just the name of a given file, which is not particularly useful). This information is obtained through the NLST command. If the given pathname is a directory and contains no files, a zero length array is returned only if the FTP server returned a positive completion code, otherwise null is returned (the FTP server returned a 550 error No files found.). If the directory is not empty, an array of filenames in the directory is returned. If the pathname corresponds to a file, only that file will be listed. The server may or may not expand glob expressions.

 public boolean login(String username,
    String password) throws IOException 
{
        user(username);
        if (FTPReply.isPositiveCompletion(_replyCode))
            return true;
        // If we get here, we either have an error code, or an intermmediate
        // reply requesting password.
        if (!FTPReply.isPositiveIntermediate(_replyCode))
            return false;
        return FTPReply.isPositiveCompletion(pass(password));
}

Login to the FTP server using the provided username and password.

 public boolean login(String username,
    String password,
    String account) throws IOException 
{
        user(username);
        if (FTPReply.isPositiveCompletion(_replyCode))
            return true;
        // If we get here, we either have an error code, or an intermmediate
        // reply requesting password.
        if (!FTPReply.isPositiveIntermediate(_replyCode))
            return false;
        pass(password);
        if (FTPReply.isPositiveCompletion(_replyCode))
            return true;
        if (!FTPReply.isPositiveIntermediate(_replyCode))
            return false;
        return FTPReply.isPositiveCompletion(acct(account));
}

Login to the FTP server using the provided username, password, and account. If no account is required by the server, only the username and password, the account information is not used.

 public boolean logout() throws IOException 
{
        return FTPReply.isPositiveCompletion(quit());
}

Logout of the FTP server by sending the QUIT command.

 public boolean makeDirectory(String pathname) throws IOException 
{
        return FTPReply.isPositiveCompletion(mkd(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).

 public String printWorkingDirectory() throws IOException 
{
        if (pwd() != FTPReply.PATHNAME_CREATED)
            return null;
        return __parsePathname(_replyLines.get( _replyLines.size() - 1));
}

Returns the pathname of the current working directory.

 boolean reinitialize() throws IOException 
{
        rein();
        if (FTPReply.isPositiveCompletion(_replyCode) ||
                (FTPReply.isPositivePreliminary(_replyCode) &&
                 FTPReply.isPositiveCompletion(getReply())))
        {
            __initDefaults();
            return true;
        }
        return false;
}

Reinitialize the FTP session. Not all FTP servers support this command, which issues the FTP REIN command.

 public boolean remoteAppend(String filename) throws IOException 
{
        if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
                __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
            return FTPReply.isPositivePreliminary(stor(filename));
        return false;
}

Initiate a server to server file transfer. This method tells the server to which the client is connected to append to a given file on the other server. The other server must have had a remoteRetrieve issued to it by another FTPClient.

 public boolean remoteRetrieve(String filename) throws IOException 
{
        if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
                __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
            return FTPReply.isPositivePreliminary(retr(filename));
        return false;
}

Initiate a server to server file transfer. This method tells the server to which the client is connected to retrieve a given file from the other server.

 public boolean remoteStore(String filename) throws IOException 
{
        if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
                __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
            return FTPReply.isPositivePreliminary(stor(filename));
        return false;
}

Initiate a server to server file transfer. This method tells the server to which the client is connected to store a file on the other server using the given filename. The other server must have had a remoteRetrieve issued to it by another FTPClient.

 public boolean remoteStoreUnique() throws IOException 
{
        if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
                __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
            return FTPReply.isPositivePreliminary(stou());
        return false;
}

Initiate a server to server file transfer. This method tells the server to which the client is connected to store a file on the other server using a unique filename. The other server must have had a 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

 public boolean remoteStoreUnique(String filename) throws IOException 
{
        if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
                __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
            return FTPReply.isPositivePreliminary(stou(filename));
        return false;
}

Initiate a server to server file transfer. This method tells the server to which the client is connected to store a file on the other server using a unique filename based on the given filename. The other server must have had a remoteRetrieve issued to it by another FTPClient.

 public boolean removeDirectory(String pathname) throws IOException 
{
        return FTPReply.isPositiveCompletion(rmd(pathname));
}

Removes a directory on the FTP server (if empty).

 public boolean rename(String from,
    String to) throws IOException 
{
        if (!FTPReply.isPositiveIntermediate(rnfr(from)))
            return false;
        return FTPReply.isPositiveCompletion(rnto(to));
}

Renames a remote file.

 public boolean retrieveFile(String remote,
    OutputStream local) throws IOException 
{
        InputStream input;
        Socket socket;
        if ((socket = _openDataConnection_(FTPCommand.RETR, remote)) == null)
            return false;
        input = new BufferedInputStream(socket.getInputStream(),
                                        getBufferSize());
        if (__fileType == ASCII_FILE_TYPE)
          input = new FromNetASCIIInputStream(input);
        // Treat everything else as binary for now
        try
        {
            Util.copyStream(input, local, getBufferSize(),
                            CopyStreamEvent.UNKNOWN_STREAM_SIZE, null,
                            false);
        }
        catch (IOException e)
        {
            try
            {
                socket.close();
            }
            catch (IOException f)
            {}
            throw e;
        }
        socket.close();
        return completePendingCommand();
}

Retrieves a named file from the server and writes it to the given OutputStream. This method does NOT close the given OutputStream. If the current file type is ASCII, line separators in the file are converted to the local representation.

 public InputStream retrieveFileStream(String remote) throws IOException 
{
        InputStream input;
        Socket socket;
        if ((socket = _openDataConnection_(FTPCommand.RETR, remote)) == null)
            return null;
        input = socket.getInputStream();
        if (__fileType == ASCII_FILE_TYPE) {
          // We buffer ascii transfers because the buffering has to
          // be interposed between FromNetASCIIOutputSream and the underlying
          // socket input stream.  We don't buffer binary transfers
          // because we don't want to impose a buffering policy on the
          // programmer if possible.  Programmers can decide on their
          // own if they want to wrap the SocketInputStream we return
          // for file types other than ASCII.
          input = new BufferedInputStream(input,
                                          getBufferSize());
          input = new FromNetASCIIInputStream(input);
        }
        return new org.apache.commons.net.io.SocketInputStream(socket, input);
}

Returns an InputStream from which a named file from the server can be read. If the current file type is ASCII, the returned InputStream will convert line separators in the file to the local representation. You must close the InputStream when you finish reading from it. The InputStream itself will take care of closing the parent data connection socket upon being closed. To finalize the file transfer you must call completePendingCommand and check its return value to verify success.

 public boolean sendNoOp() throws IOException 
{
        return FTPReply.isPositiveCompletion(noop());
}

Sends a NOOP command to the FTP server. This is useful for preventing server timeouts.

 public boolean sendSiteCommand(String arguments) throws IOException 
{
        return FTPReply.isPositiveCompletion(site(arguments));
}

Send a site specific command.

 public  void setBufferSize(int bufSize) 
{
        __bufferSize = bufSize;
}

Set the internal buffer size.

 public  void setDataTimeout(int timeout) 
{
        __dataTimeout = timeout;
}

Sets the timeout in milliseconds to use when reading from the data connection. This timeout will be set immediately after opening the data connection.

 public boolean setFileStructure(int structure) throws IOException 
{
        if (FTPReply.isPositiveCompletion(stru(structure)))
        {
            __fileStructure = structure;
            return true;
        }
        return false;
}

Sets the file structure. The default structure is FTP.FILE_STRUCTURE if this method is never called.

 public boolean setFileTransferMode(int mode) throws IOException 
{
        if (FTPReply.isPositiveCompletion(mode(mode)))
        {
            __fileTransferMode = mode;
            return true;
        }
        return false;
}

Sets the transfer mode. The default transfer mode FTP.STREAM_TRANSFER_MODE if this method is never called.

 public boolean setFileType(int fileType) throws IOException 
{
        if (FTPReply.isPositiveCompletion(type(fileType)))
        {
            __fileType = fileType;
            __fileFormat = FTP.NON_PRINT_TEXT_FORMAT;
            return true;
        }
        return false;
}

Sets the file type to be transferred. This should be one of 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.

 public boolean setFileType(int fileType,
    int formatOrByteSize) throws IOException 
{
        if (FTPReply.isPositiveCompletion(type(fileType, formatOrByteSize)))
        {
            __fileType = fileType;
            __fileFormat = formatOrByteSize;
            return true;
        }
        return false;
}

Sets the file type to be transferred and the format. The type should be one of 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.

 public  void setListHiddenFiles(boolean listHiddenFiles) 
{
        this.__listHiddenFiles = listHiddenFiles;
}

You can set this to true if you would like to get hidden files when #listFiles 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".

 public  void setParserFactory(FTPFileEntryParserFactory parserFactory) 
{
        __parserFactory = parserFactory;
}

set the factory used for parser creation to the supplied factory object.

 public  void setRemoteVerificationEnabled(boolean enable) 
{
        __remoteVerificationEnabled = 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. The default is for verification to be enabled. You may set this value at any time, whether the FTPClient is currently connected or not.

 public  void setRestartOffset(long offset) 
{
        if (offset  >= 0)
            __restartOffset = offset;
}

Sets the restart offset. The restart command is sent to the server only before sending the file transfer command. When this is done, the restart marker is reset to zero.

 public boolean storeFile(String remote,
    InputStream local) throws IOException 
{
        return __storeFile(FTPCommand.STOR, remote, local);
}

Stores a file on the server using the given name and taking input from the given InputStream. This method does NOT close the given InputStream. If the current file type is ASCII, line separators in the file are transparently converted to the NETASCII format (i.e., you should not attempt to create a special InputStream to do this).

 public OutputStream storeFileStream(String remote) throws IOException 
{
        return __storeFileStream(FTPCommand.STOR, remote);
}

Returns an OutputStream through which data can be written to store a file on the server using the given name. If the current file type is ASCII, the returned OutputStream will convert line separators in the file to the NETASCII format (i.e., you should not attempt to create a special OutputStream to do this). You must close the OutputStream when you finish writing to it. The OutputStream itself will take care of closing the parent data connection socket upon being closed. To finalize the file transfer you must call completePendingCommand and check its return value to verify success.

 public boolean storeUniqueFile(InputStream local) throws IOException 
{
        return __storeFile(FTPCommand.STOU, null, local);
}

Stores a file on the server using a unique name assigned by the server and taking input from the given InputStream. This method does NOT close the given InputStream. If the current file type is ASCII, line separators in the file are transparently converted to the NETASCII format (i.e., you should not attempt to create a special InputStream to do this).

 public boolean storeUniqueFile(String remote,
    InputStream local) throws IOException 
{
        return __storeFile(FTPCommand.STOU, remote, local);
}

Stores a file on the server using a unique name derived from the given name and taking input from the given InputStream. This method does NOT close the given InputStream. If the current file type is ASCII, line separators in the file are transparently converted to the NETASCII format (i.e., you should not attempt to create a special InputStream to do this).

 public OutputStream storeUniqueFileStream() throws IOException 
{
        return __storeFileStream(FTPCommand.STOU, null);
}

Returns an OutputStream through which data can be written to store a file on the server using a unique name assigned by the server. If the current file type is ASCII, the returned OutputStream will convert line separators in the file to the NETASCII format (i.e., you should not attempt to create a special OutputStream to do this). You must close the OutputStream when you finish writing to it. The OutputStream itself will take care of closing the parent data connection socket upon being closed. To finalize the file transfer you must call completePendingCommand and check its return value to verify success.

 public OutputStream storeUniqueFileStream(String remote) throws IOException 
{
        return __storeFileStream(FTPCommand.STOU, 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. If the current file type is ASCII, the returned OutputStream will convert line separators in the file to the NETASCII format (i.e., you should not attempt to create a special OutputStream to do this). You must close the OutputStream when you finish writing to it. The OutputStream itself will take care of closing the parent data connection socket upon being closed. To finalize the file transfer you must call completePendingCommand and check its return value to verify success.

 public boolean structureMount(String pathname) throws IOException 
{
        return FTPReply.isPositiveCompletion(smnt(pathname));
}

Issue the FTP SMNT command.