filesystemconnection.java

一个JAVA做的FTP软件,带源码的,可以很好的进行二次开发,,并带有详细说明文件的

        size = new String[files.length];
        perms = new int[files.length];

        int accessible = 0;

        for(int i = 0; i < files.length; i++)
        {
            File f2 = new File(pwd + files[i]);

            if(f2.isDirectory() && !files[i].endsWith("/"))
            {
                files[i] = files[i] + "/";
            }

            size[i] = "" + new File(pwd + files[i]).length();

            if(f2.canWrite())
            {
                accessible = FtpConnection.W;
            }
            else if(f2.canRead())
            {
                accessible = FtpConnection.R;
            }
            else
            {
                accessible = FtpConnection.DENIED;
            }

            perms[i] = accessible;

            //System.out.println(pwd+files[i] +" : " +accessible + " : " + size[i]);
        }

        return files;
    }

    public String[] sortSize(String file)
    {
        return size;
    }

    public int[] getPermissions(String file)
    {
        return perms;
    }

    public int handleDownload(String file)
    {
        transfer(file);

        return 0;
    }

    public int handleUpload(String file)
    {
        transfer(file);

        return 0;
    }

    public int download(String file)
    {
        transfer(file);

        return 0;
    }

    public int upload(String file)
    {
        transfer(file);

        return 0;
    }

    private void transferDir(String dir, String out)
    {
        fileCount = 0;
        shortProgress = true;
        baseFile = StringUtils.getDir(dir);

        File f2 = new File(dir);
        String[] tmp = f2.list();

        if(tmp == null)
        {
            return;
        }

        File fx = new File(out);

        if(!fx.mkdir())
        {
            Log.debug("Can not create directory: " + out +
                      " - already exist or permission denied?");
        }

        for(int i = 0; i < tmp.length; i++)
        {
            tmp[i] = tmp[i].replace('\\', '/');

            //System.out.println("1: " + dir+tmp[i] + ", " + out +tmp[i]);
            File f3 = new File(dir + tmp[i]);

            if(f3.isDirectory())
            {
                if(!tmp[i].endsWith("/"))
                {
                    tmp[i] = tmp[i] + "/";
                }

                transferDir(dir + tmp[i], out + tmp[i]);
            }
            else
            {
                fireProgressUpdate(baseFile,
                                   DataConnection.GETDIR + ":" + fileCount, -1);
                work(dir + tmp[i], out + tmp[i]);
            }
        }

        fireProgressUpdate(baseFile,
                           DataConnection.DFINISHED + ":" + fileCount, -1);
        shortProgress = false;
    }

    private void transfer(String file)
    {
        String out = StringUtils.getDir(file);

        if(StringUtils.isRelative(file))
        {
            file = getPWD() + file;
        }

        file = file.replace('\\', '/');
        out = out.replace('\\', '/');

        String outfile = StringUtils.getFile(file);

        if(file.endsWith("/"))
        {
            transferDir(file, getLocalPath() + out);

            return;
        }
        else
        {
            work(file, getLocalPath() + outfile);
        }
    }

    private void work(String file, String outfile)
    {
        try
        {
            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outfile));
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
            byte[] buf = new byte[filesystemBuffer];
            int len = 0;
            int reallen = 0;

            //System.out.println(file+":"+getLocalPath()+outfile);
            while(true)
            {
                len = in.read(buf);

                //System.out.print(".");
                if(len == StreamTokenizer.TT_EOF)
                {
                    break;
                }

                out.write(buf, 0, len);

                reallen += len;
                fireProgressUpdate(StringUtils.getFile(file),
                                   DataConnection.GET, reallen);
            }

            out.flush();
            out.close();
            in.close();
            fireProgressUpdate(file, DataConnection.FINISHED, -1);
        }
        catch(IOException ex)
        {
            Log.debug("Error with file IO (" + ex + ")!");
            fireProgressUpdate(file, DataConnection.FAILED, -1);
        }
    }

    public int upload(String file, InputStream in)
    {
        if(StringUtils.isRelative(file))
        {
            file = getPWD() + file;
        }

        file = file.replace('\\', '/');

        try
        {
            work(new BufferedInputStream(in), file, file);

            return 0;
        }
        catch(Exception ex)
        {
            Log.debug("Error: " + ex.toString());
            ex.printStackTrace();

            return -1;
        }
    }

    private void work(BufferedInputStream in, String outfile, String file)
    {
        try
        {
            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outfile));
            byte[] buf = new byte[filesystemBuffer];
            int len = 0;
            int reallen = 0;

            while(true)
            {
                len = in.read(buf);
                System.out.print(".");

                if(len == StreamTokenizer.TT_EOF)
                {
                    break;
                }

                out.write(buf, 0, len);

                reallen += len;
                fireProgressUpdate(StringUtils.getFile(file),
                                   DataConnection.GET, reallen);
            }

            out.flush();
            out.close();
            in.close();
            fireProgressUpdate(file, DataConnection.FINISHED, -1);
        }
        catch(IOException ex)
        {
            Log.debug("Error with file IO (" + ex + ")!");
            fireProgressUpdate(file, DataConnection.FAILED, -1);
        }
    }

    public InputStream getDownloadInputStream(String file)
    {
        if(StringUtils.isRelative(file))
        {
            file = getPWD() + file;
        }

        file = file.replace('\\', '/');

        try
        {
            return new FileInputStream(file);
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
            Log.debug(ex.toString() +
                      " @Filesystemconnection::getDownloadInputStream");

            return null;
        }
    }

    public void addConnectionListener(ConnectionListener l)
    {
        listeners.add(l);
    }

    public void setConnectionListeners(Vector l)
    {
        listeners = l;
    }

    /** remote directory has changed */
    public void fireDirectoryUpdate()
    {
        if(listeners == null)
        {
            return;
        }
        else
        {
            for(int i = 0; i < listeners.size(); i++)
            {
                ((ConnectionListener) listeners.elementAt(i)).updateRemoteDirectory(this);
            }
        }
    }

    public boolean login(String user, String pass)
    {
        return true;
    }

    public void fireProgressUpdate(String file, String type, int bytes)
    {
        if(listeners == null)
        {
            return;
        }
        else
        {
            for(int i = 0; i < listeners.size(); i++)
            {
                ConnectionListener listener = (ConnectionListener) listeners.elementAt(i);

                if(shortProgress && Settings.shortProgress)
                {
                    if(type.startsWith(DataConnection.DFINISHED))
                    {
                        listener.updateProgress(baseFile,
                                                DataConnection.DFINISHED + ":" +
                                                fileCount, bytes);
                    }

                    listener.updateProgress(baseFile,
                                            DataConnection.GETDIR + ":" +
                                            fileCount, bytes);
                }
                else
                {
                    listener.updateProgress(file, type, bytes);
                }
            }
        }
    }
}