home | career | drupal | java | mac | mysql | perl | scala | uml | unix  

What this is

This file is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Other links

The source code

// $Header: /home/cvs/jakarta-jmeter/src/protocol/ftp/org/apache/jmeter/protocol/ftp/sampler/FtpClient.java,v 1.8 2004/02/11 23:59:31 sebb Exp $
/*
 * Copyright 2001-2004 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
*/

package org.apache.jmeter.protocol.ftp.sampler;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

import org.apache.jorphan.logging.LoggingManager;
import org.apache.log.Logger;

/**
 * Simple FTP client (non-passive transfers don't work yet).
 * Kind of a hack, lots of room for optimizations.
 *
 * @author     mike
 * Created    August 31, 2001
 * @version $Revision: 1.8 $ Last updated: $Date: 2004/02/11 23:59:31 $
 */
public class FtpClient
{
    transient private static Logger log = LoggingManager.getLoggerForClass();
    //File f = new File("e:\\");
    BufferedWriter out;
    BufferedReader in;
    Socket s;
    boolean passive = false;
    static int port = 21;
    static int dataPort = 4096;

    /**
     *  Constructor for the FtpClient object.
     */
    public FtpClient()
    {
    }

    /**
     * Set passive mode.
     *
     *@param  flag  the new Passive value
     */
    public void setPassive(boolean flag)
    {
        passive = flag;
    }

    /**
     * Get a file from the server.
     *
     * @return                  the Response value
     */
    public String getResponse() throws IOException
    {
        StringBuffer response = new StringBuffer();
        String line = in.readLine();
        response.append(line);
        log.info("FtpClient.getResponse(): #" + line + "#");
        while (line.charAt(3) == '-')
        {
            line = in.readLine();
            response.append("\n");
            response.append(line);
            log.info("FtpClient.getResponse(): #" + line + "#");
        }
        log.info("return response");
        return response.toString();
    }

    /**
     * Get a file from the server.
     */
    public String get(String file) throws Exception
    {
        send("SYST");
        getResponse();
        send("PWD");
        getResponse();
        send("TYPE I");
        getResponse();
        String data = "";
        if (!passive)
        {
            dataPort++;
            int upper = getUpper(dataPort);
            int lower = getLower(dataPort);
            String ip =
                InetAddress.getLocalHost().getHostAddress().replace('.', ',');
            String port = ip + "," + upper + "," + lower;
            log.info("port:" + port);
            send("PORT " + port);
            getResponse();
            dataGrabber grab = new dataGrabber(ip, dataPort);
            while (!grab.isPortCreated())
            {
            }
            send("RETR " + file);
            String response = in.readLine();
            log.info(response);
            log.info("" + dataPort);
            data = "FTP client - File Not Found";
            if (!response.startsWith("5"))
            {
                while (!grab.isDone())
                {
                }
                data = grab.getData();
            }
        }
        else
        {
            send("PASV");
            String port = getResponse();
            while (!port.startsWith("227"))
            {
                port = getResponse();
            }
            int start = port.indexOf('(');
            int end = port.indexOf(')');
            port = port.substring(start + 1, end);
            int a = port.indexOf(',');
            int b = port.indexOf(',', a + 1);
            int c = port.indexOf(',', b + 1);
            int d = port.indexOf(',', c + 1);
            int e = port.indexOf(',', d + 1);
            String ip =
                port.substring(0, a)
                    + "."
                    + port.substring(a + 1, b)
                    + "."
                    + port.substring(b + 1, c)
                    + "."
                    + port.substring(c + 1, d);
            int upper = Integer.parseInt(port.substring(d + 1, e));
            int lower = Integer.parseInt(port.substring(e + 1));
            int dataPort = getPort(upper, lower);
            send("RETR " + file);
            dataGrabber grab = new dataGrabber(ip, dataPort);
            getResponse();
            while (!grab.isDone())
            {
            }
            data = grab.getData();
        }
        return data;
    }

    /**
     * Connect to server.
     */
    public void connect(String host, String username, String password)
        throws Exception
    {
        InetAddress addr = InetAddress.getByName(host);
        s = new Socket(addr, port);
        out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        InputStreamReader isr = new InputStreamReader(s.getInputStream());
        in = new BufferedReader(isr);
        send("USER " + username);
        send("PASS " + password);
    }

    /**
     * Disconnect from the server
     */
    public void disconnect()
    {
        try
        {
            send("QUIT");
            getResponse();
        }
        catch (Exception e)
        {
            log.error("FTP client - ", e);
        }
        try
        {
            in.close();
            out.close();
            s.close();
        }
        catch (Exception e)
        {
            log.error("FTP client - ", e);
        }
    }

    /**
     * Send a command to the server.
     */
    public void send(String command) throws IOException
    {
        for (int i = 0; i < command.length(); i++)
        {
            out.write(command.charAt(i));
        }
        out.write('\r');
        out.write('\n');
        out.flush();
    }

    /**
     * Gets the Port attribute of the FtpClient class.
     * @return        the Port value
     */
    public static int getPort(int upper, int lower)
    {
        return upper * 256 + lower;
    }

    /**
     * Gets the Upper attribute of the FtpClient class.
     * @return       the Upper value
     */
    public static int getUpper(int port)
    {
        return port / 256;
    }

    /**
     * Gets the Lower attribute of the FtpClient class.
     *
     * @return       the Lower value
     */
    public static int getLower(int port)
    {
        return port % 256;
    }

    /**
     * Grabs the data from the dataport.
     *
     * @author     mike
     * Created    August 31, 2001
     * @version $Revision: 1.8 $ Last updated: $Date: 2004/02/11 23:59:31 $
     */
    public class dataGrabber implements Runnable
    {
        StringBuffer buffer = new StringBuffer();
        Socket s;
        boolean done = false;
        boolean portCreated = false;
        String host = "";
        int port = 22;

        /**
         * Constructor for the dataGrabber object.
         */
        public dataGrabber(String host, int port) throws Exception
        {
            this.host = host;
            this.port = port;
            new Thread((Runnable) this).start();
        }

        /**
         * Gets the Done attribute of the dataGrabber object.
         *
         * @return    the Done value
         */
        public boolean isDone()
        {
            return done;
        }

        /**
         * Gets the Data attribute of the dataGrabber object.
         *
         * @return    the Data value
         */
        public String getData()
        {
            return buffer.toString();
        }

        /**
         * Gets the PortCreated attribute of the dataGrabber object.
         *
         * @return    the PortCreated value
         */
        public boolean isPortCreated()
        {
            return portCreated;
        }

        /**
         * Main processing method for the dataGrabber object.
         */
        public void run()
        {
            try
            {
                if (passive)
                {
                    s = new Socket(host, port);
                }
                else
                {
                    log.info("creating socket on " + port);
                    ServerSocket server = new ServerSocket(port);
                    log.info("accepting...");
                    portCreated = true;
                    s = server.accept();
                    log.info("accepted");
                }
            }
            catch (Exception e)
            {
            }
            try
            {
                InputStream in = s.getInputStream();
                BufferedInputStream dataIn = new BufferedInputStream(in);
                int bufferSize = 4096;
                byte[] inputBuffer = new byte[bufferSize];
                int i = 0;
                while ((i = dataIn.read(inputBuffer, 0, bufferSize)) != -1)
                {
                    buffer.append((char) i);
                }
                dataIn.close();
                s.close();
            }
            catch (Exception e)
            {
                log.error("FTP client: dataGrabber", e);
            }
            done = true;
        }
    }
}


my book on functional programming

 

new blog posts

 

Copyright 1998-2019 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.