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

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

Introduction

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

Prototype

public void connect(InetAddress host, int port) throws SocketException, IOException 

Source Link

Document

Opens a Socket connected to a remote host at the specified port and originating from the current host at a system assigned port.

Usage

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  ww w  . j  ava 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:org.wso2.carbon.connector.FileFtpOverProxy.java

/**
 * Send file FTP over Proxy.//from  w  w w.j  a  v  a 2  s. co m
 *
 * @param proxyHost      Name of the proxy host.
 * @param proxyPort      Proxy port number.
 * @param proxyUsername  User name of the proxy.
 * @param proxyPassword  Password of the proxy.
 * @param ftpServer      FTP server.
 * @param ftpPort        Port number of FTP.
 * @param ftpUsername    User name of the FTP.
 * @param ftpPassword    Password of the FTP.
 * @param messageContext he message context that is generated for processing the ftpOverHttp method.
 * @return true, if the FTP client tunnels over an HTTP proxy connection or stores a file on the server.
 */
public boolean ftpOverHttp(String proxyHost, String proxyPort, String proxyUsername, String proxyPassword,
        String ftpServer, String ftpPort, String ftpUsername, String ftpPassword,
        MessageContext messageContext) {
    String keepAliveTimeout = (String) ConnectorUtils.lookupTemplateParamater(messageContext,
            FileConstants.KEEP_ALIVE_TIMEOUT);
    String controlKeepAliveReplyTimeout = (String) ConnectorUtils.lookupTemplateParamater(messageContext,
            FileConstants.CONTROL_KEEP_ALIVE_REPLY_TIMEOUT);
    String targetPath = (String) ConnectorUtils.lookupTemplateParamater(messageContext,
            FileConstants.TARGET_PATH);
    String targetFile = (String) ConnectorUtils.lookupTemplateParamater(messageContext,
            FileConstants.TARGET_FILE);
    String binaryTransfer = (String) ConnectorUtils.lookupTemplateParamater(messageContext,
            FileConstants.BINARY_TRANSFER);
    String localActive = (String) ConnectorUtils.lookupTemplateParamater(messageContext,
            FileConstants.LOCAL_ACTIVE);
    boolean resultStatus = false;
    InputStream inputStream = null;

    final FTPClient ftp;
    if (StringUtils.isNotEmpty(proxyHost) && StringUtils.isNotEmpty(proxyPort)
            && StringUtils.isNotEmpty(proxyUsername) && StringUtils.isNotEmpty(proxyPassword)) {
        proxyHost = proxyHost.trim();
        proxyPort = proxyPort.trim();
        proxyUsername = proxyUsername.trim();
        proxyPassword = proxyPassword.trim();
        ftp = new FTPHTTPClient(proxyHost, Integer.parseInt(proxyPort), proxyUsername, proxyPassword);
    } else {
        ftp = new FTPClient();
    }
    //Set the time to wait between sending control connection keep alive messages when
    // processing file upload or download (Zero (or less) disables).
    keepAliveTimeout = keepAliveTimeout.trim();
    if (StringUtils.isNotEmpty(keepAliveTimeout)) {
        ftp.setControlKeepAliveTimeout(Long.parseLong(keepAliveTimeout.trim()));
    }
    //Set how long to wait for control keep-alive message replies.(defaults to 1000 milliseconds.)
    if (StringUtils.isNotEmpty(controlKeepAliveReplyTimeout)) {
        ftp.setControlKeepAliveReplyTimeout(Integer.parseInt(controlKeepAliveReplyTimeout.trim()));
    }
    try {
        int reply;
        ftpPort = ftpPort.trim();
        int IntFtpPort = Integer.parseInt(ftpPort);
        if (IntFtpPort > 0) {
            ftp.connect(ftpServer, IntFtpPort);
        } else {
            ftpServer = ftpServer.trim();
            ftp.connect(ftpServer);
        }
        if (log.isDebugEnabled()) {
            log.debug(
                    " Connected to " + ftpServer + " on " + (IntFtpPort > 0 ? ftpPort : ftp.getDefaultPort()));
        }
        // After connection attempt, should check the reply code to verify success.
        reply = ftp.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            log.error("FTP ftpServer refused connection.");
        }
        if (ftp.login(ftpUsername, ftpPassword)) {
            if (StringUtils.isNotEmpty(binaryTransfer)) {
                if (Boolean.valueOf(binaryTransfer.trim())) {
                    ftp.setFileType(FTP.BINARY_FILE_TYPE);
                } else {
                    // in theory this should not be necessary as servers should default to ASCII
                    // but they don't all do so - see NET-500
                    ftp.setFileType(FTP.ASCII_FILE_TYPE);
                }
            } else {
                ftp.setFileType(FTP.ASCII_FILE_TYPE);
            }
            // Use passive mode as default because most of us are behind firewalls these days.
            if (StringUtils.isNotEmpty(localActive)) {
                if (Boolean.valueOf(localActive.trim())) {
                    ftp.enterLocalActiveMode();
                } else {
                    ftp.enterLocalPassiveMode();
                }
            } else {
                ftp.enterLocalPassiveMode();
            }
            inputStream = new ByteArrayInputStream(
                    messageContext.getEnvelope().getBody().getFirstElement().toString().getBytes());
            if (StringUtils.isNotEmpty(targetPath)) {
                ftp.changeWorkingDirectory(targetPath);
                ftp.storeFile(targetFile, inputStream);
                if (log.isDebugEnabled()) {
                    log.debug("Successfully FTP transfered the File");
                }
            }
            // check that control connection is working
            if (log.isDebugEnabled()) {
                log.debug("The code received from the server." + ftp.noop());
            }
            resultStatus = true;
        } else {
            ftp.logout();
            handleException("Error while login ftp server.", messageContext);
        }
    } catch (FTPConnectionClosedException e) {
        // log.error("Server closed connection " + e.getMessage(), e);
        handleException("Server closed connection: " + e.getMessage(), e, messageContext);
    } catch (IOException e) {
        //log.error("Error occurred while uploading:" + e.getMessage(), e);
        handleException("Could not connect to FTP ftpServer: " + e.getMessage(), e, messageContext);
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
                ftp.logout();
            } catch (IOException f) {
                log.error("Error while disconnecting/logging out ftp server");
            }
        }
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException f) {
                log.error("Error while closing inputStream");
            }
        }
    }
    return resultStatus;
}

From source file:org.wso2.carbon.connector.FileFtpOverProxyConnector.java

/**
 * Send file FTP over Proxy./*w w  w.j a v  a  2 s .  c o  m*/
 *
 * @param messageContext The message context that is generated for processing the file.
 * @return true, if the FTP client tunnels over an HTTP proxy connection or stores a file on the server.
 *
 */
public boolean ftpOverHttpProxy(MessageContext messageContext) {
    String proxyHost = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.PROXY_HOST));
    String proxyPort = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.PROXY_PORT));
    String proxyUsername = StringUtils.trim(
            (String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.PROXY_USERNAME));
    String proxyPassword = StringUtils.trim(
            (String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.PROXY_PASSWORD));
    String ftpHost = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.FTP_SERVER));
    String ftpPort = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.FTP_PORT));
    String ftpUsername = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.FTP_USERNAME));
    String ftpPassword = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.FTP_PASSWORD));
    String keepAliveTimeout = StringUtils.trim(
            (String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.KEEP_ALIVE_TIMEOUT));
    String controlKeepAliveReplyTimeout = StringUtils.trim((String) ConnectorUtils
            .lookupTemplateParamater(messageContext, FileConstants.CONTROL_KEEP_ALIVE_REPLY_TIMEOUT));
    String targetPath = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.TARGET_PATH));
    String targetFile = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.TARGET_FILE));
    String activeMode = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.ACTIVE_MODE));
    String fileType = StringUtils
            .trim((String) ConnectorUtils.lookupTemplateParamater(messageContext, FileConstants.FILE_TYPE));
    boolean activeModeParameter = false;

    if (StringUtils.isEmpty(keepAliveTimeout)) {
        keepAliveTimeout = FileConstants.DEFAULT_KEEP_ALIVE_TIMEOUT;
    }
    if (StringUtils.isEmpty(controlKeepAliveReplyTimeout)) {
        controlKeepAliveReplyTimeout = FileConstants.DEFAULT_CONTROL_KEEP_ALIVE_REPLY_TIMEOUT;
    }
    if (StringUtils.isNotEmpty(activeMode)) {
        activeModeParameter = Boolean.parseBoolean(activeMode);
    }

    InputStream inputStream = null;
    FTPClient ftp = new FTPClient();
    if (StringUtils.isNotEmpty(proxyHost) && StringUtils.isNotEmpty(proxyPort)
            && StringUtils.isNotEmpty(proxyUsername) && StringUtils.isNotEmpty(proxyPassword)) {
        ftp = new FTPHTTPClient(proxyHost, Integer.parseInt(proxyPort), proxyUsername, proxyPassword);
    }
    //Set the time to wait between sending control connection keep alive messages when processing file upload or
    // download (Zero (or less) disables).
    ftp.setControlKeepAliveTimeout(Long.parseLong(keepAliveTimeout));
    //Set how long to wait for control keep-alive message replies.(defaults to 1000 milliseconds.)
    ftp.setControlKeepAliveReplyTimeout(Integer.parseInt(controlKeepAliveReplyTimeout));
    try {
        int reply;
        int IntFtpPort = Integer.parseInt(ftpPort);
        if (IntFtpPort > 0) {
            ftp.connect(ftpHost, IntFtpPort);
        } else {
            ftp.connect(ftpHost);
        }
        if (log.isDebugEnabled()) {
            log.debug(" Connected to " + ftpHost + " on " + (IntFtpPort > 0 ? ftpPort : ftp.getDefaultPort()));
        }
        // After connection attempt, should check the reply code to verify success.
        reply = ftp.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            log.error("FTP ftpServer refused connection.");
        }
        if (!ftp.login(ftpUsername, ftpPassword)) {
            ftp.logout();
            throw new SynapseException("Error while login ftp server.");
        }
        setFileType(fileType, ftp);

        // Use passive mode as default because most of us are behind firewalls these days.
        if (activeModeParameter) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }
        inputStream = new ByteArrayInputStream(
                messageContext.getEnvelope().getBody().getFirstElement().toString().getBytes());
        if (StringUtils.isNotEmpty(targetPath)) {
            ftp.changeWorkingDirectory(targetPath);
            ftp.storeFile(targetFile, inputStream);
            if (log.isDebugEnabled()) {
                log.debug("Successfully FTP server transferred the File");
            }
        }
        // check that control connection is working
        if (log.isDebugEnabled()) {
            log.debug("The code received from the server." + ftp.noop());
        }
    } catch (IOException e) {
        throw new SynapseException("Could not connect to FTP Server", e);
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
                ftp.logout();
            } catch (IOException f) {
                log.error("Error while disconnecting/logging out ftp server");
            }
        }
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException f) {
                log.error("Error while closing inputStream");
            }
        }
    }
    return true;
}

From source file:org.wso2.iot.agent.services.FileDownloadService.java

/**
 * This method downloads the file using sftp client.
 *
 * @param operation      - operation object.
 * @param host           - host address.
 * @param ftpUserName    - ftp user name.
 * @param ftpPassword    - ftp password.
 * @param savingLocation - location in the device to save the file.
 * @param fileName       - name of the file to download.
 * @param serverPort     - ftp server port.
 * @param fileDirectory  - the directory of the file in FTP server.
 * @throws AndroidAgentException - Android agent exception.
 *///w  ww.java2 s.c o m
private void downloadFileUsingFTPClient(Operation operation, String host, String ftpUserName,
        String ftpPassword, String savingLocation, String fileName, int serverPort, String fileDirectory)
        throws AndroidAgentException {

    FTPClient ftpClient = new FTPClient();
    FileOutputStream fileOutputStream = null;
    OutputStream outputStream = null;
    String response;
    try {
        ftpClient.connect(host, serverPort);
        if (ftpClient.login(ftpUserName, ftpPassword)) {
            ftpClient.enterLocalPassiveMode();
            fileOutputStream = new FileOutputStream(savingLocation + File.separator + fileName);
            outputStream = new BufferedOutputStream(fileOutputStream);
            ftpClient.changeWorkingDirectory(fileDirectory);
            if (ftpClient.retrieveFile(fileName, outputStream)) {
                response = "File uploaded to the device successfully ( " + fileName + " ).";
                operation.setStatus(resources.getString(R.string.operation_value_completed));
            } else {
                response = "File uploaded to the device not completed ( " + fileName + " ).";
                operation.setStatus(resources.getString(R.string.operation_value_error));
            }
            operation.setOperationResponse(response);
        } else {
            downloadFileUsingFTPSClient(operation, host, ftpUserName, ftpPassword, savingLocation, fileName,
                    serverPort, fileDirectory);
        }
    } catch (FTPConnectionClosedException | ConnectException e) {
        downloadFileUsingFTPSClient(operation, host, ftpUserName, ftpPassword, savingLocation, fileName,
                serverPort, fileDirectory);
    } catch (IOException e) {
        handleOperationError(operation, fileTransferExceptionCause(e, fileName), e);
    } finally {
        try {
            if (ftpClient.isConnected()) {
                ftpClient.logout();
                ftpClient.disconnect();
            }
        } catch (IOException ignored) {
        }
        cleanupStreams(null, outputStream, null, fileOutputStream, null, null, null, null);
    }
}

From source file:org.wso2.iot.agent.services.FileUploadService.java

/**
 * File upload operation using an FTP client.
 *
 * @param operation       - operation object.
 * @param host            - host name./*w  ww  .  j ava2s . c o  m*/
 * @param ftpUserName     - ftp user name.
 * @param ftpPassword     - ftp password.
 * @param uploadDirectory - ftp directory to upload file.
 * @param fileLocation    - local file location.
 * @param serverPort      - ftp port to connect.
 * @throws AndroidAgentException - AndroidAgent exception.
 */
private void uploadFileUsingFTPClient(Operation operation, String host, String ftpUserName, String ftpPassword,
        String uploadDirectory, String fileLocation, int serverPort) throws AndroidAgentException {
    FTPClient ftpClient = new FTPClient();
    String fileName = null;
    InputStream inputStream = null;
    String response;
    try {
        File file = new File(fileLocation);
        fileName = file.getName();
        ftpClient.connect(host, serverPort);
        ftpClient.enterLocalPassiveMode();
        ftpClient.login(ftpUserName, ftpPassword);
        inputStream = new FileInputStream(file);
        ftpClient.changeWorkingDirectory(uploadDirectory);
        if (ftpClient.storeFile(file.getName(), inputStream)) {
            response = "File uploaded from the device completed ( " + fileName + " ).";
            operation.setStatus(resources.getString(R.string.operation_value_completed));
        } else {
            response = "File uploaded from the device not completed ( " + fileName + " ).";
            operation.setStatus(resources.getString(R.string.operation_value_error));
        }
        operation.setOperationResponse(response);
    } catch (FTPConnectionClosedException e) {
        uploadFileUsingFTPSClient(operation, host, ftpUserName, ftpPassword, uploadDirectory, fileLocation,
                serverPort);
    } catch (IOException e) {
        handleOperationError(operation, fileTransferExceptionCause(e, fileName), e, resources);
    } finally {
        if (ftpClient.isConnected()) {
            try {
                ftpClient.logout();
            } catch (IOException ignored) {
            }
        }
        if (ftpClient.isConnected()) {
            try {
                ftpClient.disconnect();
            } catch (IOException ignored) {
            }
        }
        cleanupStreams(inputStream, null, null, null, null, null, null, null);
    }
}

From source file:pl.psnc.synat.wrdz.zmd.download.adapters.FtpDownloadAdapter.java

/**
 * Establishes connection to the FTP server or throws exceptions if any problems occur.
 * //from   w  w  w  . jav  a2  s.  c om
 * @param ftpClient
 *            client instance to operate on.
 * @throws DownloadAdapterException
 *             should any problems occur.
 */
private void connectToFtp(FTPClient ftpClient) throws DownloadAdapterException {
    try {
        ftpClient.connect(connectionInfo.getHost(), connectionInfo.getPort());
        if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
            throw new DownloadAdapterException(
                    "Unable to establish connection to the server, server refused connection.");
        }
    } catch (IOException e) {
        throw new DownloadAdapterException("Exception while trying to establish connection to the server.", e);
    }
}

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 {//  www . j  a v a  2  s .co 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 {/*  w ww  .  j  a  va 2 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:ro.kuberam.libs.java.ftclient.FTP.FTP.java

public <X> X connect(URI remoteHostUri, String username, String password, String remoteHost, int remotePort,
        String options) throws Exception {
    long startTime = new Date().getTime();
    X abstractConnection = null;/*from   ww  w .j a  v a2s  . c  o m*/
    FTPClient ftpConnection = new FTPClient();
    try {
        remotePort = (remotePort == -1) ? (int) 21 : remotePort;
        ftpConnection.setDefaultTimeout(60 * 1000);
        ftpConnection.setRemoteVerificationEnabled(false);
        // FTPconnection.setSoTimeout( 60 * 1000 );
        // FTPconnection.setDataTimeout( 60 * 1000 );
        ftpConnection.connect(remoteHost, remotePort);
        ftpConnection.login(username, password);
        ftpConnection.enterLocalPassiveMode();
        ftpConnection.setFileType(FTPClient.BINARY_FILE_TYPE);
        // FTPconnection.setControlKeepAliveTimeout(300);
        // Check reply code for success
        int reply = ftpConnection.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpConnection.disconnect();
            throw new Exception(ErrorMessages.err_FTC005);
        } else {
            abstractConnection = (X) ftpConnection;
        }
    } catch (IOException se) {
        if (ftpConnection.isConnected()) {
            try {
                ftpConnection.disconnect();
            } catch (IOException ioe) {
                throw new Exception(ErrorMessages.err_FTC005);
            }
        }
    }
    log.info("The FTP sub-module connected to '" + remoteHostUri + "' in " + (new Date().getTime() - startTime)
            + " ms.");
    return abstractConnection;
}

From source file:ru.in360.FTPUploader.java

public boolean uploadFolder(File src, URI dest) {
    FTPClient ftpClient = new FTPClient();

    try {//from  w  w w  . ja va 2  s.c o  m
        // connect and login to the server
        ftpClient.connect(server, port);
        ftpClient.login(user, pass);

        // use local passive mode to pass firewall
        ftpClient.enterLocalPassiveMode();

        System.out.println("Connected");

        String remoteDirPath = "/Upload";
        String localDirPath = "E:/winhex";

        FTPUtil.saveFilesToServer(ftpClient, remoteProject, src);

        // log out and disconnect from the server
        ftpClient.logout();
        ftpClient.disconnect();

        System.out.println("Disconnected");
        return true;
    } catch (IOException ex) {
        ex.printStackTrace();
        return false;
    }
}