Ftp上传类(FtpClient)

mofdan

　　
　　网上找的，学习下
　　
Code
using System;
using System.Net;
using System.IO;
using System.Text;
using System.Net.Sockets;
using System.Diagnostics;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Messaging;
using System.Threading;
/**
  * FTP Client library in C#
  * Author: Jaimon Mathew
  * mailto:jaimonmathew@rediffmail.com
  * http://www.csharphelp.com/archives/archive9.html
  *
  * Addapted for use by Dan Glass 07/03/03
  */

namespace Main08
{
    public class FtpClient
    {
        public class FtpException : Exception
        {
            public FtpException(string message)
                : base(message)
            {
            }
            public FtpException(string message, Exception innerException)
                : base(message, innerException)
            {
            }
        }
        private static int BUFFER_SIZE = 512;
        private static Encoding ASCII = Encoding.Default;
        private bool verboseDebugging = false;
        // defaults
        private string server = "localhost";
        private string remotePath = ".";
        private string username = "anonymous";
        private string password = "anonymous@anonymous.net";
        private string message = null;
        private string result = null;
        private int port = 21;
        private int bytes = 0;
        private int resultCode = 0;
        private bool loggedin = false;
        private bool binMode = false;
        private Byte[] buffer = new Byte[BUFFER_SIZE];
        private Socket clientSocket = null;
        private int timeoutSeconds = 10;
        ///
        /// Default contructor
        ///
        public FtpClient()
        {
        }
        ///
        ///
        ///
        ///
        ///
        ///
        public FtpClient(string server, string username, string password)
        {
            this.server = server;
            if (username.Length > 0)
                this.username = username;
            if (password.Length > 0)
                this.password = password;
        }
        ///
        ///
        ///
        ///
        ///
        ///
        ///
        ///
        public FtpClient(string server, string username, string password, int timeoutSeconds, int port)
        {
            this.server = server;
            this.username = username;
            this.password = password;
            this.timeoutSeconds = timeoutSeconds;
            this.port = port;
        }
        ///
        /// Display all communications to the debug log
        ///
        public bool VerboseDebugging
        {
            get
            {
                return this.verboseDebugging;
            }
            set
            {
                this.verboseDebugging = value;
            }
        }
        ///
        /// Remote server port. Typically TCP 21
        ///
        public int Port
        {
            get
            {
                return this.port;
            }
            set
            {
                this.port = value;
            }
        }
        ///
        /// Timeout waiting for a response from server, in seconds.
        ///
        public int Timeout
        {
            get
            {
                return this.timeoutSeconds;
            }
            set
            {
                this.timeoutSeconds = value;
            }
        }
        ///
        /// Gets and Sets the name of the FTP server.
        ///
        ///
        public string Server
        {
            get
            {
                return this.server;
            }
            set
            {
                this.server = value;
            }
        }
        ///
        /// Gets and Sets the port number.
        ///
        ///
        public int RemotePort
        {
            get
            {
                return this.port;
            }
            set
            {
                this.port = value;
            }
        }
        ///
        /// GetS and Sets the remote directory.
        ///
        public string RemotePath
        {
            get
            {
                return this.remotePath;
            }
            set
            {
                this.remotePath = value;
            }
        }
        ///
        /// Gets and Sets the username.
        ///
        public string Username
        {
            get
            {
                return this.username;
            }
            set
            {
                this.username = value;
            }
        }
        ///
        /// Gets and Set the password.
        ///
        public string Password
        {
            get
            {
                return this.password;
            }
            set
            {
                this.password = value;
            }
        }
        ///
        /// If the value of mode is true, set binary mode for downloads, else, Ascii mode.
        ///
        public bool BinaryMode
        {
            get
            {
                return this.binMode;
            }
            set
            {
                if (this.binMode == value)
                    return;
                if (value)
                    sendCommand("TYPE I");
                else
                    sendCommand("TYPE A");
                if (this.resultCode != 200)
                    throw new FtpException(result.Substring(4));
            }
        }
        ///
        /// Login to the remote server.
        ///
        public void Login()
        {
            if (this.loggedin)
                this.Close();
            Debug.WriteLine("Opening connection to " + this.server, "FtpClient");
            IPAddress addr = null;
            IPEndPoint ep = null;
            try
            {
                this.clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                addr = Dns.GetHostEntry(this.server).AddressList[0];
                ep = new IPEndPoint(addr, this.port);
                this.clientSocket.Connect(ep);
            }
            catch (Exception ex)
            {
                // doubtfull
                if (this.clientSocket != null && this.clientSocket.Connected)
                    this.clientSocket.Close();
                throw new FtpException("Couldn't connect to remote server", ex);
            }
            this.readResponse();
            if (this.resultCode != 220)
            {
                this.Close();
                throw new FtpException(this.result.Substring(4));
            }
            this.sendCommand("USER " + username);
            if (!(this.resultCode == 331 || this.resultCode == 230))
            {
                this.cleanup();
                throw new FtpException(this.result.Substring(4));
            }
            if (this.resultCode != 230)
            {
                this.sendCommand("PASS " + password);
                if (!(this.resultCode == 230 || this.resultCode == 202))
                {
                    this.cleanup();
                    throw new FtpException(this.result.Substring(0, 3));//
                }
            }
            this.loggedin = true;
            Debug.WriteLine("Connected to " + this.server, "FtpClient");
            this.ChangeDir(this.remotePath);
        }
        ///
        /// Close the FTP connection.
        ///
        public void Close()
        {
            Debug.WriteLine("Closing connection to " + this.server, "FtpClient");
            if (this.clientSocket != null)
            {
                this.sendCommand("QUIT");
            }
            this.cleanup();
        }
        ///
        /// Return a string array containing the remote directory's file list.
        ///
        ///
        public string[] GetFileList()
        {
            return this.GetFileList("*.*");
        }
        public bool DirectoryExist(string RomtePathName)
        {
            try
            {
                ChangeDir(RomtePathName);
                return true;
            }
            catch
            {
                MakeDir(RomtePathName);
                ChangeDir(RomtePathName);
                return true;
            }
        }
        private string[] ListDirectories(string[] msg)
        {
            string s = "";
            foreach (string f in msg)
            {
                if (f.Length > 0)
                {
                    if (f.ToUpper().Trim()[0] == 'D' && f.ToUpper().IndexOf("") < 0)
                    {
                        s += f.Trim() + "\n";
                    }
                }
            }
            return s.Replace("\r", "").Split('\n');
        }
        public string[] GetDirectory()
        {
            if (!this.loggedin)
                this.Login();
            Socket cSocket = createDataSocket();
            sendCommand("LIST");
            if (this.resultCode == 226)
                this.readLine();
            if (!(this.resultCode == 150 || this.resultCode == 125))
                throw new FtpException(this.result.Substring(4));
            this.readLine();
            this.message = "";
            DateTime timeout = DateTime.Now.AddSeconds(this.timeoutSeconds);
            while (timeout > DateTime.Now)
            {
                int bytes = cSocket.Receive(buffer, buffer.Length, 0);
                this.message += ASCII.GetString(buffer, 0, bytes);
                if (bytes < this.buffer.Length)
                    break;
            }
            string[] msg = this.message.Replace("\r", "").Split('\n');
            cSocket.Close();
            return ListDirectories(msg);
        }
        /*///
        /// Return a string array containing the remote directory's file list.
        ///
        ///
        ///
        public string[] GetFileList(string mask)
        {
            if ( !this.loggedin ) this.Login();
            Socket cSocket = createDataSocket();
            this.sendCommand("NLST " + mask);
            if(!(this.resultCode == 150 || this.resultCode == 125)) throw new FtpException(this.result.Substring(4));
            this.message = "";
            DateTime timeout = DateTime.Now.AddSeconds(this.timeoutSeconds);
            while( timeout > DateTime.Now )
            {
                int bytes = cSocket.Receive(buffer, buffer.Length, 0);
                this.message += ASCII.GetString(buffer, 0, bytes);
                if ( bytes < this.buffer.Length ) break;
            }
            string[] msg = this.message.Replace("\r","").Split('\n');
            cSocket.Close();
            if ( this.message.IndexOf( "No such file or directory" ) != -1 )
                msg = new string[]{};
            this.readResponse();
            if ( this.resultCode != 226 )
                msg = new string[]{};
            //    throw new FtpException(result.Substring(4));
            return msg;
        }
        */
        ///
        /// Return a string array containing the remote directory's file list.
        ///
        ///
        ///
        public string[] GetFileList(string mask)
        {
            if (!this.loggedin)
                this.Login();
            Socket cSocket = createDataSocket();
            this.sendCommand("List " + mask);
            if (!(this.resultCode == 150 || this.resultCode == 125))
                throw new FtpException(this.result.Substring(4));
            this.message = "";
            DateTime timeout = DateTime.Now.AddSeconds(this.timeoutSeconds);
            while (timeout > DateTime.Now)
            {
                int bytes = cSocket.Receive(buffer, buffer.Length, 0);
                this.message += ASCII.GetString(buffer, 0, bytes);
                if (bytes < this.buffer.Length)
                    break;
            }
            string[] msg = this.message.Replace("\r", "").Split('\n');
            cSocket.Close();
            if (this.message.IndexOf("No such file or directory") != -1 || this.message == "")
            {
                msg = new string[] { };
            }
            //else
            //    this.sendCommand("List ..");

            this.readResponse();
            if (this.resultCode != 226)
                msg = new string[] { };
            //    throw new FtpException(result.Substring(4));

            return ListFiles(msg);
        }
        private string[] ListFiles(string[] msg)
        {
            string s = "";
            foreach (string f in msg)
            {
                if (f.Length > 0)
                {
                    if (f.Trim()[0] != 'd' && f.ToUpper().IndexOf("") < 0)
                    {
                        s += f + "\n";
                    }
                }
            }
            return s.Replace("\r", "").Split('\n');
        }
        ///
        /// Return the size of a file.
        ///
        ///
        ///
        public long GetFileSize(string fileName)
        {
            if (!this.loggedin)
                this.Login();
            this.sendCommand("SIZE " + fileName);
            long size = 0;
            if (this.resultCode == 213)
                size = long.Parse(this.result.Substring(4));
            else
                throw new FtpException(this.result.Substring(4));
            return size;
        }

        ///
        /// Download a file to the Assembly's local directory,
        /// keeping the same file name.
        ///
        ///
        public void Download(string remFileName)
        {
            this.Download(remFileName, "", false);
        }
        ///
        /// Download a remote file to the Assembly's local directory,
        /// keeping the same file name, and set the resume flag.
        ///
        ///
        ///
        public void Download(string remFileName, Boolean resume)
        {
            this.Download(remFileName, "", resume);
        }
        ///
        /// Download a remote file to a local file name which can include
        /// a path. The local file name will be created or overwritten,
        /// but the path must exist.
        ///
        ///
        ///
        public void Download(string remFileName, string locFileName)
        {
            this.Download(remFileName, locFileName, false);
        }
        ///
        /// Download a remote file to a local file name which can include
        /// a path, and set the resume flag. The local file name will be
        /// created or overwritten, but the path must exist.
        ///
        ///
        ///
        ///
        public void Download(string remFileName, string locFileName, Boolean resume)
        {
            if (!this.loggedin)
                this.Login();
            this.BinaryMode = true;
            Debug.WriteLine("Downloading file " + remFileName + " from " + server + "/" + remotePath, "FtpClient");
            if (locFileName.Equals(""))
            {
                locFileName = remFileName;
            }
            FileStream output = null;
            if (!File.Exists(locFileName))
                output = File.Create(locFileName);
            else
                output = new FileStream(locFileName, FileMode.Open);
            Socket cSocket = createDataSocket();
            long offset = 0;
            if (resume)
            {
                offset = output.Length;
                if (offset > 0)
                {
                    this.sendCommand("REST " + offset);
                    if (this.resultCode != 350)
                    {
                        //Server dosnt support resuming
                        offset = 0;
                        Debug.WriteLine("Resuming not supported:" + result.Substring(4), "FtpClient");
                    }
                    else
                    {
                        Debug.WriteLine("Resuming at offset " + offset, "FtpClient");
                        output.Seek(offset, SeekOrigin.Begin);
                    }
                }
            }
            this.sendCommand("RETR " + remFileName);
            if (this.resultCode != 150 && this.resultCode != 125)
            {
                throw new FtpException(this.result.Substring(4));
            }
            DateTime timeout = DateTime.Now.AddSeconds(this.timeoutSeconds);
            while (timeout > DateTime.Now)
            {
                this.bytes = cSocket.Receive(buffer, buffer.Length, 0);
                output.Write(this.buffer, 0, this.bytes);
                if (this.bytes  0)
            {
                this.sendCommand("REST " + offset);
                if (this.resultCode != 350)
                {
                    Debug.WriteLine("Resuming not supported", "FtpClient");
                    offset = 0;
                }
            }
            this.sendCommand("STOR " + Path.GetFileName(fileName));
            if (this.resultCode != 125 && this.resultCode != 150)
                throw new FtpException(result.Substring(4));
            if (offset != 0)
            {
                Debug.WriteLine("Resuming at offset " + offset, "FtpClient");
                input.Seek(offset, SeekOrigin.Begin);
            }
            Debug.WriteLine("Uploading file " + fileName + " to " + remotePath, "FtpClient");
            while ((bytes = input.Read(buffer, 0, buffer.Length)) > 0)
            {
                cSocket.Send(buffer, bytes, 0);
            }
            input.Close();
            if (cSocket.Connected)
            {
                cSocket.Close();
            }
            this.readResponse();
            if (this.resultCode != 226 && this.resultCode != 250)
                throw new FtpException(this.result.Substring(4));
        }
        ///
        /// Upload a directory and its file contents
        ///
        ///
        /// Whether to recurse sub directories
        public void UploadDirectory(string path, bool recurse, string despath)
        {
            this.UploadDirectory(path, recurse, "*.*", despath);
        }
        ///
        /// Upload a directory and its file contents
        ///
        ///
        /// Whether to recurse sub directories
        /// Only upload files of the given mask - everything is '*.*'
        public void UploadDirectory(string path, bool recurse, string mask, string despath)
        {
            if (despath != string.Empty)
            {
                string[] dp = despath.Replace("/", @"\").Split('\\');
                foreach (string s in dp)
                {
                    if (s != "")
                    {
                        this.MakeDir(s);
                        this.ChangeDir(s);
                    }
                }
            }
            string[] dirs = path.Replace("/", @"\").Split('\\');
            string rootDir = dirs[dirs.Length - 1];
            // make the root dir if it doed not exist
            //if ( this.GetFileList(rootDir).Length < 1 )
            this.MakeDir(rootDir);
            //this.MakeDir(despath);
            this.ChangeDir(rootDir);
            foreach (string file in Directory.GetFiles(path, mask))
            {
                //this.Upload(file, true);
                this.Upload(file, false);
            }
            if (recurse)
            {
                foreach (string directory in Directory.GetDirectories(path))
                {
                    this.UploadDirectory(directory, recurse, mask, "");
                }
            }
            this.ChangeDir("..");
        }
        ///
        /// Delete a file from the remote FTP server.
        ///
        ///
        public void DeleteFile(string fileName)
        {
            if (!this.loggedin)
                this.Login();
            this.sendCommand("DELE " + fileName);
            if (this.resultCode != 250)
                throw new FtpException(this.result.Substring(4));
            Debug.WriteLine("Deleted file " + fileName, "FtpClient");
        }
        ///
        /// Rename a file on the remote FTP server.
        ///
        ///
        ///
        /// setting to false will throw exception if it exists
        public void RenameFile(string oldFileName, string newFileName, bool overwrite)
        {
            if (!this.loggedin)
                this.Login();
            this.sendCommand("RNFR " + oldFileName);
            if (this.resultCode != 350)
                throw new FtpException(this.result.Substring(4));
            if (!overwrite && this.GetFileList(newFileName).Length > 0)
                throw new FtpException("File already exists");
            this.sendCommand("RNTO " + newFileName);
            if (this.resultCode != 250)
                throw new FtpException(this.result.Substring(4));
            Debug.WriteLine("Renamed file " + oldFileName + " to " + newFileName, "FtpClient");
        }
        ///
        /// Create a directory on the remote FTP server.
        ///
        ///
        public void MakeDir(string dirName)
        {
            if (!this.loggedin)
                this.Login();
            this.sendCommand("MKD " + dirName);
            string err = result;
            if (result.IndexOf("Failed to create") > 0)
            {
                //文件已经存在
            }
            if (result.IndexOf("Permission denied") > 0)
            {
                //没有权限
            }
            //if ( this.resultCode != 250 && this.resultCode != 257 ) throw new FtpException(this.result.Substring(4));
            //Debug.WriteLine( "Created directory " + dirName, "FtpClient" );
        }
        ///
        /// Delete a directory on the remote FTP server.
        ///
        ///
        public void RemoveDir(string dirName)
        {
            if (!this.loggedin)
                this.Login();
            this.sendCommand("RMD " + dirName);
            if (this.resultCode != 250)
                throw new FtpException(this.result.Substring(4));
            Debug.WriteLine("Removed directory " + dirName, "FtpClient");
        }
        ///
        /// Change the current working directory on the remote FTP server.
        ///
        ///
        public void ChangeDir(string dirName)
        {
            if (dirName == null || dirName.Equals(".") || dirName.Length == 0)
            {
                return;
            }
            if (!this.loggedin)
                this.Login();
            this.sendCommand("CWD " + dirName);
            //Thread.Sleep(7000);
            if (this.resultCode == 226)
                this.readResponse();
            if (this.resultCode != 250)
                throw new FtpException(result.Substring(4));
            this.sendCommand("PWD");
            if (this.resultCode != 257)
                throw new FtpException(result.Substring(4));
            // gonna have to do better than this .
            this.remotePath = this.message.Split('"')[1];
            Debug.WriteLine("Current directory is " + this.remotePath, "FtpClient");
        }
        ///
        ///
        ///
        private void readResponse()
        {
            this.message = "";
            this.result = this.readLine();
            //string rs = this.readLine();
            //if (rs != string.Empty && rs.Length > 0)
            //    result = rs;
            if (this.result.Length > 3)
                this.resultCode = int.Parse(this.result.Substring(0, 3));
            else
                this.result = null;
        }
        ///
        ///
        ///
        ///
        private string readLine()
        {
            while (true)
            {
                this.bytes = clientSocket.Receive(this.buffer, this.buffer.Length, 0);
                this.message += ASCII.GetString(this.buffer, 0, this.bytes);
                if (this.bytes < this.buffer.Length)
                {
                    break;
                }
            }
            string[] msg = this.message.Split('\n');
            if (this.message.Length > 2)
                this.message = msg[msg.Length - 2];
            else
                this.message = msg[0];

            if (this.message.Length > 4 && !this.message.Substring(3, 1).Equals(" "))
                return this.readLine();
            if (this.verboseDebugging)
            {
                for (int i = 0; i < msg.Length - 1; i++)
                {
                    Debug.Write(msg, "FtpClient");
                }
            }
            return message;
        }
        ///
        ///
        ///
        ///
        private void sendCommand(String command)
        {
            if (this.verboseDebugging)
                Debug.WriteLine(command, "FtpClient");
            Byte[] cmdBytes = Encoding.Default.GetBytes((command + "\r\n").ToCharArray());
            clientSocket.Send(cmdBytes, cmdBytes.Length, 0);
            this.readResponse();
        }
        ///
        /// when doing data transfers, we need to open another socket for it.
        ///
        /// Connected socket
        private Socket createDataSocket()
        {
            this.sendCommand("PASV");
            if (this.resultCode == 226)
                this.readLine();
            if (this.resultCode != 227)
                throw new FtpException(this.result.Substring(4));
            int index1 = this.result.IndexOf('(');
            int index2 = this.result.IndexOf(')');
            string ipData = this.result.Substring(index1 + 1, index2 - index1 - 1);
            int[] parts = new int[6];
            int len = ipData.Length;
            int partCount = 0;
            string buf = "";
            for (int i = 0; i < len && partCount