Example usage for org.apache.commons.net.ftp FTPClient getReplyString

List of usage examples for org.apache.commons.net.ftp FTPClient getReplyString

Introduction

In this page you can find the example usage for org.apache.commons.net.ftp FTPClient getReplyString.

Prototype

public String getReplyString() 

Source Link

Document

Returns the entire text of the last FTP server response exactly as it was received, including all end of line markers in NETASCII format.

Usage

From source file:org.structr.files.ftp.FtpAccessTest.java

public void test01LoginFailed() {

    try (final Tx tx = StructrApp.getInstance(securityContext).tx()) {

        FTPClient ftp = new FTPClient();

        ftp.connect("127.0.0.1", ftpPort);
        logger.log(Level.INFO, "Reply from FTP server:", ftp.getReplyString());

        int reply = ftp.getReplyCode();
        assertTrue(FTPReply.isPositiveCompletion(reply));

        boolean loginSuccess = ftp.login("jt978hasdl", "lj3498ha");
        logger.log(Level.INFO, "Try to login as jt978hasdl/lj3498ha:", loginSuccess);
        assertFalse(loginSuccess);//from w w w . java 2s . c  o  m

        ftp.disconnect();

    } catch (IOException | FrameworkException ex) {
        logger.log(Level.SEVERE, "Error in FTP test", ex);
        fail("Unexpected exception: " + ex.getMessage());
    }

}

From source file:org.structr.web.common.FtpTest.java

/**
 * Creates an FTP client, a backend user and logs this user in.
 *
 * @return//from ww  w .  ja  v a  2  s . c om
 */
protected FTPClient setupFTPClient() {

    FTPClient ftp = new FTPClient();

    try {

        ftp.connect("localhost", ftpPort);
        logger.log(Level.INFO, "Reply from FTP server:", ftp.getReplyString());

        int reply = ftp.getReplyCode();
        assertTrue(FTPReply.isPositiveCompletion(reply));

        String username = "ftpuser1";
        String password = "ftpuserpw1";

        try (final Tx tx = StructrApp.getInstance(securityContext).tx()) {
            ftpUser = createFTPUser(username, password);
            tx.success();
        } catch (FrameworkException fex) {
            logger.log(Level.SEVERE, "Unable to create FTP user", fex);
        }
        boolean loginSuccess = ftp.login(username, password);
        logger.log(Level.INFO, "Try to login as " + username + "/" + password + ": ", loginSuccess);
        assertTrue(loginSuccess);

        reply = ftp.getReplyCode();
        assertEquals(FTPReply.USER_LOGGED_IN, reply);

    } catch (IOException ex) {
        logger.log(Level.SEVERE, "Error in FTP test", ex);
        fail("Unexpected exception: " + ex.getMessage());
    }

    return ftp;

}

From source file:org.structr.web.files.FtpTest.java

/**
 * Creates an FTP client, a backend user and logs this user in.
 *
 * @param username//from w w w . ja v  a2s .c  om
 * @return
 */
protected FTPClient setupFTPClient(final String username) {

    FTPClient ftp = new FTPClient();

    try {

        ftp.connect("localhost", ftpPort);
        logger.info("Reply from FTP server:", ftp.getReplyString());

        int reply = ftp.getReplyCode();
        assertTrue(FTPReply.isPositiveCompletion(reply));

        String password = "ftpuserpw1";

        try (final Tx tx = StructrApp.getInstance(securityContext).tx()) {
            ftpUser = createFTPUser(username, password);
            tx.success();
        } catch (FrameworkException fex) {
            logger.error("Unable to create FTP user", fex);
        }

        boolean loginSuccess = ftp.login(username, password);
        logger.info("Tried to login as {}/{}: {}", new Object[] { username, password, loginSuccess });
        assertTrue(loginSuccess);

        reply = ftp.getReplyCode();
        assertEquals(FTPReply.USER_LOGGED_IN, reply);

    } catch (IOException ex) {
        logger.error("Error in FTP test", ex);
        fail("Unexpected exception: " + ex.getMessage());
    }

    return ftp;

}

From source file:org.teiid.resource.adapter.ftp.FtpManagedConnectionFactory.java

protected FTPClient createClient() throws IOException, ResourceException {

    FTPClient client = createClientInstance();

    beforeConnectProcessing(client);/*from  w  w w .  ja v a 2  s .  com*/

    client.connect(this.host, this.port);

    if (!FTPReply.isPositiveCompletion(client.getReplyCode())) {
        throw new ResourceException(UTIL.getString("ftp_connect_failed", this.host, this.port)); //$NON-NLS-1$
    }

    if (!client.login(this.username, this.password)) {
        throw new IllegalStateException(UTIL.getString("ftp_login_failed", client.getReplyString())); //$NON-NLS-1$
    }

    afterConnectProcessing(client);

    return client;

}

From source file:org.umit.icm.mobile.connectivity.ServiceFTP.java

/**
 * Returns an FTP Response String.//from  w  ww .j  ava  2  s  .  co m
 * 
 *                                                                                                 
              
@return      String
 *
         
@see FTPClient
 */
@Override
public String connect() {

    FTPClient ftpClient = new FTPClient();
    try {
        ftpClient.connect(getServiceURL());
        ftpClient.login("test", "test");
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.enterLocalPassiveMode();
        String reply = ftpClient.getReplyString();
        ftpClient.logout();
        ftpClient.disconnect();
        if (reply != null)
            return "normal";
        return "blocked";
    } catch (SocketException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return null;
}

From source file:org.waarp.ftp.client.FTPClientExample.java

public static final void main(String[] args) {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;/*from w w  w.  j  a  v  a 2  s .  co m*/
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false;
    boolean lenient = false;
    long keepAliveTimeout = -1;
    int controlKeepAliveReplyTimeout = -1;
    int minParams = 5; // listings require 3 params
    String protocol = null; // SSL protocol
    String doCommand = null;
    String trustmgr = null;
    String proxyHost = null;
    int proxyPort = 80;
    String proxyUser = null;
    String proxyPassword = null;

    int base = 0;
    for (base = 0; base < args.length; base++) {
        if (args[base].equals("-s")) {
            storeFile = true;
        } else if (args[base].equals("-a")) {
            localActive = true;
        } else if (args[base].equals("-b")) {
            binaryTransfer = true;
        } else if (args[base].equals("-c")) {
            doCommand = args[++base];
            minParams = 3;
        } else if (args[base].equals("-d")) {
            mlsd = true;
            minParams = 3;
        } else if (args[base].equals("-e")) {
            useEpsvWithIPv4 = true;
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-k")) {
            keepAliveTimeout = Long.parseLong(args[++base]);
        } else if (args[base].equals("-l")) {
            listFiles = true;
            minParams = 3;
        } else if (args[base].equals("-L")) {
            lenient = true;
        } else if (args[base].equals("-n")) {
            listNames = true;
            minParams = 3;
        } else if (args[base].equals("-p")) {
            protocol = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-w")) {
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
        } else if (args[base].equals("-T")) {
            trustmgr = args[++base];
        } else if (args[base].equals("-PrH")) {
            proxyHost = args[++base];
            String parts[] = proxyHost.split(":");
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
        } else if (args[base].equals("-PrU")) {
            proxyUser = args[++base];
        } else if (args[base].equals("-PrP")) {
            proxyPassword = args[++base];
        } else if (args[base].equals("-#")) {
            printHash = true;
        } else {
            break;
        }
    }

    int remain = args.length - base;
    if (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        System.err.println(USAGE);
        System.exit(1);
    }

    String server = args[base++];
    int port = 0;
    String parts[] = server.split(":");
    if (parts.length == 2) {
        server = parts[0];
        port = Integer.parseInt(parts[1]);
    }
    String username = args[base++];
    String password = args[base++];
    String account = args[base++];

    String remote = null;
    if (args.length - base > 0) {
        remote = args[base++];
    }

    String local = null;
    if (args.length - base > 0) {
        local = args[base++];
    }

    boolean mustCallProtP = false;
    final FTPClient ftp;
    if (protocol == null) {
        if (proxyHost != null) {
            System.out.println("Using HTTP proxy server: " + proxyHost);
            ftp = new FTPHTTPClient(proxyHost, proxyPort, proxyUser, proxyPassword);
        } else {
            ftp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (protocol.equals("true")) {
            System.out.println("Implicit FTPS");
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            System.out.println("Explicit FTPS");
            ftps = new FTPSClient(false);
            mustCallProtP = true;
        } else {
            String prot[] = protocol.split(",");
            System.out.println("Protocl FTPS: " + protocol);

            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                mustCallProtP = !Boolean.parseBoolean(prot[1]);
                ftps = new FTPSClient(prot[0], !mustCallProtP);
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            System.out.println("Accept all");
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            System.out.println("Accept after valid");
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            System.out.println("Accept none");
            ftps.setTrustManager(null);
        }
    }

    if (printHash) {
        ftp.setCopyStreamListener(createListener());
    }
    if (keepAliveTimeout >= 0) {
        ftp.setControlKeepAliveTimeout(keepAliveTimeout);
    }
    if (controlKeepAliveReplyTimeout >= 0) {
        ftp.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    ftp.setListHiddenFiles(hidden);

    // suppress login details
    ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out), true));

    try {
        int reply;
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }
        System.out.println("Connected to " + server + " on " + (port > 0 ? port : ftp.getDefaultPort()));

        // 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);
        }
    } catch (IOException e) {
        if (ftp.getDataConnectionMode() == FTPClient.ACTIVE_LOCAL_DATA_CONNECTION_MODE) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        System.exit(1);
    }

    __main: try {
        if (account == null) {
            if (!ftp.login(username, password)) {
                ftp.logout();
                error = true;
                break __main;
            }
        } else {
            if (!ftp.login(username, password, account)) {
                ftp.logout();
                error = true;
                break __main;
            }
        }
        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (localActive) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4(useEpsvWithIPv4);

        if (mustCallProtP) {
            ((FTPSClient) ftp).execPBSZ(0);
            ((FTPSClient) ftp).execPROT("P");
        }

        if (storeFile) {
            InputStream input;

            input = new FileInputStream(local);

            ftp.storeFile(remote, input);

            input.close();
        } else if (listFiles) {
            if (lenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                ftp.configure(config);
            }

            for (FTPFile f : ftp.listFiles(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlsd) {
            for (FTPFile f : ftp.mlistDir(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlst) {
            FTPFile f = ftp.mlistFile(remote);
            if (f != null) {
                System.out.println(f.toFormattedString());
            }
        } else if (listNames) {
            for (String s : ftp.listNames(remote)) {
                System.out.println(s);
            }
        } else if (feat) {
            // boolean feature check
            if (remote != null) { // See if the command is present
                if (ftp.hasFeature(remote)) {
                    System.out.println("Has feature: " + remote);
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " was not detected");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }

                // Strings feature check
                String[] features = ftp.featureValues(remote);
                if (features != null) {
                    for (String f : features) {
                        System.out.println("FEAT " + remote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " is not present");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }
            } else {
                if (ftp.features()) {
                    // Command listener has already printed the output
                } else {
                    System.out.println("Failed: " + ftp.getReplyString());
                }
            }
        } else if (doCommand != null) {
            if (ftp.doCommand(doCommand, remote)) {
                // Command listener has already printed the output
                // for(String s : ftp.getReplyStrings()) {
                // System.out.println(s);
                // }
            } else {
                System.out.println("Failed: " + ftp.getReplyString());
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(local);

            ftp.retrieveFile(remote, output);

            output.close();
        }

        ftp.noop(); // check that control connection is working OK

        ftp.logout();
    } catch (FTPConnectionClosedException e) {
        error = true;
        System.err.println("Server closed connection.");
        e.printStackTrace();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.getDataConnectionMode() == FTPClient.ACTIVE_LOCAL_DATA_CONNECTION_MODE) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

    System.exit(error ? 1 : 0);
}

From source file:rems.Global.java

public static String UploadFile(InetAddress ftpserverurl, String serverAppDirectory, String PureFileName,
        String fullLocFileUrl, String userName, String password) {
    // get an ftpClient object  
    FTPClient ftpClient = new FTPClient();
    FileInputStream inputStream = null;
    String responsTxt = "";
    try {//from   w  w w  .  j a  va 2 s.c  o m
        // pass directory path on server to connect
        // pass username and password, returned true if authentication is  
        // successful  
        ftpClient.connect(ftpserverurl, 21);
        boolean login = ftpClient.login(userName, password);
        ftpClient.setKeepAlive(false);
        ftpClient.setPassiveNatWorkaround(true);
        if (login) {
            ftpClient.enterLocalPassiveMode();
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            File firstLocalFile = new File(fullLocFileUrl);
            inputStream = new FileInputStream(firstLocalFile);
            //inputStream.reset();
            boolean uploaded = ftpClient.storeFile(serverAppDirectory + PureFileName, inputStream);
            inputStream.close();
            responsTxt = ftpClient.getReplyString();
            if (uploaded) {
                responsTxt += "File uploaded successfully !";
            } else {
                responsTxt += "Error in uploading file !::" + serverAppDirectory + PureFileName;
            }

            Global.updateLogMsg(Global.logMsgID, "\r\n\r\n\r\nUpload Response ==>\r\n" + responsTxt,
                    Global.logTbl, Global.gnrlDateStr, Global.rnUser_ID);
            // logout the user, returned true if logout successfully  
            boolean logout = ftpClient.logout();
            if (logout) {
                //System.out.println("Connection close...");
            }
        } else {
            Global.errorLog += "Connection Failed..." + responsTxt;
            Global.updateLogMsg(Global.logMsgID,
                    "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                    Global.gnrlDateStr, Global.rnUser_ID);
            Global.writeToLog();
        }
        return responsTxt;
    } catch (SocketException e) {
        Global.errorLog += e.getMessage() + "\r\n" + Arrays.toString(e.getStackTrace());
        Global.updateLogMsg(Global.logMsgID,
                "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                Global.gnrlDateStr, Global.rnUser_ID);
        Global.writeToLog();
    } catch (IOException e) {
        Global.errorLog += e.getMessage() + "\r\n" + Arrays.toString(e.getStackTrace());
        Global.updateLogMsg(Global.logMsgID,
                "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                Global.gnrlDateStr, Global.rnUser_ID);
        Global.writeToLog();
    } finally {
        try {
            ftpClient.disconnect();
        } catch (IOException e) {
            Global.errorLog += e.getMessage() + "\r\n" + Arrays.toString(e.getStackTrace());
            Global.updateLogMsg(Global.logMsgID,
                    "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                    Global.gnrlDateStr, Global.rnUser_ID);
            Global.writeToLog();
        } finally {

        }
    }
    return "";
}

From source file:rems.Global.java

public static String DownloadFile(InetAddress ftpserverurl, String serverAppDirectory, String PureFileName,
        String fullLocFileUrl, String userName, String password) {

    File f = new File(fullLocFileUrl);
    // get an ftpClient object  
    FTPClient ftpClient = new FTPClient();
    String responsTxt = "";
    try {//from  www  .ja va2 s .c o  m
        // pass directory path on server to connect  
        ftpClient.connect(ftpserverurl, 21);
        // pass username and password, returned true if authentication is  
        // successful  
        boolean login = ftpClient.login(userName, password);
        if (login) {
            ftpClient.enterLocalPassiveMode();
            //ftpClient.setFileTransferMode(FTP.BLOCK_TRANSFER_MODE);
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            OutputStream outputStream1 = new BufferedOutputStream(new FileOutputStream(f));
            boolean download = ftpClient.retrieveFile(serverAppDirectory + PureFileName, outputStream1);
            outputStream1.close();

            //fos = new FileOutputStream(fullLocFileUrl);
            //boolean download = ftpClient.retrieveFile(serverAppDirectory + PureFileName, fos);
            responsTxt = ftpClient.getReplyString();
            if (download) {
                responsTxt += "File downloaded successfully !";
            } else {
                responsTxt += "Error in downloading file !::" + serverAppDirectory + PureFileName;
            }
            Global.updateLogMsg(Global.logMsgID, "\r\n\r\nDownload Response ==>\r\n" + responsTxt,
                    Global.logTbl, Global.gnrlDateStr, Global.rnUser_ID);
            Global.writeToLog();
            // logout the user, returned true if logout successfully  
            boolean logout = ftpClient.logout();
            if (logout) {
                //System.out.println("Connection close...");
            }
        } else {
            Global.errorLog += "Connection Failed..." + responsTxt;
            Global.updateLogMsg(Global.logMsgID,
                    "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                    Global.gnrlDateStr, Global.rnUser_ID);
            Global.writeToLog();
        }
        return responsTxt;
    } catch (SocketException e) {
        Global.errorLog += Arrays.toString(e.getStackTrace());
        Global.updateLogMsg(Global.logMsgID,
                "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                Global.gnrlDateStr, Global.rnUser_ID);
        Global.writeToLog();
    } catch (IOException e) {
        Global.errorLog += Arrays.toString(e.getStackTrace());
        Global.updateLogMsg(Global.logMsgID,
                "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                Global.gnrlDateStr, Global.rnUser_ID);
        Global.writeToLog();
    } finally {
        try {
            ftpClient.disconnect();
        } catch (IOException e) {
            Global.errorLog += Arrays.toString(e.getStackTrace());
            Global.updateLogMsg(Global.logMsgID,
                    "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + Global.errorLog, Global.logTbl,
                    Global.gnrlDateStr, Global.rnUser_ID);
            Global.writeToLog();
        } finally {

        }
    }
    Global.updateLogMsg(Global.logMsgID, "\r\n\r\n\r\nThe Program has Errored Out ==>\r\n\r\n" + responsTxt,
            Global.logTbl, Global.gnrlDateStr, Global.rnUser_ID);
    return responsTxt;
}

From source file:ru.in360.FTPUtil.java

public static void saveFilesToServer(FTPClient ftp, String remoteDest, File localSrc) throws IOException {
    //        FTPClient ftp = new FTPClient();
    //// www.j  a v  a2s .  c  om
    //        ftp.connect("46.8.19.232", 21);
    //
    //
    //        if (!FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
    //            ftp.disconnect();
    //            System.out.println("FTP not disconnected");
    //        }
    //        ftp.login("admin", "fa43limited");
    //        ftp.enterLocalPassiveMode();
    System.out.println("Connected to server .");

    System.out.println("remote directory: " + remoteDest);
    ftp.changeWorkingDirectory(remoteDest);
    ftp.setFileType(FTPClient.BINARY_FILE_TYPE);

    System.out.println("upload: " + localSrc.getPath());
    upload(localSrc, ftp);
    System.out.println(ftp.getReplyString());

}

From source file:simplehttpdb.net.FTPHelper.java

/**
 * returns an FTP connection to the given server
 * if login fails null will be returned/*from w  w  w  .  j av a  2s.  c o m*/
 * @param ftpServer
 * @param ftpUser
 * @param ftpPass
 * @return
 * @throws SocketException
 * @throws IOException
 */
public FTPClient getFTPConnection(String ftpServer, String ftpUser, String ftpPass)
        throws SocketException, IOException {

    FTPClient ftp = new FTPClient();

    int reply;

    ftp.connect(ftpServer);
    Logger.getLogger(FTPHelper.class.getName()).log(Level.INFO,
            "Connected to " + ftpServer + " --> " + ftp.getReplyString());

    if (!FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
        ftp.disconnect();
        Logger.getLogger(getClass().getName()).log(Level.SEVERE, "FTP server refused connection.");
        return null;
    }
    if (ftp.login(ftpUser, ftpPass)) {
        return ftp;
    } //else
    return null;
}