Exemplo n.º 1
16
        private static void backup(FTPClient ftp, DirectoryInfo dir, Regex regex, RegistryKey key)
        {
            string[] files = ftp.Dir(null, true);
                string[] names = new string[files.Length];
                int i = 0;
                foreach (string file in files)
                {
                    names[i] = file.Substring(56);
                    if (file.Substring(0,1) == "d")
                    {
                        // A directory!
                        if (dir.GetDirectories(names[i]).Length != 1 && !names[i].Substring(0,1).Equals("."))
                            RecRm(ftp, names[i]);
                    }
                    else
                        // A file!
                        if (regex.IsMatch(names[i]) && dir.GetFiles(names[i]).Length != 1)
                            ftp.Delete(names[i]);
                    i++;
                }

                foreach (DirectoryInfo subdir in dir.GetDirectories())
                {
                    if (!stringSearch(names, subdir.Name))
                        ftp.MkDir(subdir.Name);

                    ftp.ChDir(subdir.Name);
                    backup(ftp, subdir, regex, getDataKey(ref key, subdir.Name));
                    ftp.ChDir("..");
                }

                foreach (FileInfo file in dir.GetFiles())
                {
                    if (!regex.IsMatch(file.Name))
                        continue;

                    if (file.LastWriteTime > getDateTime(key.GetValue(file.Name, "0001-01-01 00:00:00").ToString()))
                    {
                        ftp.Put(file.FullName, file.Name, false);
                        key.SetValue(file.Name, DateTime.Now.ToString());
                    }
                }
        }
Exemplo n.º 2
1
        public bool Put(Photo ph)
        {
            //функция отправки одной фотки (какой - в аргументах вызова) на сервер
            //lock (lock_)
            bool f = true;
            if(ph!=null)
            if (ph.name.Length>=32)
            try
            {
                ph.name = ph.name.Substring(32);
                string filepath = "photos" + "/" + ph.name.ToString().Substring(0, 1) + "/" +
                                                  ph.name.ToString().Substring(1, 1) + "/";
                //File.WriteAllBytes("photos" + "/" + ph.name, ph.photo);
                        //Console.WriteLine("Ищем путь " + "photos" + "/" + sb.ToString().Substring(0, 1) + "/" +sb.ToString().Substring(1, 1) + "/");
                if (Directory.Exists(filepath))
                {
                    try
                    {
                        //Console.WriteLine("Отправляем через sshfs");
                        if (!File.Exists(filepath + ph.name))
                            File.WriteAllBytes(filepath + ph.name, ph.photo);
                        /*else
                            Console.WriteLine("не отсылаем фото, т.к. оно уже на сервере");*/
                    }
                    catch (Exception exx)
                    {
                        string s = exx.Message;
                        if (!s.Contains("553"))
                            ddbs.WriteErrorMessage(ddbs.ConnectionString, 0, ph.name, "Ошибка отправки фоток-2: " + s);
                        Console.WriteLine("Ошибка отправки фоток-2: " + s);
                    }

                }
                else
                {
                    FTPClient conn = new FTPClient("srv5.r-slon.com");
                    if (conn != null)
                    {
                        try
                        {   
                            conn.Login("gsmcity", "fZZ9PQ1DnN");
                            conn.TransferType = FTPTransferType.BINARY;
                            conn.CloseStreamsAfterTransfer = true;
                            if (!conn.IsConnected)
                                conn.Connect();
                            filepath = filepath.Replace("photos/", "");
                            if(!conn.Exists(filepath + ph.name))
                                conn.Put(ph.photo, filepath + ph.name);
                            /*else
                                Console.WriteLine("не отсылаем фото, т.к. оно уже на сервере");*/
                        }
                        catch(Exception exx)
                        {
                            string s = exx.Message;
                            if(!s.Contains("553"))
                                ddbs.WriteErrorMessage(ddbs.ConnectionString, 0, ph.name, "Ошибка отправки фоток-0-1: " + s);
                            Console.WriteLine("Ошибка отправки фоток-0-1: " + s);
                        }
                        finally
                        {
                            conn.Quit();
                            GC.SuppressFinalize(conn);
                        }
                    }
                    else
                        ddbs.WriteErrorMessage(ddbs.ConnectionString, 0, ph.name, "Ошибка отправки фоток-0: не создалось ftp-подключение");

                }
            }
            catch (Exception ex)
            {
                string s = ex.Message;
                if (!(s.Contains("553") || s.Contains("530")))
                    f = false;
                ddbs.WriteErrorMessage(ddbs.ConnectionString, 0, ph.name, "Ошибка отправки фоток-1: " + s);
                //return false;
            }
            return f;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Attempts to connect to the remote location.
        /// </summary>
        public void Connect()
        {
            // Init FTP client
            _ftp = new FTPClient(_settings.Address, _settings.Port);
            _ftp.CommandSent += new FTPMessageHandler(Ftp_CommandSent);
            _ftp.ReplyReceived += new FTPMessageHandler(Ftp_ReplyReceived);
            _ftp.BytesTransferred += new BytesTransferredHandler(Ftp_BytesTransferred);
            _ftp.Login(_settings.Login, _settings.Password);
            _ftp.TransferType = FTPTransferType.BINARY;

            // Setup root deploy path
            string rootpath = _ftp.Pwd();
            _remoteRootPath = Path.Combine(rootpath, _settings.Path.TrimStart('\\', '/'));

            _currentRemotePath = null;
        }
Exemplo n.º 4
0
 /// <summary>
 /// Loads data from the server into the text box.
 /// </summary>
 private void LoadData()
 {
     try
     {
         FTPClient client = new FTPClient();
         client.RemoteHost = this.textBoxHost.Text;
         client.Connect();
         client.Login(this.textBoxUser.Text, this.maskedTextBoxPass.Text);
         this.textBoxStudents.Text = Encoding.UTF8.GetString(client.Get(this.textBoxPath.Text));
         this.textBoxStudents.Enabled = true;
         client.Quit();
     }
     catch (Exception ex)
     {
         this.textBoxStudents.Enabled = false;
         MessageBox.Show(ex.ToString());
     }
 }
Exemplo n.º 5
0
 private static void RecRm(FTPClient ftp, string name)
 {
     ftp.ChDir(name);
     string[] list;
     if ((list = ftp.Dir(null, true)).Length > 0)
     {
         foreach (string thing in list)
         {
             string thingname = thing.Substring(56);
             if (thing.Substring(0,1) == "d")
                 RecRm(ftp, thingname);
             else
                 ftp.Delete(thingname);
         }
     }
     ftp.ChDir("..");
     ftp.RmDir(name);
 }
Exemplo n.º 6
0
        /// <summary>   
        /// Test harness
        /// </summary>
        public static void Main(string[] args)
        {
            // we want remote host, user name and password
            if (args.Length < 7)
            {
                log.Debug(Convert.ToString(args.Length));
                Usage();
                System.Environment.Exit(1);
            }
            try
            {
                // assign args to make it clear
                string host = args[0];
                string user = args[1];
                string password = args[2];
                string filename = args[3];
                string directory = args[4];
                string mode = args[5];
                string connMode = args[6];

                FTPClient ftp = new FTPClient();
                ftp.RemoteHost = host;
                ftp.ControlPort = 21;

                // set up message collector
                ftp.CommandSent += new FTPMessageHandler(FTPClientTest.LogCommand);
                ftp.ReplyReceived += new FTPMessageHandler(FTPClientTest.LogReply);
                ftp.TransferStarted += new EventHandler(FTPClientTest.LogTransferStarted);
                ftp.TransferComplete += new EventHandler(FTPClientTest.LogTransferComplete);

                // connect
                ftp.Connect();
                ftp.Login(user, password);
                ftp.Quit();

                // connect again
                ftp = new FTPClient(host);
                ftp.CommandSent += new FTPMessageHandler(FTPClientTest.LogCommand);
                ftp.ReplyReceived += new FTPMessageHandler(FTPClientTest.LogReply);
                ftp.TransferStarted += new EventHandler(FTPClientTest.LogTransferStarted);
                ftp.TransferComplete += new EventHandler(FTPClientTest.LogTransferComplete);
                ftp.BytesTransferred += new BytesTransferredHandler(FTPClientTest.BytesTransferred);

                ftp.Login(user, password);

                // binary transfer
                if (mode.ToUpper().Equals("BINARY".ToUpper()))
                {
                    ftp.TransferType = FTPTransferType.BINARY;
                }
                else if (mode.ToUpper().Equals("ASCII".ToUpper()))
                {
                    ftp.TransferType = FTPTransferType.ASCII;
                }
                else
                {
                    log.Debug("Unknown transfer type: " + args[5]);
                    System.Environment.Exit(- 1);
                }

                // PASV or active?
                if (connMode.ToUpper().Equals("PASV".ToUpper()))
                {
                    ftp.ConnectMode = FTPConnectMode.PASV;
                }
                else if (connMode.ToUpper().Equals("ACTIVE".ToUpper()))
                {
                    ftp.ConnectMode = FTPConnectMode.ACTIVE;
                }
                else
                {
                    log.Debug("Unknown connect mode: " + args[6]);
                    System.Environment.Exit(- 1);
                }

                // change dir
                ftp.ChDir(directory);

                // Put a local file to remote host
                ftp.Put(filename, filename);

                // get bytes
                byte[] buf1 = ftp.Get(filename);
                log.Debug("Got " + buf1.Length + " bytes");

                // append local file
                try
                {
                    ftp.Put(filename, filename, true);
                }
                catch (FTPException ex)
                {
                    log.Debug("Append failed: " + ex.Message);
                }

                // get bytes again - should be 2 x
                //byte[] buf2 = ftp.Get(filename);
                //log.Debug("Got " + buf2.Length + " bytes");

                // rename
                ftp.Rename(filename, filename + ".new");

                // get a remote file - the renamed one
                ftp.Get(filename + ".tst", filename + ".new");

                // delete the remote file
                ftp.Delete(filename + ".new");

                // ASCII transfer
                ftp.TransferType = FTPTransferType.ASCII;

                // test that dir() works in full mode
                string[] listings = ftp.Dir(".", true);
                for (int i = 0; i < listings.Length; i++)
                    log.Debug(listings[i]);

                // and now DirDetails test
                FTPFile[] files = ftp.DirDetails(".");
                log.Debug(files.Length + " files");
                for (int i = 0; i < files.Length; i++) {
                    log.Debug(files[i].ToString());
                }

                // try system()
                log.Debug(ftp.GetSystem());

                // try pwd()
                log.Debug(ftp.Pwd());

                ftp.Quit();

                log.Debug("******** message log ********");
                log.Debug(FTPClientTest.messages.ToString());
            }
            catch (SystemException ex)
            {
                log.Debug("Caught exception: " + ex.Message);
            }
            catch (FTPException ex)
            {
                log.Debug("Caught exception: " + ex.Message);
            }
        }
Exemplo n.º 7
0
 /// <summary>
 /// Disconnects from the remote location.
 /// </summary>
 public void Disconnect()
 {
     _ftp.Quit();
     _ftp = null;
 }
Exemplo n.º 8
0
 /// <summary>
 /// Checks if we have a idle connection to the remote ftp server
 /// </summary>
 /// <param name="hostname">hostname or ipadres of the ftp server</param>
 /// <param name="login">loginname</param>
 /// <param name="password">password</param>
 /// <param name="port">tcp/ip port</param>
 /// <param name="ftpclient">on return contains the idle ftp connection for this server
 /// or null if none is found</param>
 /// <returns>
 /// true: found an idle connection, this is returned in ftpclient
 /// false: no idle connections found. ftpclient =null
 /// </returns>
 public static bool InCache(string hostname, string login, string password, int port, bool active,
                            out FTPClient ftpclient)
 {
   ftpclient = null;
   foreach (FtpConnection client in ftpConnections)
   {
     if (client.HostName == hostname &&
         client.LoginName == login &&
         client.Password == password && client.Port == port)
     {
       if (!client.Busy)
       {
         ftpclient = client.Connection;
         return true;
       }
     }
   }
   return false;
 }
Exemplo n.º 9
0
        /// <summary>Close a connection to a server</summary>
        public void Close()
        {
            if (IsConnected) {
                //throw new FTPTaskException("Connection is already closed");
                _task.Log(Level.Info, "Disconnecting from '{0}'", Server);
                _client.Quit();
                _client = null;
                _task = null;

            }

            return;
        }
Exemplo n.º 10
0
        /// <summary>
        /// Loads the student names from the remote server into the program.
        /// </summary>
        private void LoadNames()
        {
            try
            {
                FTPClient client = new FTPClient();
                client.RemoteHost = Settings.Default.DefaultFtpHost;
                client.Connect();
                client.Login(Settings.Default.DefaultFtpUserName, Settings.Default.DefaultFtpPassword);

                this.names.Clear();
                this.names.AddRange(Encoding.UTF8.GetString(client.Get(Settings.Default.DefaultFtpPath)).Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries));
            }
            catch (Exception e)
            {
                new ThreadExceptionDialog(e).ShowDialog();
            }
        }
Exemplo n.º 11
0
 protected internal FTPConnection(FTPClient ftpClient)
 {
     this.components = null;
     this.log = Logger.GetLogger("FTPConnection");
     this.clientLock = new object();
     this.useAutoLogin = true;
     this.areEventsEnabled = true;
     this.isTransferringData = false;
     this.guiControl = null;
     this.haveQueriedForControl = false;
     this.currentFileSize = -1L;
     this.useGuiThread = true;
     this.localDir = null;
     this.remoteDir = null;
     this.lastTransferCancel = false;
     lock (instanceCountMutex)
     {
         this.instanceNumber = instanceCount++;
     }
     this.ftpClient = ftpClient;
     this.activeClient = ftpClient;
     this.ftpClient.AutoPassiveIPSubstitution = true;
     this.ftpClient.BytesTransferred += new BytesTransferredHandler(this.ftpClient_BytesTransferred);
     this.fileTransferType = FTPTransferType.BINARY;
     ftpClient.CommandSent += new FTPMessageHandler(this.ftpClient_CommandSent);
     ftpClient.ReplyReceived += new FTPMessageHandler(this.ftpClient_ReplyReceived);
     ftpClient.ActivePortRange.PropertyChangeHandler = new PropertyChangedEventHandler(this.OnActivePortRangeChanged);
     ftpClient.FileNotFoundMessages.PropertyChangeHandler = new PropertyChangedEventHandler(this.OnFileNotFoundMessagesChanged);
     ftpClient.TransferCompleteMessages.PropertyChangeHandler = new PropertyChangedEventHandler(this.OnFileNotFoundMessagesChanged);
     ftpClient.DirectoryEmptyMessages.PropertyChangeHandler = new PropertyChangedEventHandler(this.OnDirectoryEmptyMessagesChanged);
 }
Exemplo n.º 12
0
        public void Ftp(List<string> zipFiles)
        {
            IEnumerable<XElement> ftps = gConfig.GetElements("Backup/Ftp");
            foreach (XElement xeFtp in ftps)
            {
                if (gAbortTask) break;
                string ftpServer = xeFtp.zAttribValue("server");
                if (ftpServer == null)
                {
                    //cTrace.Trace("Ftp          : server is'nt defined");
                    gTaskTrace.WriteLine("Ftp          : server is'nt defined");
                    continue;
                }
                string ftpUser = xeFtp.zAttribValue("user");
                if (ftpUser == null)
                {
                    //cTrace.Trace("Ftp          : user is'nt defined");
                    gTaskTrace.WriteLine("Ftp          : user is'nt defined");
                    continue;
                }
                string ftpPassword = xeFtp.zAttribValue("password");
                string ftpDirectory = xeFtp.zAttribValue("directory");

                string dir = "";
                if (ftpDirectory != null) dir = " directory " + ftpDirectory;
                gTaskTrace.WriteLine("Ftp          : connect to server {0}{1}", ftpServer, dir);

                FTPClient ftp = new FTPClient();
                try
                {
                    ftp.RemoteHost = ftpServer;
                    ftp.Connect();
                    ftp.Login(ftpUser, ftpPassword);
                    if (ftpDirectory != null) ftp.ChDir(ftpDirectory);
                    ftp.TransferType = FTPTransferType.BINARY;
                    ftp.BytesTransferred += new BytesTransferredHandler(FtpBytesTransferred);


                    int iFile = 0;
                    foreach (string zipFile in zipFiles)
                    {
                        if (gAbortTask) break;
                        gTaskProgress.SetProgressText("Ftp copy file " + zipFile);
                        gTaskProgress.SetProgress(++iFile, zipFiles.Count);
                        gTaskTrace.WriteLine("Ftp          : copy file {0}", zipFile);

                        if (!zFile.Exists(zipFile))
                        {
                            //cTrace.Trace("Ftp          : file does'nt exist {0}", zipFile);
                            gTaskTrace.WriteLine("Ftp          : file does'nt exist {0}", zipFile);
                            continue;
                        }
                        string remoteFile = zPath.GetFileName(zipFile);
                        //glFtpByteToTransfer = new FileInfo(zipFile).Length;
                        glFtpByteToTransfer = zFile.CreateFileInfo(zipFile).Length;
                        gTaskProgressDetail.SetProgressText("FTP transfer file {0}", remoteFile);

                        try
                        {
                            ftp.Put(zipFile, remoteFile);
                        }
                        catch
                        {
                            if (!gbErrorGeneratedByFtpStop) throw;
                            //string sError = cError.GetErrorMessage(ex, false, true);
                            //gTrace.Trace(sError);
                            break;
                        }

                        gTaskProgressDetail.SetProgress(glFtpByteToTransfer, glFtpByteToTransfer);
                    }

                    ftp.BytesTransferred -= new BytesTransferredHandler(FtpBytesTransferred);
                }
                finally
                {
                    if (!gbErrorGeneratedByFtpStop)
                        ftp.Quit();
                    else
                        gbErrorGeneratedByFtpStop = false;
                }
            }
        }
Exemplo n.º 13
0
    /// <summary>
    /// Start downloading a file from a remote server to local harddisk
    /// orgremoteFile is in format remote:hostname?port?login?password?folder
    /// while the remotefile only contains the remote path+filename
    /// </summary>
    /// <param name="ftpclient">FTP client to use</param>
    /// <param name="orgremoteFile">remote file including all details</param>
    /// <param name="remotefile">remote file including only path+filename</param>
    /// <param name="localfile">filename where download should be stored</param>
    /// <returns>
    /// true: download is started
    /// false: unable to download file
    /// </returns>
    public static bool Download(FTPClient ftpclient, string orgremoteFile, string remotefile, string localfile)
    {
      foreach (FtpConnection client in ftpConnections)
      {
        if (client.Connection == ftpclient)
        {
          if (!client.Busy)
          {
            client.Busy = true;
            client.Download(orgremoteFile, remotefile, localfile);

            return true;
          }
        }
      }
      return false;
    }
Exemplo n.º 14
0
 /// <summary>
 /// Remove an ftp client from the cache
 /// this can be used to remove ftp clients which are disconnected
 /// </summary>
 /// <param name="ftpclient">FTPClient</param>
 public static void Remove(FTPClient ftpclient)
 {
   foreach (FtpConnection client in ftpConnections)
   {
     if (client.Connection == ftpclient)
     {
       ftpConnections.Remove(client);
       return;
     }
   }
 }
Exemplo n.º 15
0
        private static void sync(object sender, EventArgs e)
        {
            RegistryKey key = getDataKey();
            FTPClient ftp = null;

            DirectoryInfo dir = new DirectoryInfo(props.Folder);
            Regex regex = new Regex(props.Regex);

            try
            {
                systray.Text = "bakkappah - connecting...";
                ftp = new FTPClient(props.Server, props.Port, 30000);
                ftp.Login(props.User, props.Password);
                ftp.ConnectMode = FTPConnectMode.ACTIVE;
                ftp.TransferType = FTPTransferType.BINARY;
                systray.Text = "bakkappah - uploading...";
                backup(ftp, dir, regex, key);
            }
            catch
            {
                return;
            }
            finally
            {
                try { ftp.Quit(); }
                catch {}
                systray.Text = "bakkappah";
            }
        }
Exemplo n.º 16
0
        /// <summary>
        /// Saves data from the text box onto the server.
        /// </summary>
        private void SaveData()
        {
            try
            {
                FTPClient client = new FTPClient();
                client.RemoteHost = this.textBoxHost.Text;
                client.Connect();
                client.Login(this.textBoxUser.Text, this.maskedTextBoxPass.Text);
                client.Put(Encoding.UTF8.GetBytes(this.textBoxStudents.Text), this.textBoxPath.Text);
                client.Quit();

                this.DialogResult = DialogResult.OK;
                this.Close();
            }
            catch (Exception ex)
            {
                this.textBoxStudents.Enabled = false;
                if (MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OKCancel) == DialogResult.OK)
                {
                    this.Close();
                }
            }
        }
Exemplo n.º 17
0
        /// <summary>
        /// Create an FTPConnection using the given FTP client.
        /// </summary>
        /// <param name="ftpClient"><see cref="FTPClient"/>-instance to use.</param>
        protected internal FTPConnection(FTPClient ftpClient)
        {
            log.Info(VersionDetails.GetVersionDetails(this.GetType()));
            log.Info("Built: " + BuildTimestamp);
            lock (instanceCountMutex)
            {
                this.instanceNumber = instanceCount++;
            }
            this.ftpClient = ftpClient;
            this.activeClient = ftpClient;
            this.ftpClient.AutoPassiveIPSubstitution = true;
            this.ftpClient.BytesTransferred += new BytesTransferredHandler(ftpClient_BytesTransferred);
            fileTransferType = FTPTransferType.BINARY;

            ftpClient.CommandSent += new FTPMessageHandler(ftpClient_CommandSent);
            ftpClient.ReplyReceived += new FTPMessageHandler(ftpClient_ReplyReceived);
            ftpClient.CommandError += new FTPErrorEventHandler(ftpClient_CommandError);

            ftpClient.ActivePortRange.PropertyChangeHandler = new PropertyChangedEventHandler(OnActivePortRangeChanged);
            ftpClient.FileNotFoundMessages.PropertyChangeHandler = new PropertyChangedEventHandler(OnFileNotFoundMessagesChanged);
            ftpClient.TransferCompleteMessages.PropertyChangeHandler = new PropertyChangedEventHandler(OnFileNotFoundMessagesChanged);
            ftpClient.DirectoryEmptyMessages.PropertyChangeHandler = new PropertyChangedEventHandler(OnDirectoryEmptyMessagesChanged);
        }
Exemplo n.º 18
0
        /// <summary>Open a connection to the specified server.</summary>
        /// <param name="task">The task using this connection</param>
        public void Open(FTPTask task)
        {
            if (_task!=null) {
                throw new FTPTaskException("This connection is already being used by "+_task.ToString());
            }

            if (task==null) {
                throw new FTPTaskException("Must specify the task that will use this connection.");
            }

            _task = task;

            if (IsConnected) {
                throw new FTPTaskException("This connection is already open.");
            }

            _task.Log(Level.Info, "Using '{0}':", ID);

            // ensure this connection object has all the info it needs
            Validate();

            if (!_task.Exec) {
                _task.Log(Level.Info, "-------------- Debugging the ftp queries --------------");
                _task.Log(Level.Info, "Connection will be attempted to scan remotely for <get> sets");
                _task.Log(Level.Info, "but no transfers will be attempted in either direction");
                _task.Log(Level.Info, "and neither local nor remote file trees will be modified.");
                _task.Log(Level.Info, "-------------------------------------------------------\n");
            }

            _task.Log(Level.Info, "Connecting to '{0}' as '{1}' . . .", Server, UserName);

            _task.Log(Level.Verbose, "Instantiating the FTPClient & opening the connection...");
            _client = new FTPClient(Server);

            _task.Log(Level.Verbose, "Authenticating...");

            Login(UserName, Password);

            _task.Log(Level.Verbose, "and setting the connection mode to passive.");
            _client.ConnectMode = ParseConnectMode(ParseConnectMode(_task.ConnectMode));

            return;
        }
Exemplo n.º 19
0
        private void _test_Click(object sender, EventArgs e)
        {
            try {
                this.Cursor = Cursors.WaitCursor;
                FTPClient ftp = new FTPClient(_address.Text, int.Parse(_port.Text));
                ftp.Login(_login.Text, _password.Text);
                ftp.Quit();

                MessageBox.Show("The connection was successfully established.", "Connection successful", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex) {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            this.Cursor = Cursors.Default;
        }