public SftpFileInfo(string name, string directoryName, ulong length, PermissionsFlags permissions, DateTime lastAccessTime, DateTime lastWriteTime)
{
this.Name = name;
this.DirectoryName = directoryName;
this.Length = length;
this.Permissions = permissions;
this.LastAccessTime = lastAccessTime;
this.LastWriteTime = lastWriteTime;
}
/// <summary>
/// Creates virtual directory under site with given name and sets authorization rules.
/// </summary>
/// <param name="siteName">Site name.</param>
/// <param name="account">Account information.</param>
public void CreateFtpAccount(string siteName, FtpAccount account)
{
Site site = this.GetIisSite(siteName);
if (site != null)
{
Application application = site.Applications["/"];
if (application != null)
{
// Convert FTP account name to virtual directory format
var ftpVirtualDir = String.Format("/{0}", account.Name);
//
VirtualDirectory accountDirectory = application.VirtualDirectories[ftpVirtualDir];
//
if (accountDirectory != null)
{
application.VirtualDirectories.Remove(accountDirectory);
}
VirtualDirectory createdVirtualDirectory = application.VirtualDirectories.Add(ftpVirtualDir, account.Folder);
AuthorizationRuleCollection authRulesCollection = this.GetAuthorizationRuleCollection(String.Format("{0}/{1}", siteName, account.Name));
List <AuthorizationRule> rulesToRemove = new List <AuthorizationRule>();
foreach (AuthorizationRule rule in authRulesCollection)
{
if (rule.AccessType == AuthorizationRuleAccessType.Allow && (rule.Users == "?" || rule.Users == "*"))
{
rulesToRemove.Add(rule);
}
}
foreach (AuthorizationRule rule in rulesToRemove)
{
authRulesCollection.Remove(rule);
}
PermissionsFlags permissions = 0;
if (account.CanRead)
{
permissions |= PermissionsFlags.Read;
}
if (account.CanWrite)
{
permissions |= PermissionsFlags.Write;
}
if (account.CanRead || account.CanWrite)
{
authRulesCollection.Add(AuthorizationRuleAccessType.Allow, account.Name, String.Empty, permissions);
}
}
}
this.CommitChanges();
}
/// <summary>
/// Fills iis configuration from ftp account.
/// </summary>
/// <param name="ftpAccount">Ftp account to fill from.</param>
private void FillIisFromFtpAccount(FtpAccount ftpAccount)
{
// Remove permissions if required.
string currentPhysicalPath = this.ftpSitesService.GetSitePhysicalPath(this.SiteId, String.Format("/{0}", ftpAccount.Name));
if (String.Compare(currentPhysicalPath, ftpAccount.Folder, true) != 0)
{
RemoveFtpFolderPermissions(currentPhysicalPath, ftpAccount.Name);
}
// Set new permissions
EnsureUserHomeFolderExists(ftpAccount.Folder, ftpAccount.Name, ftpAccount.CanRead, ftpAccount.CanWrite);
// Update physical path.
this.ftpSitesService.SetSitePhysicalPath(this.SiteId, ftpAccount.VirtualPath, ftpAccount.Folder);
// Configure connect as feature.
this.ftpSitesService.ConfigureConnectAs(ftpAccount.Folder, this.SiteId, ftpAccount.VirtualPath,
this.GetQualifiedAccountName(ftpAccount.Name), ftpAccount.Password, false);
// Update authorization rules.
AuthorizationRuleCollection authRulesCollection = this.ftpSitesService.GetAuthorizationRuleCollection(String.Format("{0}/{1}", this.SiteId, ftpAccount.Name));
AuthorizationRule realtedRule = null;
foreach (AuthorizationRule rule in authRulesCollection)
{
IList <string> users = rule.Users.Split(',');
if (users.Contains(ftpAccount.Name))
{
realtedRule = rule;
}
}
if (realtedRule != null)
{
PermissionsFlags permissions = 0;
if (ftpAccount.CanRead)
{
permissions |= PermissionsFlags.Read;
}
if (ftpAccount.CanWrite)
{
permissions |= PermissionsFlags.Write;
}
if (ftpAccount.CanRead || ftpAccount.CanWrite)
{
realtedRule.Permissions = permissions;
}
}
this.ftpSitesService.CommitChanges();
}
public AuthorizationRule this[string users, string roles, PermissionsFlags permissions]
{
get
{
for (int i = 0; i < base.Count; i++)
{
AuthorizationRule rule = base[i];
if ((string.Equals(rule.Users, users, StringComparison.OrdinalIgnoreCase) && string.Equals(rule.Roles, roles, StringComparison.OrdinalIgnoreCase)) && (rule.Permissions == permissions))
{
return(rule);
}
}
return(null);
}
}
private void AddAuthorizationRules(string siteName, PropertyBag authBag)
{
PermissionsFlags permissions = (PermissionsFlags)authBag[3];
string str = (string)authBag[1];
string str2 = (string)authBag[2];
AuthorizationRuleCollection authorizationRuleCollection = this.GetAuthorizationRuleCollection(siteName);
if (!string.IsNullOrEmpty(str))
{
authorizationRuleCollection.Add(AuthorizationRuleAccessType.Allow, str, string.Empty, permissions);
}
if (!string.IsNullOrEmpty(str2))
{
authorizationRuleCollection.Add(AuthorizationRuleAccessType.Allow, string.Empty, str2, permissions);
}
}
public AuthorizationRule Add(AuthorizationRuleAccessType accessType, string users, string roles, PermissionsFlags permissions)
{
AuthorizationRule element = base.CreateElement();
element.AccessType = accessType;
if (!string.IsNullOrEmpty(users))
{
element.Users = users;
}
if (!string.IsNullOrEmpty(roles))
{
element.Roles = roles;
}
element.Permissions = permissions;
return(base.Add(element));
}
