예제 #1
0
        public static DateTime StringToFtpDate(String value)
        {
            //String[] lParts = Regex.Split(value, @"\w+");
            String[] lParts = ParseLine(value, 3);

            return(FtpListingItem.StringToFtpDate(lParts[0], lParts[1], lParts[2]));
        }
예제 #2
0
        public void Parse(String list, Boolean includeUpDir)
        {
            this.Clear();

            Boolean lFoundUpDir = false;

            //String[] lItems = Regex.Split(list, @"(?:\r\n|\r|\n)");
            String[] lItems = SplitLines(list);

            for (Int32 i = 0; i < lItems.Length; i++)
            {
                String lItem = lItems[i].Trim();

                if (String.IsNullOrEmpty(lItem))
                {
                    continue;
                }

                if (lItem.ToLower().StartsWith("total"))
                {
                    continue;
                }

                try
                {
                    FtpListingItem lNewItem = new FtpListingItem();
                    lNewItem.Parse(lItem);

                    this.Add(lNewItem);

                    if (lNewItem.Directory && lNewItem.FileName == "..")
                    {
                        lFoundUpDir = true;
                    }
                }
                catch (Exception ex)
                {
                    if (!(ex is FormatException))
                    {
                        if (defined("ECHOES") && (!(ex is IndexOutOfRangeException)))
                        {
                            throw ex;
                        }
                        else if (!defined("ECHOES") && (!(ex is RTLException)))
                        {
                            throw ex;
                        }
                    }
                }
            }

            if (includeUpDir && !lFoundUpDir)
            {
                FtpListingItem lUpItem = new FtpListingItem();
                lUpItem.Directory = true;
                lUpItem.FileName  = "..";
                this.Insert(0, lUpItem);
            }
        }
예제 #3
0
        public FtpListingItem Add()
        {
            FtpListingItem lResult = new FtpListingItem();

            this.Add(lResult);

            return(lResult);
        }
예제 #4
0
        public override String ToString()
        {
            Char[] lRights = new Char[] { 'd', 'r', 'w', 'x', 'r', 'w', 'x', 'r', 'w', 'x' };

            if (!this.Directory)
            {
                lRights[0] = '-';
            }

            if (!this.UserRead)
            {
                lRights[1] = '-';
            }

            if (!this.UserWrite)
            {
                lRights[2] = '-';
            }

            if (!this.UserExec)
            {
                lRights[3] = '-';
            }

            if (!this.GroupRead)
            {
                lRights[4] = '-';
            }

            if (!this.GroupWrite)
            {
                lRights[5] = '-';
            }

            if (!this.GroupExec)
            {
                lRights[6] = '-';
            }

            if (!this.OtherRead)
            {
                lRights[7] = '-';
            }

            if (!this.OtherWrite)
            {
                lRights[8] = '-';
            }

            if (!this.OtherExec)
            {
                lRights[9] = '-';
            }

            return(String.Format("{0} {1,3} {2,8} {3,8} {4,7} {5} {6}", new String(lRights), this.SubItemCount, this.User,
                                 this.Group, this.Size, FtpListingItem.FtpDateToString(this.FileDate), this.FileName));
        }
예제 #5
0
        protected void AddListingItems(FtpListing listing, IEnumerable ftpItems)
        {
            if (ftpItems == null)
            {
                return;
            }

            foreach (IFtpItem item in ftpItems)
            {
                FtpListingItem lListingItem = listing.Add();
                item.FillFtpListingItem(lListingItem);
            }
        }
예제 #6
0
        public override void DoListFolderItems(FtpListing listing)
        {
            String[] lNames = Directory.GetDirectories(LocalPath);

            foreach (String name in lNames)
            {
                FtpListingItem lListingItem = listing.Add();
                lListingItem.Directory  = true;
                lListingItem.FileName   = Path.GetFileName(name);
                lListingItem.FileDate   = Directory.GetLastWriteTime(Path.Combine(LocalPath, name));
                lListingItem.Size       = 0;
                lListingItem.User       = "******";
                lListingItem.Group      = "system";
                lListingItem.UserRead   = UserRead;
                lListingItem.UserWrite  = UserWrite;
                lListingItem.UserExec   = UserRead;
                lListingItem.GroupRead  = GroupRead;
                lListingItem.GroupWrite = GroupWrite;
                lListingItem.GroupExec  = GroupRead;
                lListingItem.OtherRead  = WorldRead;
                lListingItem.OtherWrite = WorldWrite;
                lListingItem.OtherExec  = WorldRead;
            }

            DirectoryInfo lDirectory = new DirectoryInfo(LocalPath);

            FileInfo[] lFiles = lDirectory.GetFiles();
            foreach (FileInfo file in lFiles)
            {
                FtpListingItem lListingItem = listing.Add();
                lListingItem.Directory  = false;
                lListingItem.FileName   = file.Name;
                lListingItem.FileDate   = file.LastWriteTime;
                lListingItem.Size       = file.Length;
                lListingItem.User       = "******";
                lListingItem.Group      = "system";
                lListingItem.UserRead   = UserRead;
                lListingItem.UserWrite  = UserWrite;
                lListingItem.UserExec   = false;
                lListingItem.GroupRead  = GroupRead;
                lListingItem.GroupWrite = GroupWrite;
                lListingItem.GroupExec  = false;
                lListingItem.OtherRead  = WorldRead;
                lListingItem.OtherWrite = WorldWrite;
                lListingItem.OtherExec  = false;
            }

            AddListingItems(listing, SubFolders);
            AddListingItems(listing, Files);
        }
예제 #7
0
  
    private bool fComplete;
    public bool Complete
    {
      get { return fComplete; }
      set	{ fComplete = value; }
    }

    public override void FillFtpListingItem(FtpListingItem aItem)
    {
      base.FillFtpListingItem(aItem);
      aItem.Directory = false;
      aItem.Size = Size;
      aItem.UserRead = Complete && UserRead;
      aItem.UserWrite = Complete && UserWrite;
예제 #8
0
 public override void FillFtpListingItem(FtpListingItem item)
 {
     base.FillFtpListingItem(item);
     item.Directory  = false;
     item.Size       = Size;
     item.UserRead   = Complete && UserRead;
     item.UserWrite  = Complete && UserWrite;
     item.UserExec   = false;
     item.GroupRead  = Complete && GroupRead;
     item.GroupWrite = Complete && GroupWrite;
     item.GroupExec  = false;
     item.OtherRead  = Complete && WorldRead;
     item.OtherWrite = Complete && WorldWrite;
     item.OtherExec  = false;
 }
예제 #9
0
        public void ListFolderItems(FtpListing listing)
        {
            /* Add this folder (.) */
            FtpListingItem lListingItem = listing.Add();

            FillFtpListingItem(lListingItem, ".");

            /* Add parent folder (..) */
            if (Parent != null)
            {
                lListingItem = listing.Add();
                Parent.FillFtpListingItem(lListingItem, "..");
            }

            DoListFolderItems(listing);
        }
예제 #10
0
 public virtual void FillFtpListingItem(FtpListingItem item)
 {
     item.Directory  = (this is IFtpFolder);
     item.FileName   = Name;
     item.FileDate   = Date;
     item.Size       = Size;
     item.User       = OwningUser;
     item.Group      = OwningGroup;
     item.UserRead   = UserRead;
     item.UserWrite  = UserWrite;
     item.UserExec   = item.Directory && UserRead;
     item.GroupRead  = GroupRead;
     item.GroupWrite = GroupWrite;
     item.GroupExec  = item.Directory && GroupRead;
     item.OtherRead  = WorldRead;
     item.OtherWrite = WorldWrite;
     item.OtherExec  = item.Directory && WorldRead;
 }
예제 #11
0
   if (aSession.Username == OwningUser && UserRead) return true;
   if (WorldRead) return true;
   return false;
 }
 public virtual bool AllowWrite(VirtualFtpSession aSession)
 {
   if (Invalid) return false;
   if (aSession.IsFileAdmin) return true;
   if (aSession.Username == OwningUser && UserWrite) return true;
   if (WorldWrite) return true;
   return false;
 }
 private bool[] fRights = new bool[6];
 public virtual bool UserRead     { get { return fRights[0]; } set	{ fRights[0] = value; } }
 public virtual bool UserWrite    { get { return fRights[1]; } set	{ fRights[1] = value; } }
 public virtual bool GroupRead    { get { return fRights[2]; } set	{ fRights[2] = value; } }
 public virtual bool GroupWrite   { get { return fRights[3]; } set	{ fRights[3] = value; } }
 public virtual bool WorldRead    { get { return fRights[4]; } set	{ fRights[4] = value; } }
예제 #12
0
		public virtual void FillFtpListingItem(FtpListingItem item, String name)
		{
			FillFtpListingItem(item);
			item.FileName = name;
		}
예제 #13
0
        public void SyncDirectory(string aLocalDirectory, string aRemoteDirectory)
        {
            string lOriginalLocalDirectory  = Directory.GetCurrentDirectory();
            string lOriginalRemoteDirectory = fFtpClient.GetCurrentDirectory();

            try
            {
                #region Step into synchronized directories
                ClientLog(String.Format("Local change directory to {0}", aLocalDirectory));
                Directory.SetCurrentDirectory(aLocalDirectory);

                ClientLog(String.Format("Remote change directory to {0}", aRemoteDirectory));
                fFtpClient.ChangeDirectory(aRemoteDirectory);
                #endregion

                #region Retrieve content
                ClientLog("Retrieving directory contents");
                fFtpClient.List();
                #endregion

                #region Get Local Folders List
                Dictionary <String, DirectoryInfo> lLocalFolders = new Dictionary <String, DirectoryInfo>();
                if (fRecursiveSync)
                {
                    foreach (String lName in Directory.GetDirectories(aLocalDirectory))
                    {
                        DirectoryInfo d = new DirectoryInfo(lName);
                        lLocalFolders.Add(d.Name, d);
                    }
                }
                #endregion

                #region Get Local Files List
                Dictionary <String, FileInfo> lLocalFiles = new Dictionary <String, FileInfo>();
                foreach (String lName in Directory.GetFiles(aLocalDirectory))
                {
                    FileInfo f = new FileInfo(lName);
                    lLocalFiles.Add(f.Name, f);
                }
                #endregion

                #region Get Remote Files and Directories List
                Dictionary <String, FtpListingItem> lRemoteFolders = new Dictionary <string, FtpListingItem>();
                Dictionary <String, FtpListingItem> lRemoteFiles   = new Dictionary <string, FtpListingItem>();
                foreach (FtpListingItem lRemoteItem in fFtpClient.CurrentDirectoryContents)
                {
                    if (lRemoteItem.Directory)
                    {
                        if (fRecursiveSync)
                        {
                            if (lRemoteItem.FileName != "..")
                            {
                                lRemoteFolders.Add(lRemoteItem.FileName, lRemoteItem);
                            }
                        }
                    }
                    else
                    {
                        lRemoteFiles.Add(lRemoteItem.FileName, lRemoteItem);
                    }
                }
                #endregion

                #region Synchronization...
                switch (fSyncMode)
                {
                    #region Local Synchronization. Master: ftp; slave: local;
                case SyncMode.Local:

                    #region Folders synchronization
                    foreach (String lName in lRemoteFolders.Keys)
                    {
                        ClientLog(String.Format("Synchronizing folder '{0}'...", lName));
                        String lLocalItemName = Path.Combine(aLocalDirectory, lName);

                        if (!Directory.Exists(lLocalItemName))
                        {
                            Directory.CreateDirectory(lLocalItemName);
                        }
                        SyncDirectory(lLocalItemName, lName);
                        ClientLog(String.Format("Folder '{0}' has been synchronized", lName));
                        lLocalFolders.Remove(lName);
                    }
                    #region Delete local folders that doesn't exists on FTP
                    if (!fDoNotDeleteMissingItems)
                    {
                        foreach (DirectoryInfo toDelete in lLocalFolders.Values)
                        {
                            toDelete.Delete(true);                                    //delete recursive
                        }
                        lLocalFolders.Clear();
                    }
                    #endregion
                    #endregion

                    #region Files synchronization
                    foreach (String lName in lRemoteFiles.Keys)
                    {
                        FtpListingItem lRemoteItem = lRemoteFiles[lName];
                        Boolean        lNeedSync   = true;
                        if (lLocalFiles.ContainsKey(lName))
                        {
                            FileInfo lLocalItem = lLocalFiles[lName];
                            lNeedSync = (
                                (lLocalItem.Length != lRemoteItem.Size) ||
                                (lLocalItem.LastWriteTime != lRemoteItem.FileDate));
                        }
                        ClientLog(
                            String.Format(
                                "File {0} {1}",
                                lRemoteItem.FileName,
                                lNeedSync ? "requires synchronization." : "doesn't require synchronization."));
                        if (lNeedSync)
                        {
                            ClientLog(String.Format("Downloading {0}...", lRemoteItem.FileName));
                            using (Stream lStream = File.Open(Path.Combine(aLocalDirectory, lName), FileMode.Create))
                            {
                                fFtpClient.Retrieve(lRemoteItem, lStream);
                                lStream.Close();
                                File.SetLastWriteTime(lRemoteItem.FileName, lRemoteItem.FileDate);
                            }
                            ClientLog(String.Format("File {0} has been downloaded.", lRemoteItem.FileName));
                        }
                        lLocalFiles.Remove(lName);
                    }

                    #region Delete local files that doesn't exists on FTP
                    if (!fDoNotDeleteMissingItems)
                    {
                        foreach (FileInfo toDelete in lLocalFiles.Values)
                        {
                            toDelete.Delete();
                        }
                        lLocalFiles.Clear();
                    }
                    #endregion

                    #endregion
                    break;
                    #endregion

                    #region Remote Synchronization.	Master: local; slave: ftp;
                case SyncMode.Remote:

                    #region Folders Synchronization.
                    foreach (String lName in lLocalFolders.Keys)
                    {
                        ClientLog(String.Format("Synchronizing folder '{0}'...", lName));
                        String lLocalItemName = Path.Combine(aLocalDirectory, lName);

                        if (!lRemoteFolders.ContainsKey(lName))
                        {
                            fFtpClient.MakeDirectory(lName);
                        }
                        SyncDirectory(lLocalItemName, lName);
                        ClientLog(String.Format("Folder '{0}' has been synchronized", lName));
                        lRemoteFolders.Remove(lName);
                    }
                    #region Delete FTP folders that doesn't exists locally
                    if (!fDoNotDeleteMissingItems)
                    {
                        foreach (FtpListingItem toDelete in lRemoteFolders.Values)
                        {
                            fFtpClient.RemoveDirectory(toDelete.FileName);
                        }
                        lRemoteFolders.Clear();
                    }
                    #endregion
                    #endregion

                    #region Files Synchronization.
                    foreach (String lName in lLocalFiles.Keys)
                    {
                        String lLocalItemName = Path.Combine(aLocalDirectory, lName);

                        Boolean lNeedSync = true;
                        if (lRemoteFiles.ContainsKey(lName))
                        {
                            FileInfo       lLocalItem  = new FileInfo(lLocalItemName);
                            FtpListingItem lRemoteItem = lRemoteFiles[lName];
                            lNeedSync = (
                                (lLocalItem.Length != lRemoteItem.Size) ||
                                (lLocalItem.LastWriteTime != lRemoteItem.FileDate));
                        }
                        ClientLog(
                            String.Format(
                                "File {0} {1}",
                                lName,
                                lNeedSync ? "requires synchronization." : "doesn't require synchronization."));
                        if (lNeedSync)
                        {
                            ClientLog(String.Format("Uploading {0}...", lName));
                            if (File.Exists(lLocalItemName))
                            {
                                using (FileStream fs = new FileStream(lLocalItemName, FileMode.Open, FileAccess.Read))
                                {
                                    fFtpClient.Store(lName, fs);
                                }
                            }
                            ClientLog(String.Format("File {0} has been uploaded.", lName));
                        }
                        lRemoteFiles.Remove(lName);
                    }

                    #region Delete FTP files that doesn't exist locally
                    if (!fDoNotDeleteMissingItems)
                    {
                        foreach (FtpListingItem toDelete in lRemoteFiles.Values)
                        {
                            fFtpClient.Delete(toDelete.FileName);
                        }
                        lRemoteFiles.Clear();
                    }
                    #endregion

                    #endregion
                    break;
                    #endregion
                }
                #endregion
            }
            finally
            {
                #region Step out of synchronized directories
                Directory.SetCurrentDirectory(lOriginalLocalDirectory);
                ClientLog(String.Format("Local change directory to {0}", lOriginalLocalDirectory));
                fFtpClient.ChangeDirectory(lOriginalRemoteDirectory);
                ClientLog(String.Format("Remote change directory to {0}", lOriginalRemoteDirectory));
                #endregion
            }
        }
예제 #14
0
        public void Parse(String item)
        {
            //Regex lRegEx = new Regex(@"\s+");

            // there is two modes possible Unix mode or MS-DOS mode
            if (item.StartsWith("d") || item.StartsWith("-"))
            {
                /*
                 * Unix Mode
                 * ======================================================================
                 * drwxr-xr-x    3 65025    100          4096 Dec 10 12:13 1 1
                 * drwxr-xr-x    2 65025    100          4096 Dec 10 12:13 2
                 * -rw-r--r--    1 65025    100            35 Dec 10 12:33 root.txt
                 * -rw-r--r--    1 65025    100            43 Dec 10 12:33 root2.txt
                 *
                 *
                 * where
                 * 0 - access
                 * 1 - sub item count
                 * 2 - owner
                 * 3 - group
                 * 4 - size
                 * 5 - Month
                 * 6 - day
                 * 7 - Time or Year
                 * 8 - Filename
                 */
                //String[] lSplittedData = lRegEx.Split(item, 9);
                String[] lSplittedData = ParseLine(item, 9);

                // Copy splitted data to result
                // Problem is that at least one FTP server doesn;t return Group segment
                // So we have to compensate this
                String[] lSegments = new String[9];
                for (Int32 i = 0; i < 3; i++)
                {
                    lSegments[i] = lSplittedData[i];
                }
                for (Int32 i = 1; i <= 6; i++)
                {
                    lSegments[9 - i] = lSplittedData[lSplittedData.Length - i];
                }

                this.Directory  = lSegments[0][0] != '-';
                this.UserRead   = lSegments[0][1] != '-';
                this.UserWrite  = lSegments[0][2] != '-';
                this.UserExec   = lSegments[0][3] != '-';
                this.GroupRead  = lSegments[0][4] != '-';
                this.GroupWrite = lSegments[0][5] != '-';
                this.GroupExec  = lSegments[0][6] != '-';
                this.OtherRead  = lSegments[0][7] != '-';
                this.OtherWrite = lSegments[0][8] != '-';
                this.OtherExec  = lSegments[0][9] != '-';

                this.SubItemCount = Convert.ToInt32(lSegments[1]);
                this.User         = lSegments[2];
                this.Group        = lSegments[3];
                this.Size         = Convert.ToInt64(lSegments[4]);

                String lMonthShortName = lSegments[5];
                String lDay            = lSegments[6];
                String lTimeOrYear     = lSegments[7];

                this.FileDate = FtpListingItem.StringToFtpDate(lMonthShortName, lDay, lTimeOrYear);

                this.FileName = lSegments[8];
            }
            else
            {
                /*
                 * MS-DOS Mode
                 * ======================================================================
                 * 01-14-08  01:35PM       <DIR>          1 1
                 * 01-14-08  01:35PM       <DIR>          2
                 * 01-14-08  01:36PM                   35 root.txt
                 * 01-14-08  01:36PM                   43 root2.txt
                 *
                 * where
                 *
                 * 0 - date
                 * 1 - time
                 * 2 - Size or IsDir
                 * 3 - Filename
                 */
                //String[] lSegments = lRegEx.Split(item, 4);
                String[] lSegments = ParseLine(item, 4);
                this.Directory = (lSegments[2] == "<DIR>");

                this.Size = this.Directory ? 0 : Convert.ToInt64(lSegments[2]);

                String lDateStr = lSegments[0];
                String lTimeStr = lSegments[1];
                this.FileDate = FtpListingItem.StringToFtpDate(lDateStr, lTimeStr);

                this.FileName = lSegments[3];
            }
        }
예제 #15
0
 public virtual void FillFtpListingItem(FtpListingItem item, String name)
 {
     FillFtpListingItem(item);
     item.FileName = name;
 }
예제 #16
0
    public virtual string OwningGroup { get { return fOwningGroup; } set	{ fOwningGroup = value; } }

    public virtual bool AllowRead(VirtualFtpSession aSession)
    {
      if (Invalid) return false;