public static void AddDirectorySecurity(string strPath, string Account, System.Security.AccessControl.FileSystemRights Rights, System.Security.AccessControl.AccessControlType ControlType)
{
System.IO.DirectoryInfo directoryInfo = new System.IO.DirectoryInfo(strPath);
System.Security.AccessControl.DirectorySecurity accessControl = directoryInfo.GetAccessControl();
accessControl.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule(Account, Rights, ControlType));
directoryInfo.SetAccessControl(accessControl);
}
public static void AddFileSecurity(string path, string Account, System.Security.AccessControl.FileSystemRights Rights, System.Security.AccessControl.AccessControlType ControlType)
{
System.IO.FileInfo FINFO = new System.IO.FileInfo(path);
System.Security.AccessControl.FileSecurity FSECURITY = FINFO.GetAccessControl();
FSECURITY.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule(Account, Rights, ControlType));
FINFO.SetAccessControl(FSECURITY);
}
private static void SetDirectoryAccess(string path, IdentityReference user, System.Security.AccessControl.FileSystemRights fileSystemRights)
{
DirectorySecurity directorySecurity = Directory.GetAccessControl(path, AccessControlSections.All);
directorySecurity.AddAccessRule(new FileSystemAccessRule(user, fileSystemRights, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
Directory.SetAccessControl(path, directorySecurity);
}
private async Task <bool> LockFile(System.IO.FileShare fshare = FileShare.Read, System.Security.AccessControl.FileSystemRights fSysRights = FileSystemRights.Read, System.IO.FileAccess fAccess = FileAccess.Read, System.IO.FileMode fMode = FileMode.Open, System.IO.FileOptions fOptions = FileOptions.None)
{
int num = 0;
bool flag = false;
Stopwatch SW = new Stopwatch();
SW.Start();
while (!flag && (num < 2000) && (SW.ElapsedMilliseconds < 30000))
{
//Try
if (!this.IsFileInUse(fshare, fSysRights, fAccess, fMode, fOptions))
{
if (fMode == FileMode.OpenOrCreate || fAccess == FileAccess.ReadWrite || fAccess == FileAccess.Write)
{
try
{
this.m_fileStream.Lock(this.m_fileStream.Length, 0xFFFF);
this.m_WasLocked = true;
this.FileExists = true;
}
catch (Exception ex)
{
Console.WriteLine(" LockFile Error: " + ex.Message);
}
}
}
else
{
num += 1;
await Task.Delay(10); //'Thread.Sleep(10)
continue;
}
//Catch exception1 As Exception
// num += 1
// Thread.Sleep(10)
// Continue Do
//End Try
flag = true;
}
SW.Stop();
if (num > 0)
{
Console.WriteLine(" Lockfile lock time: " + SW.ElapsedMilliseconds + "ms, errcount=" + num);
}
return(flag);
}
private bool IsFileInUse(System.IO.FileShare fshare = FileShare.Read, System.Security.AccessControl.FileSystemRights fSysRights = FileSystemRights.Read, System.IO.FileAccess fAccess = FileAccess.Read, System.IO.FileMode fMode = FileMode.Open, System.IO.FileOptions fOptions = FileOptions.None)
{
bool inUse = false;
try
{
do
{
this.m_fileHandle = CreateFile(this.m_path, fSysRights, fshare, IntPtr.Zero, fMode, FileOptions.None, IntPtr.Zero);
if (this.m_fileHandle.IsInvalid)
{
int LastErr = Marshal.GetLastWin32Error();
//Console.WriteLine("IsFileInUse LastErr: " & LastErr & ", " & New Win32Exception(LastErr).Message, , , False)
inUse = true;
if (LastErr == ERROR_SHARING_VIOLATION || LastErr == ERROR_LOCK_VIOLATION)
{
if (!this.m_fileHandle.IsClosed)
{
this.m_fileHandle.Close();
}
}
else
{
//Me.m_fileStream = New FileStream(m_fileHandle, fAccess)
}
}
else
{
this.m_fileStream = new FileStream(this.m_fileHandle, fAccess);
}
break;
} while (true);
}
catch (Exception ex)
{
Console.WriteLine("IsFileInUse Error: " + ex.Msg());
inUse = true;
}
finally
{
}
return(inUse);
}
/// <summary>
/// Verify that a specific user has access rights to a specific File
/// </summary>
/// <param name="userName">Name of the user to check for</param>
/// <param name="filePath">Full path to the file to check</param>
/// <param name="rights"><>Expected access rights/param>
public static void VerifyFilePermession(string userName, string filePath, System.Security.AccessControl.FileSystemRights rights)
{
FileSecurity fileSecurity = System.IO.File.GetAccessControl(filePath);
AuthorizationRuleCollection accessRules = fileSecurity.GetAccessRules(true, true, typeof(NTAccount));
foreach (FileSystemAccessRule accessRule in accessRules)
{
if (userName.ToLowerInvariant().Equals(accessRule.IdentityReference.Value.ToLowerInvariant()))
{
if ((accessRule.FileSystemRights & rights) == rights)
{
return;
}
}
}
Assert.True(false, string.Format("User '{0}' do not have permession to File '{1}'.", userName, filePath));
}
/// <span class="code-SummaryComment"><summary></span>
/// Convenience method to test if the right exists within the given rights
/// <span class="code-SummaryComment"></summary></span>
/// <span class="code-SummaryComment"><param name="right"></param></span>
/// <span class="code-SummaryComment"><param name="rule"></param></span>
/// <span class="code-SummaryComment"><returns></returns></span>
public bool contains(System.Security.AccessControl.FileSystemRights right,
System.Security.AccessControl.FileSystemAccessRule rule)
{
return(((int)right & (int)rule.FileSystemRights) == (int)right);
}
public static System.IO.FileStream Create(this System.IO.FileInfo fileInfo, System.IO.FileMode mode, System.Security.AccessControl.FileSystemRights rights, System.IO.FileShare share, int bufferSize, System.IO.FileOptions options, System.Security.AccessControl.FileSecurity fileSecurity)
{
throw null;
}
public static void SetDirectoryAccessBySID(string path, string sidString, System.Security.AccessControl.FileSystemRights fileSystemRights)
{
SecurityIdentifier sid = new SecurityIdentifier(sidString);
SetDirectoryAccess(path, sid, fileSystemRights);
}
public static void SetDirectoryAccessByUserName(string path, string userName, System.Security.AccessControl.FileSystemRights fileSystemRights)
{
NTAccount userAccount = new NTAccount(userName);
SetDirectoryAccess(path, userAccount, fileSystemRights);
}
public static bool DoesUserHaveAccessToDirectory(string path, string usernameOrSID, System.Security.AccessControl.FileSystemRights fileSystemRights)
{
DirectorySecurity directorySecurity = Directory.GetAccessControl(path, AccessControlSections.All);
foreach (FileSystemAccessRule fileSystemAccessRule in directorySecurity.GetAccessRules(true, true, typeof(NTAccount)))
{
IdentityReference sidIdentityReference = fileSystemAccessRule.IdentityReference.Translate(typeof(SecurityIdentifier));
Debug.WriteLine(String.Format("IdentityReference: {0}", fileSystemAccessRule.IdentityReference.Value));
Debug.WriteLine(String.Format("FileSystemRights: {0}", fileSystemAccessRule.FileSystemRights));
Debug.WriteLine("");
if (
(usernameOrSID.Equals(fileSystemAccessRule.IdentityReference.Value, StringComparison.InvariantCultureIgnoreCase) == true ||
usernameOrSID.Equals(sidIdentityReference.Value, StringComparison.InvariantCultureIgnoreCase) == true) &&
(fileSystemAccessRule.FileSystemRights & fileSystemRights) == fileSystemRights)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Verify that a specific user has access rights to a specific Folder
/// </summary>
/// <param name="userName">Name of the user to check for</param>
/// <param name="filePath">Full path to the folder to check</param>
/// <param name="rights"><>Expected access rights/param>
public static void VerifyFolderPermession(string userName, string directoryPath, System.Security.AccessControl.FileSystemRights rights)
{
DirectorySecurity directorySecurity = Directory.GetAccessControl(directoryPath);
AuthorizationRuleCollection accessRules = directorySecurity.GetAccessRules(true, true, typeof(NTAccount));
foreach (FileSystemAccessRule accessRule in accessRules)
{
if (userName.ToLowerInvariant().Equals(accessRule.IdentityReference.Value.ToLowerInvariant()))
{
if ((accessRule.FileSystemRights & rights) == rights)
{
return;
}
}
}
Assert.Fail(string.Format("User '{0}' do not have permession to folder '{1}'.", userName, directoryPath));
}
